---
title: WIF mit Google Cloud verwenden
url: https://platform.claude.com/docs/de/manage-claude/wif-providers/gcp
description: Föderiere Google Cloud-Workloads (Cloud Run, Cloud Functions, App Engine, GCE, GKE) mit der Claude API unter Verwendung von Google-signierten Identitätstoken anstelle statischer API-Keys.
---

Jede Google Cloud-Compute-Umgebung mit Zugriff auf den Instanz-Metadatenserver (Cloud Run, Cloud Functions, App Engine, Compute Engine (GCE) und GKE mit Workload Identity) kann ein Google-signiertes „identity token“ (Identitätstoken) für ihr angehängtes Dienstkonto anfordern. Der Aussteller des Tokens ist `https://accounts.google.com`, und Anthropic kann es direkt über die standardmäßige OIDC-Discovery validieren, ohne dass eine zusätzliche Google Cloud-Konfiguration erforderlich ist.

Dieser Leitfaden zeigt, wie du den Google-Aussteller bei Anthropic registrierst, ein Google-Dienstkonto an ein Anthropic-Dienstkonto bindest und deinen Workload sein Identitätstoken gegen ein kurzlebiges Claude API-Zugriffstoken eintauschen lässt.

## Voraussetzungen

* Vertrautheit mit den [WIF-Konzepten](https://platform.claude.com/docs/de/manage-claude/workload-identity-federation#concepts): Dienstkonten, Föderationsaussteller und Föderationsregeln.
* Ein Google Cloud-Projekt mit einem Workload, der auf Cloud Run, Cloud Functions, App Engine, Compute Engine oder GKE läuft.
* Ein benutzerverwaltetes Google-Dienstkonto, das an diesen Workload angehängt ist (nicht das Compute Engine-Standarddienstkonto).
* Berechtigung zum Erstellen von Dienstkonten, Föderationsausstellern und Föderationsregeln in der Claude Console für deine Anthropic-Organisation.

## Google Cloud konfigurieren

Google stellt Identitätstoken automatisch für jeden Workload mit einem angehängten Dienstkonto aus. Auf der Google-Seite muss nichts aktiviert werden, außer das richtige Dienstkonto anzuhängen, aber die Schritte unterscheiden sich geringfügig zwischen Standard-Compute und GKE.

<Tabs>
  <Tab title="Cloud Run, Cloud Functions, App Engine, GCE">
    Hänge ein dediziertes Dienstkonto an deinen Dienst oder deine Instanz an:

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

    Innerhalb des Workloads gibt der Metadatenserver auf Anfrage ein signiertes Identitätstoken zurück. Fordere es mit der `audience` an, die du auf der Anthropic-Seite registrieren möchtest, und füge `format=full` hinzu, damit die Antwort den `email`-Claim enthält:

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

    Oder mit der gcloud CLI:

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

    Die SDK-Entsprechungen werden unter [Token abrufen und verwenden](https://platform.claude.com/docs/de/manage-claude/wif-providers/gcp#acquire-and-use-the-token) gezeigt.

    Die dekodierte Token-Payload sieht so aus:

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

    Der `sub`-Claim ist die opake numerische eindeutige ID des Google-Dienstkontos. Der `email`-Claim ist die menschenlesbare Dienstkontoadresse. Gleiche in deiner Föderationsregel sowohl `sub` als auch `email` ab.
  </Tab>

  <Tab title="GKE mit Workload Identity">
    Aktiviere [Workload Identity](https://cloud.google.com/kubernetes-engine/docs/how-to/workload-identity) auf deinem Cluster und binde dein Kubernetes-Dienstkonto mit der Annotation `iam.gke.io/gcp-service-account` an ein Google-Dienstkonto:

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

    Mit dieser Bindung gibt der GKE-Metadatenserver ein Google-signiertes Token zurück, das mit dem Fall von Cloud Run und GCE identisch ist: derselbe Aussteller `https://accounts.google.com`, derselbe `email`-Claim, dieselbe Abruf-URL. Konfiguriere Anthropic genau wie im nächsten Abschnitt.

    Ein `format=full`-Token von GKE enthält zusätzlich die Claims `google.compute_engine.project_id`, `google.compute_engine.zone` und `google.compute_engine.instance_name`, auf die du im `condition`-Matcher einer Föderationsregel verweisen kannst (ein CEL-Ausdruck wie `claims.google.compute_engine.project_id == "my-project"`), um den Zugriff auf einen bestimmten Cluster oder Knotenpool einzuschränken.

    <Note>
      Wenn du Kubernetes-Dienstkonten nicht an Google-Dienstkonten binden möchtest, können GKE-Pods stattdessen den eigenen OIDC-Aussteller des Clusters (`https://container.googleapis.com/v1/projects/PROJECT/locations/REGION/clusters/CLUSTER`) mit einem projizierten `serviceAccountToken`-Volume verwenden. Dieser Weg verwendet einen Aussteller pro Cluster anstelle von `accounts.google.com`. Siehe [WIF mit Kubernetes verwenden](https://platform.claude.com/docs/de/manage-claude/wif-providers/kubernetes) für dieses Muster.
    </Note>
  </Tab>
</Tabs>

## Anthropic konfigurieren

Gehe in der Claude Console zur Seite [Workload identity](https://platform.claude.com/settings/workload-identity-federation) (`platform.claude.com/settings/workload-identity-federation`), klicke auf **Connect workload** und wähle die Kachel **Google Cloud** aus. Der Assistent führt dich durch die Registrierung des Ausstellers, die Erstellung eines Dienstkontos und die Erstellung einer Föderationsregel.

Der Assistent erstellt diese Ressourcen für dich. Verwende die folgenden Werte, unabhängig davon, ob du sie im Assistenten eingibst oder an die [Admin API](https://platform.claude.com/docs/de/manage-claude/wif-admin-api) sendest:

**Föderationsaussteller:** Google veröffentlicht sein OIDC-Discovery-Dokument öffentlich, verwende daher den Discovery-Modus. Dieser einzelne Aussteller deckt jede Google Cloud-Oberfläche ab (Cloud Run, GCE, Cloud Functions, App Engine und GKE mit Workload Identity). Unterscheide Workloads mit Regeln, nicht mit Ausstellern.

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

**Föderationsregel:** Gleiche sowohl den `sub`- als auch den `email`-Claim ab. `email` ist die lesbare Dienstkontoadresse; `sub` ist die numerische eindeutige ID des Dienstkontos, die Google niemals wiederverwendet. Das Festlegen dieser ID schützt die Regel, falls das Dienstkonto gelöscht und später ein neues mit derselben E-Mail-Adresse erstellt wird. Finde die eindeutige ID mit `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
}
```

## Token abrufen und verwenden

Rufe innerhalb deines Google Cloud-Workloads das Identitätstoken vom Metadatenserver ab, tausche es bei `POST /v1/oauth/token` aus und verwende das zurückgegebene Bearer-Token, um die Claude API aufzurufen. Das Claude SDK übernimmt den Austausch und die Aktualisierungsschleife für dich, wenn du `identity_token_provider` (typescript: `identityTokenProvider`; php: `identityProvider`; csharp: `IdentityTokenProvider`; go: `option.WithFederationTokenProvider`; java: `IdentityTokenConfig`) angibst, wie in den folgenden Beispielen gezeigt. Außer in Java (siehe den Kommentar im Java-Beispiel) nimmt diese Option einen Token-Provider entgegen, der ein frisches Identitätstoken vom Metadatenserver zurückgibt.

<CodeGroup>
  ```bash cURL
  # Hole das von Google signierte Identitätstoken vom Metadatenserver
  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")

  # Tausche es gegen ein Anthropic-Zugriffstoken ein
  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)

  # Rufe die Claude API auf
  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();

      // Das Java SDK nimmt das Token selbst oder einen Dateipfad, keine Funktion; mit
      // source("value") enthält path(...) das Token. Das SDK sendet dasselbe Token
      // bei jeder Aktualisierung des Anthropic-Zugriffstokens, was fehlschlägt, sobald es
      // abgelaufen ist oder, falls es einen jti-Claim hat, bereits verwendet wurde. Für länger laufende
      // Prozesse übergib source("file") und schreibe vor jeder Aktualisierung ein neues Token
      // in die Datei.
      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
  # Schreibe das von Google signierte Identity-Token in eine Datei, die die CLI lesen kann
  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 und ANTHROPIC_WORKSPACE_ID werden aus der Umgebung gelesen.
  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>

Google-Identitätstoken laufen nach etwa einer Stunde ab. Außer in Java (siehe den Kommentar im Java-Beispiel) ruft das SDK den Token-Provider erneut auf und führt den Austausch vor dem Ablauf automatisch erneut durch. Bei Shell-Skripten, die länger laufen als das `expires_in` des Zugriffstokens, aktualisiere per Timer und wiederhole den Austausch.

## Einrichtung überprüfen

Dekodiere innerhalb deines Workloads das Identitätstoken und bestätige, dass die Claims mit deiner Regel übereinstimmen:

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

Prüfe, dass `iss` den Wert `https://accounts.google.com` hat, `aud` den Wert `https://api.anthropic.com` hat und `email` mit dem Wert in deiner Föderationsregel übereinstimmt. Führe dann den Austausch aus dem vorherigen Abschnitt aus. Ein erfolgreicher Austausch gibt ein `access_token` zurück, das mit `sk-ant-oat01-` beginnt, sowie einen `expires_in`-Wert in Sekunden. Wenn der Austausch mit der opaken `401`-`authentication_error`-Antwort (Meldung `Authentication failed`) fehlschlägt, prüfe die [Seite mit dem Authentifizierungsverlauf](https://platform.claude.com/settings/workload-identity-federation?tab=history) in der Claude Console auf den Ablehnungsgrund und siehe [Einen fehlgeschlagenen Austausch beheben](https://platform.claude.com/docs/de/manage-claude/wif-reference#troubleshoot-a-failed-exchange); die häufigste Ursache auf Google Cloud-Seite ist ein fehlender `email`-Claim (fordere das Token mit `format=full` an, damit er enthalten ist).

## Deine Regel eingrenzen

<Warning>
  Der Google-`sub`-Claim ist die opake numerische eindeutige ID des Dienstkontos und hat kein stabiles Präfix. Ein `subject_prefix` mit einem abschließenden `*` passt auf beliebige Dienstkonten in jedem Google Cloud-Projekt, und jedes von ihnen könnte ein föderiertes Anthropic-Token erhalten.
</Warning>

Beschränke den `match`-Block der Regel auf den engsten Geltungsbereich, der zu deinem Anwendungsfall passt:

* **`sub` exakt abgleichen:** Setze die vollständige numerische eindeutige ID in `claims.sub` und verwende niemals `subject_prefix` für Google-Token.
* **Den `email`-Claim festlegen:** Füge `claims.email` neben `sub` hinzu, sodass sowohl die stabile ID als auch die lesbare Adresse übereinstimmen müssen.
* **Die Audience festlegen:** Setze `audience` auf den exakten Wert, den du vom Metadatenserver anforderst, damit für andere Konsumenten ausgestellte Token abgelehnt werden.
* **Das Projekt auf GKE festlegen:** Füge für `format=full`-Token eine `condition` wie `claims.google.compute_engine.project_id == "my-project"` hinzu, um die Regel auf die Knoten eines Projekts zu beschränken.

## Nächste Schritte

* Lies die Seite [Workload Identity Federation](https://platform.claude.com/docs/de/manage-claude/workload-identity-federation) für das vollständige Ressourcenmodell und die Rangfolge der SDK-Anmeldedaten.
* Füge pro Umgebung (Produktion, Staging) eine separate Föderationsregel hinzu, damit du eine widerrufen kannst, ohne die anderen zu beeinträchtigen.