---
title: Usar WIF com o Google Cloud
url: https://platform.claude.com/docs/pt-BR/manage-claude/wif-providers/gcp
description: Federe cargas de trabalho do Google Cloud (Cloud Run, Cloud Functions, App Engine, GCE, GKE) à Claude API usando tokens de identidade assinados pelo Google em vez de chaves de API estáticas.
---

Qualquer ambiente de computação do Google Cloud com acesso ao servidor de metadados da instância (Cloud Run, Cloud Functions, App Engine, Compute Engine (GCE) e GKE com Workload Identity) pode solicitar um token de identidade assinado pelo Google para sua conta de serviço anexada. O emissor do token é `https://accounts.google.com`, e a Anthropic pode validá-lo diretamente por meio da descoberta OIDC padrão, sem necessidade de configuração adicional no Google Cloud.

Este guia mostra como registrar o emissor do Google na Anthropic, vincular uma conta de serviço do Google a uma conta de serviço da Anthropic e fazer com que sua carga de trabalho troque seu token de identidade por um token de acesso de curta duração à Claude API.

## Pré-requisitos

* Familiaridade com os [conceitos de WIF](https://platform.claude.com/docs/pt-BR/manage-claude/workload-identity-federation#concepts): contas de serviço, emissores de federação e regras de federação.
* Um projeto do Google Cloud com uma carga de trabalho em execução no Cloud Run, Cloud Functions, App Engine, Compute Engine ou GKE.
* Uma conta de serviço do Google gerenciada pelo usuário anexada a essa carga de trabalho (não a conta de serviço padrão do Compute Engine).
* Permissão para criar contas de serviço, emissores de federação e regras de federação no Claude Console para sua organização da Anthropic.

## Configurar o Google Cloud

O Google emite tokens de identidade automaticamente para qualquer carga de trabalho com uma conta de serviço anexada. Não há nada a habilitar no lado do Google além de anexar a conta de serviço correta, mas as etapas diferem ligeiramente entre computação padrão e GKE.

<Tabs>
  <Tab title="Cloud Run, Cloud Functions, App Engine, GCE">
    Anexe uma conta de serviço dedicada ao seu serviço ou instância:

    ```bash CLI
    gcloud run deploy my-service \
      --service-account inference-worker@my-project.iam.gserviceaccount.com
    ```

    Dentro da carga de trabalho, o servidor de metadados retorna um token de identidade assinado sob demanda. Solicite-o com o `audience` que você pretende registrar no lado da Anthropic e inclua `format=full` para que a resposta contenha a claim `email`:

    ```text wrap
    GET http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/identity?audience=https://api.anthropic.com&format=full
    Metadata-Flavor: Google
    ```

    Ou, com a CLI gcloud:

    ```bash CLI
    gcloud auth print-identity-token \
      --audiences="https://api.anthropic.com" \
      --include-email
    ```

    Os equivalentes nos SDKs são mostrados em [Obter e usar o token](https://platform.claude.com/docs/pt-BR/manage-claude/wif-providers/gcp#acquire-and-use-the-token).

    O payload do token decodificado tem esta aparência:

    ```json
    {
      "iss": "https://accounts.google.com",
      "aud": "https://api.anthropic.com",
      "sub": "104892...",
      "azp": "104892...",
      "email": "inference-worker@my-project.iam.gserviceaccount.com",
      "email_verified": true,
      "exp": 1775527120
    }
    ```

    A claim `sub` é o ID exclusivo numérico opaco da conta de serviço do Google. A claim `email` é o endereço legível da conta de serviço. Faça a correspondência tanto em `sub` quanto em `email` na sua regra de federação.
  </Tab>

  <Tab title="GKE com Workload Identity">
    Habilite o [Workload Identity](https://cloud.google.com/kubernetes-engine/docs/how-to/workload-identity) no seu cluster e vincule sua conta de serviço do Kubernetes a uma conta de serviço do Google com a anotação `iam.gke.io/gcp-service-account`:

    ```yaml
    apiVersion: v1
    kind: ServiceAccount
    metadata:
      name: inference-worker
      namespace: prod
      annotations:
        iam.gke.io/gcp-service-account: inference-worker@my-project.iam.gserviceaccount.com
    ```

    Com essa vinculação em vigor, o servidor de metadados do GKE retorna um token assinado pelo Google idêntico ao caso do Cloud Run e do GCE: mesmo emissor `https://accounts.google.com`, mesma claim `email`, mesma URL de obtenção. Configure a Anthropic exatamente como na próxima seção.

    Um token `format=full` do GKE inclui adicionalmente as claims `google.compute_engine.project_id`, `google.compute_engine.zone` e `google.compute_engine.instance_name`, que você pode referenciar no matcher `condition` de uma regra de federação (uma expressão CEL como `claims.google.compute_engine.project_id == "my-project"`) para restringir o acesso a um cluster ou pool de nós específico.

    <Note>
      Se você não quiser vincular contas de serviço do Kubernetes a contas de serviço do Google, os pods do GKE podem, em vez disso, usar o próprio emissor OIDC do cluster (`https://container.googleapis.com/v1/projects/PROJECT/locations/REGION/clusters/CLUSTER`) com um volume `serviceAccountToken` projetado. Esse caminho usa um emissor por cluster em vez de `accounts.google.com`. Consulte [Usar WIF com Kubernetes](https://platform.claude.com/docs/pt-BR/manage-claude/wif-providers/kubernetes) para esse padrão.
    </Note>
  </Tab>
</Tabs>

## Configurar a Anthropic

No Claude Console, acesse a página [Workload identity](https://platform.claude.com/settings/workload-identity-federation) (`platform.claude.com/settings/workload-identity-federation`), clique em **Connect workload** e selecione o bloco **Google Cloud**. O assistente orienta você no registro do emissor, na criação de uma conta de serviço e na criação de uma regra de federação.

O assistente cria esses recursos para você. Use os seguintes valores, seja inserindo-os no assistente ou enviando-os para a [Admin API](https://platform.claude.com/docs/pt-BR/manage-claude/wif-admin-api):

**Emissor de federação:** o Google publica seu documento de descoberta OIDC publicamente, portanto use o modo de descoberta. Esse único emissor cobre todas as superfícies do Google Cloud (Cloud Run, GCE, Cloud Functions, App Engine e GKE com Workload Identity). Diferencie as cargas de trabalho com regras, não com emissores.

```json
{
  "name": "gcp",
  "issuer_url": "https://accounts.google.com",
  "jwks": { "type": "discovery" }
}
```

**Regra de federação:** faça a correspondência tanto na claim `sub` quanto na claim `email`. `email` é o endereço legível da conta de serviço; `sub` é o ID exclusivo numérico da conta de serviço, que o Google nunca reutiliza, portanto fixá-lo protege a regra caso a conta de serviço seja excluída e uma nova seja criada posteriormente com o mesmo email. Encontre o ID exclusivo com `gcloud iam service-accounts describe SA_EMAIL --format='value(uniqueId)'`.

```json
{
  "name": "gcp-inference-worker",
  "issuer_id": "fdis_...",
  "match": {
    "audience": "https://api.anthropic.com",
    "claims": {
      "sub": "104892101234567890123",
      "email": "inference-worker@my-project.iam.gserviceaccount.com"
    }
  },
  "target": {
    "type": "service_account",
    "service_account_id": "svac_..."
  },
  "workspace_id": "wrkspc_...",
  "oauth_scope": "workspace:developer",
  "token_lifetime_seconds": 600
}
```

## Obter e usar o token

Dentro da sua carga de trabalho do Google Cloud, obtenha o token de identidade do servidor de metadados, troque-o em `POST /v1/oauth/token` e use o token bearer retornado para chamar a Claude API. O SDK do Claude cuida do ciclo de troca e renovação para você quando você fornece `identity_token_provider` (typescript: `identityTokenProvider`; php: `identityProvider`; csharp: `IdentityTokenProvider`; go: `option.WithFederationTokenProvider`; java: `IdentityTokenConfig`), conforme mostrado nos exemplos a seguir. Exceto em Java (consulte o comentário nesse exemplo), essa opção recebe um provedor de token que retorna um token de identidade novo do servidor de metadados.

<CodeGroup>
  ```bash cURL
  # Obtém o token de identidade assinado pelo Google no servidor de metadados
  JWT=$(curl -sS -H "Metadata-Flavor: Google" \
    "http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/identity?audience=https://api.anthropic.com&format=full")

  # Troca-o por um token de acesso da Anthropic
  RESPONSE=$(curl -sS https://api.anthropic.com/v1/oauth/token \
    -H "content-type: application/json" \
    --data @- <<JSON
  {
    "grant_type": "urn:ietf:params:oauth:grant-type:jwt-bearer",
    "assertion": "$JWT",
    "federation_rule_id": "$ANTHROPIC_FEDERATION_RULE_ID",
    "organization_id": "$ANTHROPIC_ORGANIZATION_ID",
    "service_account_id": "$ANTHROPIC_SERVICE_ACCOUNT_ID",
    "workspace_id": "$ANTHROPIC_WORKSPACE_ID"
  }
  JSON
  )
  ACCESS_TOKEN=$(echo "$RESPONSE" | jq -r .access_token)

  # Chama a API do Claude
  curl -sS https://api.anthropic.com/v1/messages \
    -H "authorization: Bearer $ACCESS_TOKEN" \
    -H "anthropic-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 1024,
      "messages": [{"role": "user", "content": "Hello from Cloud Run"}]
    }' | jq -r '.content[] | select(.type == "text") | .text'
  ```

  ```python Python
  import os
  import anthropic
  import google.auth.transport.requests
  import google.oauth2.id_token
  from anthropic import WorkloadIdentityCredentials

  AUDIENCE = "https://api.anthropic.com"


  def fetch_google_identity_token() -> str:
      request = google.auth.transport.requests.Request()
      return google.oauth2.id_token.fetch_id_token(request, AUDIENCE)


  client = anthropic.Anthropic(
      credentials=WorkloadIdentityCredentials(
          identity_token_provider=fetch_google_identity_token,
          federation_rule_id=os.environ["ANTHROPIC_FEDERATION_RULE_ID"],
          organization_id=os.environ["ANTHROPIC_ORGANIZATION_ID"],
          service_account_id=os.environ["ANTHROPIC_SERVICE_ACCOUNT_ID"],
          workspace_id=os.environ.get("ANTHROPIC_WORKSPACE_ID"),
      ),
  )

  message = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=1024,
      messages=[{"role": "user", "content": "Hello from Cloud Run"}],
  )
  print(next(block.text for block in message.content if block.type == "text"))
  ```

  ```typescript TypeScript
  import Anthropic from "@anthropic-ai/sdk";
  import { oidcFederationProvider } from "@anthropic-ai/sdk/lib/credentials/oidc-federation";

  const METADATA_URL =
    "http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/identity?audience=https://api.anthropic.com&format=full";

  async function fetchGoogleIdentityToken(): Promise<string> {
    const response = await fetch(METADATA_URL, {
      headers: { "Metadata-Flavor": "Google" }
    });
    return response.text();
  }

  const client = new Anthropic({
    credentials: oidcFederationProvider({
      identityTokenProvider: fetchGoogleIdentityToken,
      federationRuleId: process.env.ANTHROPIC_FEDERATION_RULE_ID!,
      organizationId: process.env.ANTHROPIC_ORGANIZATION_ID!,
      serviceAccountId: process.env.ANTHROPIC_SERVICE_ACCOUNT_ID,
      workspaceId: process.env.ANTHROPIC_WORKSPACE_ID,
      baseURL: "https://api.anthropic.com",
      fetch
    })
  });

  const message = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello from Cloud Run" }]
  });
  for (const block of message.content) {
    if (block.type === "text") {
      console.log(block.text);
    }
  }
  ```

  ```go Go
  const audience = "https://api.anthropic.com"

  googleIDToken := func(ctx context.Context) (string, error) {
  	creds, err := idtoken.NewCredentials(&idtoken.Options{Audience: audience})
  	if err != nil {
  		return "", err
  	}
  	tok, err := creds.Token(ctx)
  	if err != nil {
  		return "", err
  	}
  	return tok.Value, nil
  }

  client := anthropic.NewClient(
  	option.WithFederationTokenProvider(googleIDToken, option.FederationOptions{
  		FederationRuleID: os.Getenv("ANTHROPIC_FEDERATION_RULE_ID"),
  		OrganizationID:   os.Getenv("ANTHROPIC_ORGANIZATION_ID"),
  		ServiceAccountID: os.Getenv("ANTHROPIC_SERVICE_ACCOUNT_ID"),
  		WorkspaceID:      os.Getenv("ANTHROPIC_WORKSPACE_ID"),
  	}),
  )

  message, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 1024,
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("Hello from Cloud Run")),
  	},
  })
  if err != nil {
  	panic(err)
  }
  for _, block := range message.Content {
  	if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
  		fmt.Println(textBlock.Text)
  		break
  	}
  }
  ```

  ```java Java
  import com.anthropic.config.AuthenticationConfig;
  import com.anthropic.config.AuthenticationType;
  import com.anthropic.config.IdentityTokenConfig;
  import com.anthropic.config.InMemoryProfileConfigProvider;
  import com.anthropic.config.ProfileConfig;
  // ...
  import java.net.URI;
  import java.net.http.HttpClient;
  import java.net.http.HttpRequest;
  import java.net.http.HttpResponse;

  void main() throws Exception {
      HttpClient http = HttpClient.newHttpClient();
      HttpRequest metadataRequest = HttpRequest.newBuilder()
              .uri(URI.create("http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/identity?audience=https://api.anthropic.com&format=full"))
              .header("Metadata-Flavor", "Google")
              .build();

      // O SDK Java recebe o próprio token ou um caminho de arquivo, não uma função; com
      // source("value"), path(...) contém o token. O SDK envia esse mesmo token
      // a cada renovação do token de acesso da Anthropic, o que falha quando ele
      // expira ou, se tiver uma claim jti, já foi usado. Para um processo de longa duração,
      // passe source("file") e grave um novo token no arquivo antes de
      // cada renovação.
      String googleIdentityToken = http.send(metadataRequest, HttpResponse.BodyHandlers.ofString()).body();

      AnthropicClient client = AnthropicOkHttpClient.builder()
              .configurationProvider(InMemoryProfileConfigProvider.of(ProfileConfig.builder()
                      .organizationId(System.getenv("ANTHROPIC_ORGANIZATION_ID"))
                      .workspaceId(System.getenv("ANTHROPIC_WORKSPACE_ID"))
                      .authentication(AuthenticationConfig.builder()
                              .type(AuthenticationType.OIDC_FEDERATION)
                              .federationRuleId(System.getenv("ANTHROPIC_FEDERATION_RULE_ID"))
                              .serviceAccountId(System.getenv("ANTHROPIC_SERVICE_ACCOUNT_ID"))
                              .identityToken(IdentityTokenConfig.builder()
                                      .source("value")
                                      .path(googleIdentityToken)
                                      .build())
                              .build())
                      .build()))
              .build();

      var message = client.messages().create(MessageCreateParams.builder()
              .model(Model.CLAUDE_OPUS_5_5)
              .maxTokens(1024)
              .addUserMessage("Hello from Cloud Run")
              .build());

      IO.println(message.content());
  }
  ```

  ```csharp C#
  using Anthropic.Credentials;
  // ...

  var credentials = new WorkloadIdentityCredentials(new WorkloadIdentityOptions
  {
      FederationRuleId = Environment.GetEnvironmentVariable("ANTHROPIC_FEDERATION_RULE_ID")!,
      OrganizationId = Environment.GetEnvironmentVariable("ANTHROPIC_ORGANIZATION_ID"),
      ServiceAccountId = Environment.GetEnvironmentVariable("ANTHROPIC_SERVICE_ACCOUNT_ID"),
      WorkspaceId = Environment.GetEnvironmentVariable("ANTHROPIC_WORKSPACE_ID"),
      IdentityTokenProvider = new MetadataTokenProvider(),
  });
  using var client = new AnthropicClient(new ClientOptions { Credentials = credentials });

  var message = await client.Messages.Create(new()
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 1024,
      Messages = [new() { Role = Role.User, Content = "Hello from Cloud Run" }],
  });
  foreach (var block in message.Content)
  {
      if (block.Value is TextBlock textBlock)
      {
          Console.WriteLine(textBlock.Text);
      }
  }

  class MetadataTokenProvider : IIdentityTokenProvider
  {
      private const string METADATA_URL =
          "http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/identity?audience=https://api.anthropic.com&format=full";

      private static readonly HttpClient httpClient = new()
      {
          DefaultRequestHeaders = { { "Metadata-Flavor", "Google" } },
      };

      public async Task<string> GetIdentityTokenAsync(CancellationToken ct = default)
      {
          return await httpClient.GetStringAsync(METADATA_URL, ct);
      }
  }
  ```

  ```bash CLI
  # Grava o token de identidade assinado pelo Google em um arquivo que a CLI possa ler
  ANTHROPIC_IDENTITY_TOKEN_FILE=$(mktemp)
  curl -sS -H "Metadata-Flavor: Google" \
    "http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/identity?audience=https://api.anthropic.com&format=full" \
    > "$ANTHROPIC_IDENTITY_TOKEN_FILE"
  export ANTHROPIC_IDENTITY_TOKEN_FILE

  # ANTHROPIC_FEDERATION_RULE_ID, ANTHROPIC_ORGANIZATION_ID,
  # ANTHROPIC_SERVICE_ACCOUNT_ID e ANTHROPIC_WORKSPACE_ID são lidos do ambiente.
  ant messages create \
    --model claude-opus-5-5 \
    --max-tokens 1024 \
    --message '{role: user, content: "Hello from Cloud Run"}'
  ```

  ```php PHP
  use Anthropic\Client;
  use Anthropic\Lib\Credentials\CredentialResult;
  use Anthropic\Lib\Credentials\IdentityTokenProvider;
  use Anthropic\Lib\Credentials\TokenCache;
  use Anthropic\Lib\Credentials\WorkloadIdentityCredentials;

  const METADATA_URL = 'http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/identity?audience=https://api.anthropic.com&format=full';

  class GoogleIdentityToken implements IdentityTokenProvider
  {
      public function getIdentityToken(): string
      {
          $context = stream_context_create([
              'http' => ['header' => "Metadata-Flavor: Google\r\n"],
          ]);

          return file_get_contents(METADATA_URL, false, $context);
      }
  }

  $credentials = new CredentialResult(
      provider: new TokenCache(new WorkloadIdentityCredentials(
          identityProvider: new GoogleIdentityToken(),
          federationRuleId: getenv('ANTHROPIC_FEDERATION_RULE_ID'),
          organizationId: getenv('ANTHROPIC_ORGANIZATION_ID'),
          serviceAccountId: getenv('ANTHROPIC_SERVICE_ACCOUNT_ID'),
          workspaceId: getenv('ANTHROPIC_WORKSPACE_ID') ?: null,
      )),
  );
  $client = new Client(credentials: $credentials);

  $message = $client->messages->create(
      model: 'claude-opus-5-5',
      maxTokens: 1024,
      messages: [['role' => 'user', 'content' => 'Hello from Cloud Run']],
  );
  $textBlock = array_find($message->content, static fn ($block): bool => $block->type === 'text');
  echo $textBlock->text, PHP_EOL;
  ```

  ```ruby Ruby
  require "anthropic"
  require "net/http"

  METADATA_URL = "http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/identity?audience=https://api.anthropic.com&format=full"

  credentials = Anthropic::WorkloadIdentityCredentials.new(
    identity_token_provider: -> { Net::HTTP.get(URI(METADATA_URL), {"Metadata-Flavor" => "Google"}) },
    federation_rule_id: ENV.fetch("ANTHROPIC_FEDERATION_RULE_ID"),
    organization_id: ENV.fetch("ANTHROPIC_ORGANIZATION_ID"),
    service_account_id: ENV.fetch("ANTHROPIC_SERVICE_ACCOUNT_ID"),
    workspace_id: ENV["ANTHROPIC_WORKSPACE_ID"]
  )
  client = Anthropic::Client.new(credentials: credentials)

  message = client.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 1024,
    messages: [{role: "user", content: "Hello from Cloud Run"}]
  )
  puts message.content.find { it.type == :text }.text
  ```
</CodeGroup>

Os tokens de identidade do Google expiram após aproximadamente uma hora. Exceto em Java (consulte o comentário nesse exemplo), o SDK invoca novamente o provedor de token e refaz a troca automaticamente antes da expiração. Para scripts de shell que são executados por mais tempo do que o `expires_in` do token de acesso, renove com um temporizador e repita a troca.

## Verificar a configuração

De dentro da sua carga de trabalho, decodifique o token de identidade e confirme que as claims correspondem à sua regra:

```bash cURL
curl -sS -H "Metadata-Flavor: Google" \
  "http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/identity?audience=https://api.anthropic.com&format=full" \
  | jq -rR 'split(".")[1] | gsub("-";"+") | gsub("_";"/") | @base64d | fromjson'
```

Verifique se `iss` é `https://accounts.google.com`, `aud` é `https://api.anthropic.com` e `email` corresponde ao valor na sua regra de federação. Em seguida, execute a troca da seção anterior. Uma troca bem-sucedida retorna um `access_token` começando com `sk-ant-oat01-` e um valor `expires_in` em segundos. Se a troca falhar com a resposta opaca `401` `authentication_error` (mensagem `Authentication failed`), verifique a [página de histórico de autenticação](https://platform.claude.com/settings/workload-identity-federation?tab=history) no Claude Console para ver o motivo da negação e consulte [Solucionar problemas de uma troca com falha](https://platform.claude.com/docs/pt-BR/manage-claude/wif-reference#troubleshoot-a-failed-exchange); a causa mais comum no lado do Google Cloud é a ausência da claim `email` (solicite o token com `format=full` para que ela seja incluída).

## Restringir o escopo da sua regra

<Warning>
  A claim `sub` do Google é o ID exclusivo numérico opaco da conta de serviço e não tem prefixo estável. Um `subject_prefix` com um `*` no final corresponde a contas de serviço arbitrárias em todos os projetos do Google Cloud, e qualquer uma delas poderia obter um token federado da Anthropic.
</Warning>

Restrinja o bloco `match` da regra ao escopo mais estreito que atenda ao seu caso de uso:

* **Corresponda `sub` exatamente:** defina o ID exclusivo numérico completo em `claims.sub` e nunca use `subject_prefix` para tokens do Google.
* **Fixe a claim `email`:** adicione `claims.email` junto com `sub` para que tanto o ID estável quanto o endereço legível precisem corresponder.
* **Fixe o audience:** defina `audience` com o valor exato que você solicita ao servidor de metadados, para que tokens emitidos para outros consumidores sejam rejeitados.
* **Fixe o projeto no GKE:** para tokens `format=full`, adicione uma `condition` como `claims.google.compute_engine.project_id == "my-project"` para restringir a regra aos nós de um único projeto.

## Próximos passos

* Leia a página [Workload Identity Federation](https://platform.claude.com/docs/pt-BR/manage-claude/workload-identity-federation) para conhecer o modelo de recursos completo e a precedência de credenciais dos SDKs.
* Adicione uma regra de federação separada por ambiente (produção, staging) para que você possa revogar uma sem afetar as outras.