Włącz wymuszanie sprawdzania aplikacji dla Cloud Functions

Gdy zrozumiesz, w jaki sposób Sprawdzanie aplikacji wpłynie na Twoich użytkowników i będziesz gotowy do kontynuowania, możesz włączyć wymuszanie Sprawdzania aplikacji.

Włączanie egzekwowania

Aby rozpocząć wymuszanie wymagań dotyczących tokenów sprawdzania aplikacji w wywoływalnych funkcjach Cloud Functions, zmodyfikuj swoje funkcje, aby sprawdzały prawidłowe tokeny sprawdzania aplikacji, jak pokazano poniżej. Po włączeniu egzekwowania wszystkie niezweryfikowane prośby zostaną odrzucone.

Zainstaluj pakiet Cloud Functions SDK.
Node.js (pierwsza generacja)
Zaktualizuj zależność firebase-functions swojego projektu do wersji 4.0.0 lub nowszej:
```
npm install firebase-functions@">=4.0.0"
```
Node.js (2. generacji)
Zaktualizuj zależność firebase-functions swojego projektu do wersji 4.0.0 lub nowszej:
```
npm install firebase-functions@">=4.0.0"
```
Python (podgląd)
Dodaj firebase-functions do functions/requirements.txt :
```
firebase-functions >= 0.1.0
```
Następnie zaktualizuj zależności w środowisku wirtualnym swojego projektu:
```
./venv/bin/pip install -r requirements.txt
```

Włącz opcję środowiska uruchomieniowego wymuszania sprawdzania aplikacji dla swojej funkcji:

Node.js (pierwsza 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 (podgląd)

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óż swoje funkcje:
```
firebase deploy --only functions
```

Po wdrożeniu tych zmian wywoływalne funkcje Cloud Functions będą wymagały prawidłowych tokenów sprawdzania aplikacji. Pakiety SDK klienta Cloud Functions automatycznie dołączają token sprawdzania aplikacji, gdy wywołujesz funkcję wywoływalną.

Ochrona powtórek (beta)

Aby chronić wywoływalną funkcję przed atakami powtórkowymi, możesz użyć tokenu sprawdzania aplikacji po jego zweryfikowaniu. Po zużyciu żetonu nie można go ponownie użyć.

Należy pamiętać, że korzystanie z ochrony powtórek dodaje podróż w obie strony do weryfikacji tokenu, a zatem dodaje opóźnienie do wywołania funkcji w chmurze. Z tego powodu większość aplikacji zazwyczaj włącza ochronę powtórek tylko na szczególnie wrażliwych punktach końcowych.

Aby wykorzystać tokeny:

W konsoli Cloud przydziel rolę „Weryfikator tokenów kontrolnych aplikacji Firebase” kontu usługi używanemu przez funkcję Cloud.
- Jeśli jawnie inicjujesz pakiet Admin SDK i określiłeś poświadczenia konta usługi Admin SDK swojego projektu, wymagana rola została już przyznana.
- Jeśli używasz Cloud Functions 1. generacji z domyślną konfiguracją pakietu Admin SDK, nadaj rolę domyślnemu kontu usługi App Engine . Zobacz Zmiana uprawnień konta usługi .
- Jeśli używasz Cloud Functions drugiej generacji z domyślną konfiguracją pakietu Admin SDK, nadaj rolę domyślnemu kontu usługi obliczeniowej .

Ustaw consumeAppCheckToken na true w swojej definicji funkcji:

Node.js (pierwsza 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 uzyskiwać zużywalne tokeny o ograniczonym użyciu po wywołaniu funkcji:

Szybki

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

Modułowy interfejs API sieci 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();