Activer l’application d’App Check pour Cloud Functions

Lorsque vous comprenez comment App Check affectera vos utilisateurs et que vous êtes prêt à continuer, vous pouvez activer l'application d'App Check.

Activation de l'application

Pour commencer à appliquer les exigences en matière de jetons App Check dans vos fonctions Cloud appelables, modifiez vos fonctions pour vérifier les jetons App Check valides, comme indiqué ci-dessous. Une fois que vous aurez activé l’application, toutes les demandes non vérifiées seront rejetées.

  1. Installez le SDK Cloud Functions.

    Node.js (1ère génération)

    Mettez à jour la dépendance firebase-functions de votre projet vers la version 4.0.0 ou une version ultérieure :

    npm install firebase-functions@">=4.0.0"
    

    Node.js (2e génération)

    Mettez à jour la dépendance firebase-functions de votre projet vers la version 4.0.0 ou une version ultérieure :

    npm install firebase-functions@">=4.0.0"
    

    Python (aperçu)

    Ajoutez firebase-functions à functions/requirements.txt :

    firebase-functions >= 0.1.0
    

    Ensuite, mettez à jour les dépendances dans l'environnement virtuel de votre projet :

    ./venv/bin/pip install -r requirements.txt
    
  2. Activez l’option d’exécution d’application App Check pour votre fonction :

    Node.js (1ère génération)

    const functions = require("firebase-functions/v1");
    
    exports.yourV1CallableFunction = functions
      .runWith({
          enforceAppCheck: true, // Reject requests with missing or invalid App Check tokens.
      })
      .https.onCall((data, context) => {
            // context.app contains data from App Check, including the app ID.
            // Your function logic follows.
            ...
      });
    

    Node.js (2e génération)

    const { onCall } = require("firebase-functions/v2/https");
    
    exports.yourV2CallableFunction = onCall(
      {
        enforceAppCheck: true, // Reject requests with missing or invalid App Check tokens.
      },
      (request) => {
        // request.app contains data from App Check, including the app ID.
        // Your function logic follows.
        ...
      }
    );
    

    Python (aperçu)

    from firebase_functions import https_fn
    
    @https_fn.on_call(
        enforce_app_check=True  # Reject requests with missing or invalid App Check tokens.
    )
    def your_callable_function(req: https_fn.CallableRequest) -> https_fn.Response:
        # req.app contains data from App Check, including the app ID.
        # Your function logic follows.
        ...
    
  3. Redéployez vos fonctions :

    firebase deploy --only functions
    

Une fois ces modifications déployées, vos fonctions Cloud appelables nécessiteront des jetons App Check valides. Les SDK client Cloud Functions attachent automatiquement un jeton App Check lorsque vous appelez une fonction appelable.

Protection contre la relecture (bêta)

Pour protéger une fonction appelable contre les attaques par relecture, vous pouvez utiliser le jeton App Check après l'avoir vérifié. Une fois le jeton consommé, il ne peut plus être utilisé.

Notez que l'utilisation de la protection contre la relecture ajoute un aller-retour réseau à la vérification du jeton, et ajoute donc une latence à l'appel de la fonction cloud. Pour cette raison, la plupart des applications activent généralement la protection contre la relecture uniquement sur les points de terminaison particulièrement sensibles.

Pour consommer des jetons :

  1. Dans la console Cloud , accordez le rôle « Firebase App Check Token Verifier » au compte de service utilisé par la fonction Cloud.

    • Si vous initialisez explicitement le SDK Admin et que vous avez spécifié les informations d'identification du compte de service du SDK Admin de votre projet, le rôle requis est déjà accordé.
    • Si vous utilisez Cloud Functions de 1re génération avec la configuration par défaut du SDK Admin, accordez le rôle au compte de service par défaut d'App Engine . Voir Modification des autorisations du compte de service .
    • Si vous utilisez Cloud Functions de 2e génération avec la configuration du SDK Admin par défaut, accordez le rôle au compte de service de calcul par défaut .
  2. Définissez consumeAppCheckToken sur true dans la définition de votre fonction :

    Node.js (1ère génération)

    const functions = require("firebase-functions/v1");
    
    exports.yourV1CallableFunction = functions
      .runWith({
          enforceAppCheck: true, // Reject requests with missing or invalid App Check tokens.
          consumeAppCheckToken: true  // Consume the token after verification.
      })
      .https.onCall((data, context) => {
          // context.app contains data from App Check, including the app ID.
          // Your function logic follows.
          ...
      });
    

    Node.js (2e génération)

    const { onCall } = require("firebase-functions/v2/https");
    
    exports.yourV2CallableFunction = onCall(
      {
        enforceAppCheck: true, // Reject requests with missing or invalid App Check tokens.
        consumeAppCheckToken: true  // Consume the token after verification.
      },
      (request) => {
        // request.app contains data from App Check, including the app ID.
        // Your function logic follows.
        ...
      }
    );
    
  3. Mettez à jour le code client de votre application pour acquérir des jetons consommables à usage limité lorsque vous appelez la fonction :

    Rapide

    let options = HTTPSCallableOptions(requireLimitedUseAppCheckTokens: true)
    let yourCallableFunction =
        Functions.functions().httpsCallable("yourCallableFunction", options: options)
    do {
        let result = try await yourCallableFunction.call()
    } catch {
        // ...
    }
    

    API modulaire Web

    import { getFunctions, httpsCallable } from "firebase/functions";
    
    const yourCallableFunction = httpsCallable(
      getFunctions(),
      "yourCallableFunction",
      { limitedUseAppCheckTokens: true },
    );
    await yourCallableFunction();
    

    Kotlin+KTX

    val yourCallableFunction = Firebase.functions.getHttpsCallable("yourCallableFunction") {
        limitedUseAppCheckTokens = true
    }
    val result = yourCallableFunction.call().await()
    

    Java

    HttpsCallableReference yourCallableFunction = FirebaseFunctions.getInstance().getHttpsCallable(
            "yourCallableFunction",
            new HttpsCallableOptions.Builder()
                    .setLimitedUseAppCheckTokens(true)
                    .build()
    );
    Task<HttpsCallableResult> result = yourCallableFunction.call();