Włącz wymuszanie sprawdzania aplikacji dla Cloud Functions

Kiedy już zrozumiesz, jak Kontrola aplikacji wpłynie na Twoich użytkowników i będziesz gotowy, aby kontynuować, możesz włączyć wymuszanie Sprawdzania aplikacji.

Umożliwianie egzekwowania

Aby rozpocząć egzekwowanie wymagań dotyczących tokenów Sprawdzania aplikacji w wywoływalnych funkcjach Cloud Functions, zmodyfikuj swoje funkcje, tak aby sprawdzały prawidłowe tokeny Sprawdzania aplikacji, jak pokazano poniżej. Po włączeniu wymuszania wszystkie niezweryfikowane żądania zostaną odrzucone.

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

Wdróż ponownie swoje funkcje:
```
firebase deploy --only functions
```

Po wdrożeniu tych zmian wywoływalne funkcje Cloud Functions będą wymagały ważnych tokenów sprawdzania aplikacji. Pakiety SDK klienta Cloud Functions automatycznie dołączają token sprawdzania aplikacji, gdy wywołujesz funkcję, którą można wywołać.

Ochrona przed powtórkami (beta)

Aby chronić wywoływaną funkcję przed atakami związanymi z powtarzaniem, możesz wykorzystać token Sprawdzania aplikacji po jego zweryfikowaniu. Po zużyciu żetonu nie można go użyć ponownie.

Należy pamiętać, że korzystanie z ochrony przed powtarzaniem dodaje objazd sieciowy do weryfikacji tokenu, a zatem zwiększa opóźnienie wywołania funkcji chmury. Z tego powodu większość aplikacji zazwyczaj włącza ochronę przed ponownym odtwarzaniem tylko na szczególnie wrażliwych punktach końcowych.

Aby zużyć tokeny:

W konsoli Cloud przydziel rolę „Weryfikator tokenu sprawdzania aplikacji Firebase” kontu usługi używanemu przez funkcję Cloud.
- Jeśli jawnie inicjujesz pakiet Admin SDK i określisz poświadczenia konta usługi Admin SDK swojego projektu, wymagana rola została już przyznana.
- Jeśli używasz Cloud Functions pierwszej generacji z domyślną konfiguracją pakietu Admin SDK, przypisz 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, przypisz rolę domyślnemu kontu usługi obliczeniowej .

Ustaw consumeAppCheckToken na true w 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 uzyskać tokeny o ograniczonym użyciu, gdy wywołasz funkcję:

Szybki

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

Modułowe API sieciowe

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