Włącz wymuszanie Sprawdzania aplikacji w Cloud Functions

Gdy poznasz wpływ App Check na użytkowników i będziesz gotowy do dalszych działań, możesz włączyć App Check w przypadku funkcji wywoływalnych.

Włączanie egzekwowania

Aby zacząć egzekwować wymagania dotyczące tokena App Check w funkcjach wywoływanych, zmodyfikuj swoje funkcje, aby sprawdzać poprawność tokenów App Check, jak pokazano poniżej. Gdy włączysz wymuszanie, wszystkie niezweryfikowane żądania będą odrzucane.

  1. Zainstaluj pakiet SDK Cloud Functions.

    Node.js (1 generacja)

    Zaktualizuj zależność firebase-functions projektu do wersji 4.0.0 lub nowszej:

    npm install firebase-functions@">=4.0.0"

    Node.js (2 generacji)

    Zaktualizuj zależność firebase-functions w projekcie do wersji 4.0.0 lub nowszej:

    npm install firebase-functions@">=4.0.0"

    Python (wersja testowa)

    Dodaj firebase-functions do functions/requirements.txt:

    firebase-functions >= 0.1.0

    Następnie zaktualizuj zależności w środowisku wirtualnym projektu:

    ./venv/bin/pip install -r requirements.txt

  2. Włącz opcję wymuszania Sprawdzania aplikacji w przypadku swojej funkcji:

    Node.js (1 generacja)

    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 (2 generacji)

    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 (wersja testowa)

    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. Ponownie wdróż funkcje:

    firebase deploy --only functions

Po wdrożenie tych zmian funkcje wywoływane będą wymagać prawidłowych tokenów App Check. Pakiety SDK klienta Cloud Functions automatycznie dołączają token App Check, gdy wywołasz funkcję wywołującą.

Ochrona przed ponownym odtwarzaniem (beta)

Aby chronić wywoływaną funkcję przed atakami typu replay, możesz użyć tokenu AppCheck po jego zweryfikowaniu. Po wykorzystaniu tokena nie można go użyć ponownie.

Pamiętaj, że używanie ochrony przed odtwarzaniem zwiększa opóźnienie związane z weryfikacją tokena, a tym samym opóźnia wywołanie funkcji. Z tego powodu większość aplikacji zwykle włącza ochronę przed odtwarzaniem tylko na szczególnie wrażliwych punktach końcowych.

Aby wykorzystać tokeny:

  1. W konsoli Cloud przyznaj roli „Firebase App Check Token Verifier” konto usługi używane przez funkcję.

    • Jeśli inicjujesz pakiet SDK administratora w sposób jawny i podasz poświadczenia konta usługi pakietu SDK administratora projektu, wymagana rola jest już przypisana.
    • Jeśli używasz Cloud Functions pierwszej generacji z domyślną konfiguracją AdminSDK, przypisz tę rolę do domyślnego konta usługi App Engine. Zobacz Zmienianie uprawnień konta usługi.
    • Jeśli używasz Cloud Functions 2 generacji z domyślną konfiguracją interfejsu AdminSDK, przypisz tę rolę do domyślnego konta usługi Compute.

  2. W definicji funkcji ustaw wartość consumeAppCheckToken na true:

    Node.js (1 generacja)

    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 (2 generacji)

    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. Zaktualizuj kod klienta aplikacji, aby po wywołaniu funkcji pobierać tokeny do jednorazowego użytku:

    Swift

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

    Web 

    import { getFunctions, httpsCallable } from "firebase/functions";

const yourCallableFunction = httpsCallable(
  getFunctions(),
  "yourCallableFunction",
  { limitedUseAppCheckTokens: true },
);
await yourCallableFunction();

    Kotlin 

    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();