Fique por dentro dos destaques do Firebase no Google I/O 2023. Saiba mais

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

Assim que você entender como o App Check vai afetar seus usuários, e se estiver tudo pronto para seguir o processo, ative a aplicação do App Check.

Como ativar a aplicação

Para começar a aplicar os requisitos do token do App Check ao Cloud Functions chamável, modifique as funções para verificar os 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 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 projeto para a versão 4.0.0 ou mais recente:
```
npm install firebase-functions@">=4.0.0"
```
Python (pré-lançamento)
Adicionar firebase-functions a functions/requirements.txt:
```
firebase-functions >= 0.1.0
```
Em seguida, atualize as dependências no ambiente virtual do projeto:
```
./venv/bin/pip install -r requirements.txt
```

Ative a opção de tempo de execução de aplicação do App Check na 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 (pré-lançamento)

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

Implante as funções novamente:
```
firebase deploy --only functions
```

Depois que essas alterações forem implantadas, o Cloud Functions chamável vai precisar de 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 chamável.

Proteção contra repetição (Beta)

Para proteger uma função chamável contra ataques de repetição, use o token do App Check depois de verificá-lo. O token só pode ser usado uma vez.

O uso da proteção contra repetição adiciona uma ida e volta de rede à verificação de token e, portanto, inclui latência à chamada da função do Cloud. Por isso, a maioria dos apps geralmente ativa a proteção contra repetição apenas em endpoints particularmente confidenciais.

Para consumir tokens:

No console do Cloud, conceda o papel "Verificador de tokens do Firebase App Check" à conta de serviço usada pelo Cloud Function.
- Se você estiver inicializando explicitamente o SDK Admin e especificando as credenciais da conta de serviço do SDK Admin do seu projeto, o papel necessário já foi concedido.
- 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 Como alterar as permissões da 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 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 app para adquirir tokens consumíveis de uso limitado ao chamar a função:

Swift

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