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ć egzekwowanie App Check.

Włączanie egzekwowania

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

Zainstaluj pakiet SDK Cloud Functions.
Node.js (1 generacja)
Zaktualizuj zależność firebase-functions w projekcie 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
```

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.
    ...

Ponownie wdróż funkcje:
```
firebase deploy --only functions
```

Po wdrożeniu tych zmian wywoływalna usługa Cloud Functions będzie 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 korzystanie z funkcji ochrony przed odtwarzaniem powoduje dodatkowy przesył danych przez sieć w celu weryfikacji tokena, co wydłuża czas wywołania funkcji w chmurze. Z tego powodu większość aplikacji włącza ochronę przed odtwarzaniem tylko na szczególnie wrażliwych punktach końcowych.

Aby wykorzystać tokeny:

W konsoli Cloud przyznaj roli „Firebase App Check Token Verifier” konto usługi używane przez funkcję Cloud Functions.
- 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ą Admin SDK, przypisz tę rolę do domyślnego konta usługi Compute.

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.
    ...
  }
);

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