Questa pagina è stata tradotta dall'API Cloud Translation.

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 i token, imposta consumeAppCheckToken su true nella definizione della 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.
    ...
  }
);

Quando abiliti questa funzione per una particolare funzione cloud, devi anche aggiornare il codice client dell'app per acquisire token consumabili a utilizzo 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 {
    // ...
}

Web modular API

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