Esta página foi traduzida pela API Cloud Translation.

Ativar a aplicação do App Check para Cloud Functions

Quando você entender como o App Check afetará seus usuários e estiver pronto para prosseguir, poderá ativar a aplicação do App Check.

Habilitando a aplicação

Para começar a aplicar os requisitos de token do App Check nas Cloud Functions que podem ser chamadas, modifique suas funções para verificar tokens válidos do App Check, conforme mostrado abaixo. Depois de ativar a aplicação, todas as solicitações não verificadas serão rejeitadas.

Instale o SDK do Cloud Functions.
Node.js (1ª geração)
Atualize a dependência firebase-functions do seu projeto para a versão 4.0.0 ou mais recente:
```
npm install firebase-functions@">=4.0.0"
```
Node.js (2ª geração)
Atualize a dependência firebase-functions do seu projeto para a versão 4.0.0 ou mais recente:
```
npm install firebase-functions@">=4.0.0"
```
Python (visualização)
Adicione firebase-functions a functions/requirements.txt :
```
firebase-functions >= 0.1.0
```
Em seguida, atualize as dependências no ambiente virtual do seu projeto:
```
./venv/bin/pip install -r requirements.txt
```

Ative a opção de tempo de execução de aplicação do App Check para sua função:

Node.js (1ª geração)

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ª geração)

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 (visualização)

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

Reimplante suas funções:
```
firebase deploy --only functions
```

Depois que essas alterações forem implantadas, seu Cloud Functions chamável exigirá tokens válidos do App Check. Os SDKs do cliente do Cloud Functions anexam automaticamente um token do App Check quando você invoca uma função que pode ser chamada.

Proteção de repetição (beta)

Para proteger uma função que pode ser chamada de ataques de repetição, você pode consumir o token App Check após verificá-lo. Depois que o token for consumido, ele não poderá ser usado novamente.

Observe que o uso da proteção de reprodução adiciona um percurso de ida e volta da rede à verificação do token e, portanto, adiciona latência à chamada de função da nuvem. Por esse motivo, a maioria dos aplicativos normalmente habilita a proteção de reprodução apenas em endpoints particularmente sensíveis.

Para consumir tokens:

No console do Cloud , conceda o papel "Firebase App Check Token Verifier" à conta de serviço usada pela Cloud Function.
- Se você estiver inicializando explicitamente o SDK Admin e tiver especificado as credenciais da conta de serviço do SDK Admin do seu projeto, a função necessária já foi concedida.
- Se você estiver usando o Cloud Functions de primeira geração com a configuração padrão do SDK Admin, conceda o papel à conta de serviço padrão do App Engine . Consulte Alterando permissões de conta de serviço .
- Se você estiver usando o Cloud Functions de segunda geração com a configuração padrão do SDK Admin, conceda o papel à conta de serviço de computação padrão .

Defina consumeAppCheckToken como true na definição da sua função:

Node.js (1ª geração)

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ª geração)

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

Atualize o código do cliente do seu aplicativo para adquirir tokens consumíveis de uso limitado ao chamar a função:

Rápido

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

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