Abilita l'applicazione di App Check per le funzioni cloud

Quando capisci in che modo App Check influirà sui tuoi utenti e sei pronto a procedere, puoi abilitare l'applicazione di App Check.

Abilitazione dell'applicazione

Per iniziare ad applicare i requisiti del token App Check nelle tue Cloud Functions richiamabili, modifica le tue funzioni per verificare la presenza di token App Check validi, come mostrato di seguito. Una volta abilitata l'applicazione, tutte le richieste non verificate verranno respinte.

Installa l'SDK di Cloud Functions.
Node.js (prima generazione)
Aggiorna la dipendenza firebase-functions del tuo progetto alla versione 4.0.0 o successiva:
```
npm install firebase-functions@">=4.0.0"
```
Node.js (2ª generazione)
Aggiorna la dipendenza firebase-functions del tuo progetto alla versione 4.0.0 o successiva:
```
npm install firebase-functions@">=4.0.0"
```
Python (anteprima)
Aggiungi firebase-functions a functions/requirements.txt :
```
firebase-functions >= 0.1.0
```
Quindi, aggiorna le dipendenze nell'ambiente virtuale del tuo progetto:
```
./venv/bin/pip install -r requirements.txt
```

Abilita l'opzione di esecuzione del runtime di App Check per la tua funzione:

Node.js (prima generazione)

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ª generazione)

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

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

Ridistribuisci le tue funzioni:
```
firebase deploy --only functions
```

Una volta implementate queste modifiche, le tue Cloud Functions richiamabili richiederanno token App Check validi. Gli SDK del client Cloud Functions allegano automaticamente un token App Check quando richiami una funzione richiamabile.

Protezione dalla riproduzione (beta)

Per proteggere una funzione richiamabile dagli attacchi di riproduzione, puoi utilizzare il token App Check dopo averlo verificato. Una volta consumato, il token non può essere riutilizzato.

Tieni presente che l'utilizzo della protezione dalla riproduzione aggiunge un round trip di rete alla verifica del token e quindi aggiunge latenza alla chiamata della funzione cloud. Per questo motivo, la maggior parte delle app in genere abilita la protezione dalla riproduzione solo su endpoint particolarmente sensibili.

Per consumare token:

Nella console Cloud , concedi il ruolo "Firebase App Check Token Verifier" all'account di servizio utilizzato dalla funzione Cloud.
- Se stai inizializzando in modo esplicito Admin SDK e hai specificato le credenziali dell'account di servizio Admin SDK del tuo progetto, il ruolo richiesto è già concesso.
- Se utilizzi Cloud Functions di prima generazione con la configurazione SDK Admin predefinita, concedi il ruolo all'account di servizio predefinito di App Engine . Vedere Modifica delle autorizzazioni dell'account di servizio .
- Se utilizzi Cloud Functions di seconda generazione con la configurazione SDK di amministrazione predefinita, concedi il ruolo all'account di servizio di calcolo predefinito .

Imposta consumeAppCheckToken su true nella definizione della tua funzione:

Node.js (prima generazione)

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ª generazione)

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

Aggiorna il codice client dell'app per acquisire token consumabili a uso limitato quando chiami la funzione:

Rapido

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

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