---
title: Utiliser WIF avec Google Cloud
url: https://platform.claude.com/docs/fr/manage-claude/wif-providers/gcp
description: Fédérez les charges de travail Google Cloud (Cloud Run, Cloud Functions, App Engine, GCE, GKE) vers l'API Claude à l'aide de jetons d'identité signés par Google au lieu de clés API statiques.
---

Tout environnement de calcul Google Cloud ayant accès au serveur de métadonnées d'instance (Cloud Run, Cloud Functions, App Engine, Compute Engine (GCE) et GKE avec Workload Identity) peut demander un jeton d'identité signé par Google pour le compte de service qui lui est attaché. L'émetteur du jeton est `https://accounts.google.com`, et Anthropic peut le valider directement via la découverte OIDC standard, sans aucune configuration Google Cloud supplémentaire requise.

Ce guide montre comment enregistrer l'émetteur Google auprès d'Anthropic, lier un compte de service Google à un compte de service Anthropic, et faire en sorte que votre charge de travail échange son jeton d'identité contre un jeton d'accès à l'API Claude de courte durée.

## Prérequis

* Une familiarité avec les [concepts WIF](https://platform.claude.com/docs/fr/manage-claude/workload-identity-federation#concepts) : comptes de service, émetteurs de fédération et règles de fédération.
* Un projet Google Cloud avec une charge de travail s'exécutant sur Cloud Run, Cloud Functions, App Engine, Compute Engine ou GKE.
* Un compte de service Google géré par l'utilisateur attaché à cette charge de travail (et non le compte de service par défaut de Compute Engine).
* L'autorisation de créer des comptes de service, des émetteurs de fédération et des règles de fédération dans la Claude Console pour votre organisation Anthropic.

## Configurer Google Cloud

Google émet automatiquement des jetons d'identité pour toute charge de travail disposant d'un compte de service attaché. Il n'y a rien à activer du côté de Google au-delà de l'attachement du bon compte de service, mais les étapes diffèrent légèrement entre le calcul standard et GKE.

<Tabs>
  <Tab title="Cloud Run, Cloud Functions, App Engine, GCE">
    Attachez un compte de service dédié à votre service ou instance :

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

    À l'intérieur de la charge de travail, le serveur de métadonnées renvoie un jeton d'identité signé à la demande. Demandez-le avec l'`audience` que vous avez l'intention d'enregistrer du côté d'Anthropic, et incluez `format=full` afin que la réponse contienne la revendication (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, avec la CLI gcloud :

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

    Les équivalents SDK sont présentés dans [Acquérir et utiliser le jeton](https://platform.claude.com/docs/fr/manage-claude/wif-providers/gcp#acquire-and-use-the-token).

    La charge utile décodée du jeton ressemble à ceci :

    ```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
    }
    ```

    La revendication `sub` est l'identifiant unique numérique opaque du compte de service Google. La revendication `email` est l'adresse lisible du compte de service. Faites correspondre à la fois `sub` et `email` dans votre règle de fédération.
  </Tab>

  <Tab title="GKE avec Workload Identity">
    Activez [Workload Identity](https://cloud.google.com/kubernetes-engine/docs/how-to/workload-identity) sur votre cluster et liez votre compte de service Kubernetes à un compte de service Google avec l'annotation `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
    ```

    Une fois cette liaison en place, le serveur de métadonnées GKE renvoie un jeton signé par Google identique au cas de Cloud Run et GCE : même émetteur `https://accounts.google.com`, même revendication `email`, même URL de récupération. Configurez Anthropic exactement comme dans la section suivante.

    Un jeton `format=full` provenant de GKE inclut en plus les revendications `google.compute_engine.project_id`, `google.compute_engine.zone` et `google.compute_engine.instance_name`, que vous pouvez référencer dans le matcher `condition` d'une règle de fédération (une expression CEL telle que `claims.google.compute_engine.project_id == "my-project"`) pour restreindre l'accès à un cluster ou un pool de nœuds spécifique.

    <Note>
      Si vous ne souhaitez pas lier les comptes de service Kubernetes à des comptes de service Google, les pods GKE peuvent à la place utiliser l'émetteur OIDC propre au cluster (`https://container.googleapis.com/v1/projects/PROJECT/locations/REGION/clusters/CLUSTER`) avec un volume `serviceAccountToken` projeté. Cette approche utilise un émetteur par cluster plutôt que `accounts.google.com`. Consultez [Utiliser WIF avec Kubernetes](https://platform.claude.com/docs/fr/manage-claude/wif-providers/kubernetes) pour ce modèle.
    </Note>
  </Tab>
</Tabs>

## Configurer Anthropic

Dans la Claude Console, accédez à la page [Workload identity](https://platform.claude.com/settings/workload-identity-federation) (`platform.claude.com/settings/workload-identity-federation`), cliquez sur **Connect workload**, puis sélectionnez la tuile **Google Cloud**. L'assistant vous guide dans l'enregistrement de l'émetteur, la création d'un compte de service et la création d'une règle de fédération.

L'assistant crée ces ressources pour vous. Utilisez les valeurs suivantes, que vous les saisissiez dans l'assistant ou que vous les envoyiez à l'[Admin API](https://platform.claude.com/docs/fr/manage-claude/wif-admin-api) :

**Émetteur de fédération :** Google publie son document de découverte OIDC publiquement, utilisez donc le mode découverte. Cet émetteur unique couvre toutes les surfaces Google Cloud (Cloud Run, GCE, Cloud Functions, App Engine et GKE avec Workload Identity). Différenciez les charges de travail avec des règles, et non avec des émetteurs.

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

**Règle de fédération :** Faites correspondre à la fois les revendications `sub` et `email`. `email` est l'adresse lisible du compte de service ; `sub` est l'identifiant unique numérique du compte de service, que Google ne réutilise jamais, de sorte que l'épingler protège la règle si le compte de service est supprimé et qu'un nouveau est créé ultérieurement avec le même e-mail. Trouvez l'identifiant unique avec `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
}
```

## Acquérir et utiliser le jeton

Dans votre charge de travail Google Cloud, récupérez le jeton d'identité auprès du serveur de métadonnées, échangez-le via `POST /v1/oauth/token` et utilisez le jeton bearer renvoyé pour appeler l'API Claude. Le SDK Claude gère pour vous l'échange et la boucle de renouvellement lorsque vous fournissez `identity_token_provider` (typescript: `identityTokenProvider`; php: `identityProvider`; csharp: `IdentityTokenProvider`; go: `option.WithFederationTokenProvider`; java: `IdentityTokenConfig`), comme le montrent les exemples suivants. Sauf en Java (voir le commentaire dans cet exemple), cette option accepte un fournisseur de jetons qui renvoie un nouveau jeton d'identité depuis le serveur de métadonnées.

<CodeGroup>
  ```bash cURL
  # Récupérer le jeton d'identité signé par Google auprès du serveur de métadonnées.
  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")

  # L'échanger contre un jeton d'accès 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)

  # Appeler l'API 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();

      // Le SDK Java accepte le jeton lui-même ou un chemin de fichier, pas une fonction ; avec
      // source("value"), path(...) contient le jeton. Le SDK envoie ce même jeton
      // à chaque actualisation du jeton d'accès Anthropic, ce qui échoue dès qu'il a
      // expiré ou, s'il possède une revendication jti, été utilisé. Pour un processus
      // de longue durée, passez source("file") et écrivez un nouveau jeton dans le fichier avant
      // chaque actualisation.
      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
  # Écrire le jeton d'identité signé par Google dans un fichier lisible par la CLI
  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 et ANTHROPIC_WORKSPACE_ID sont lus depuis l'environnement.
  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>

Les jetons d'identité Google expirent après environ une heure. Sauf en Java (voir le commentaire dans cet exemple), le SDK invoque de nouveau le fournisseur de jetons et refait l'échange automatiquement avant l'expiration. Pour les scripts shell qui s'exécutent plus longtemps que la durée `expires_in` du jeton d'accès, renouvelez le jeton à l'aide d'un minuteur et répétez l'échange.

## Vérifier la configuration

Depuis l'intérieur de votre charge de travail, décodez le jeton d'identité et confirmez que les revendications correspondent à votre règle :

```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'
```

Vérifiez que `iss` vaut `https://accounts.google.com`, que `aud` vaut `https://api.anthropic.com`, et que `email` correspond à la valeur de votre règle de fédération. Exécutez ensuite l'échange de la section précédente. Un échange réussi renvoie un `access_token` commençant par `sk-ant-oat01-` et une valeur `expires_in` en secondes. Si l'échange échoue avec la réponse opaque `401` `authentication_error` (message `Authentication failed`), consultez la [page d'historique d'authentification](https://platform.claude.com/settings/workload-identity-federation?tab=history) dans la Claude Console pour connaître le motif du refus et reportez-vous à [Dépanner un échange échoué](https://platform.claude.com/docs/fr/manage-claude/wif-reference#troubleshoot-a-failed-exchange) ; la cause la plus fréquente côté Google Cloud est l'absence de la revendication `email` (demandez le jeton avec `format=full` pour qu'elle soit incluse).

## Restreindre la portée de votre règle

<Warning>
  La revendication Google `sub` est l'identifiant unique numérique opaque du compte de service et n'a pas de préfixe stable. Un `subject_prefix` avec un `*` final correspond à des comptes de service arbitraires dans tous les projets Google Cloud, et n'importe lequel d'entre eux pourrait obtenir un jeton Anthropic fédéré.
</Warning>

Verrouillez le bloc `match` de la règle sur la portée la plus étroite qui convient à votre cas d'usage :

* **Faites correspondre `sub` exactement :** Définissez l'identifiant unique numérique complet dans `claims.sub` et n'utilisez jamais `subject_prefix` pour les jetons Google.
* **Épinglez la revendication `email` :** Ajoutez `claims.email` aux côtés de `sub` afin que l'identifiant stable et l'adresse lisible doivent tous deux correspondre.
* **Épinglez l'audience :** Définissez `audience` sur la valeur exacte que vous demandez au serveur de métadonnées afin que les jetons émis pour d'autres consommateurs soient rejetés.
* **Épinglez le projet sur GKE :** Pour les jetons `format=full`, ajoutez une `condition` telle que `claims.google.compute_engine.project_id == "my-project"` pour restreindre la règle aux nœuds d'un seul projet.

## Étapes suivantes

* Lisez la page [Workload Identity Federation](https://platform.claude.com/docs/fr/manage-claude/workload-identity-federation) pour le modèle de ressources complet et l'ordre de priorité des identifiants dans les SDK.
* Ajoutez une règle de fédération distincte par environnement (production, préproduction) afin de pouvoir en révoquer une sans affecter les autres.