Habilita la aplicación forzosa de la Verificación de aplicaciones para Cloud Functions

Cuando comprendas cómo App Check afectará a tus usuarios y estés listo para continuar, puedes habilitar la aplicación forzosa de App Check.

Habilita la aplicación forzosa

Para comenzar a aplicar de manera forzosa los requisitos del token de App Check en tus Cloud Functions que admiten llamadas, modifica las funciones para comprobar los tokens de App Check válidos, como se muestra a continuación. Una vez que habilites la aplicación forzosa, se rechazarán todas las solicitudes no verificadas.

Instala el SDK de Cloud Functions.
Node.js (1ª gen.)
Actualiza la dependencia firebase-functions del proyecto a la versión 4.0.0 o una posterior:
```
npm install firebase-functions@">=4.0.0"
```
Node.js (2ª gen.)
Actualiza la dependencia firebase-functions del proyecto a la versión 4.0.0 o una posterior:
```
npm install firebase-functions@">=4.0.0"
```
Python (vista previa)
Agrega firebase-functions a functions/requirements.txt:
```
firebase-functions >= 0.1.0
```
Luego, actualiza las dependencias en el entorno virtual de tu proyecto:
```
./venv/bin/pip install -r requirements.txt
```

Habilita la opción del entorno de ejecución de la aplicación forzosa de la Verificación de aplicaciones para la función:

Node.js (1ª gen.)

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ª gen.)

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 (vista previa)

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

Vuelve a implementar las funciones:
```
firebase deploy --only functions
```

Una vez que se implementen estos cambios, tus Cloud Functions que admiten llamadas requerirán tokens de App Check válidos. Los SDK de cliente de Cloud Functions adjuntan un token de App Check de forma automática cuando se invoca una función que admite llamadas.

Protección contra la repetición (beta)

Para proteger una función que admite llamadas de los ataques de repetición, puedes consumir el token de la Verificación de aplicaciones después de verificarlo. Una vez que se consume, no se puede volver a usar.

Ten en cuenta que el uso de la protección contra la repetición agrega un proceso de ida y vuelta en la red a la verificación de tokens y, por lo tanto, agrega latencia a la llamada de Cloud Function. Por este motivo, la mayoría de las apps suelen habilitar la protección contra la reproducción solo en extremos particularmente sensibles.

Para consumir tokens, haz lo siguiente:

En Cloud Console, otorga el rol “Verificador de tokens de Verificación de aplicaciones de Firebase” a la cuenta de servicio que usa la Cloud Function.
- Si inicializas explícitamente el SDK de Admin y especificaste las credenciales de la cuenta de servicio del SDK de Admin de tu proyecto, el rol requerido ya está otorgado.
- Si usas Cloud Functions de primera generación con la configuración predeterminada del SDK de Admin, otorga el rol a la cuenta de servicio predeterminada de App Engine. Consulta Cambia los permisos de la cuenta de servicio.
- Si usas Cloud Functions de segunda generación con la configuración predeterminada del SDK de Admin, otorga el rol a la cuenta de servicio predeterminada de Compute.

Establece consumeAppCheckToken como true en la definición de la función:

Node.js (1ª gen.)

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ª gen.)

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

Actualiza el código de cliente de tu app para adquirir tokens de uso limitado consumibles cuando llames a la función:

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