---
title: Claude Models on Google Cloud (Anthropic managed)
url: https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed
description: Claude Models on Google Cloud (Anthropic managed) ist die Claude API, betrieben von Anthropic und erreichbar über dein Google Cloud-Projekt.
---
Google Cloud übernimmt Zugriff und Abrechnung für Claude Models on Google Cloud (Anthropic managed). Um die beiden Google Cloud-Angebote zu vergleichen oder zu prüfen, welches du verwendest, siehe [Claude Models on Google Cloud](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/overview).
## Dein Konto einrichten
Um dein Konto für Claude Models on Google Cloud (Anthropic managed) einzurichten, benötigst du Folgendes:
* Die Berechtigung, in Google Cloud Marketplace über dein Rechnungskonto Käufe zu tätigen
* Die Berechtigung, Dienste im Projekt zu aktivieren
* Eine [IAM-Rolle, mit der du die Claude Console öffnen kannst](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#using-the-claude-console), die du für Schritt 4 benötigst
Diese Schritte erstellen eine neue Anthropic-Organisation für dein Google Cloud-Projekt. Sie ist von jeder Anthropic-Organisation getrennt, die dein Unternehmen bereits hat. Das schließt eine Claude Enterprise-Organisation ein. Um von einer bestehenden Organisation umzuziehen, siehe [Umzug von einer bestehenden Anthropic-Organisation](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#moving-from-an-existing-anthropic-organization).
Wenn du einen bestehenden Rabatt hast, kontaktiere deinen Anthropic- oder Google Cloud-Ansprechpartner, bevor du mit diesen Schritten beginnst. Rabatte können nicht auf vergangene Nutzung angewendet werden.
1. Öffne [Google Cloud Marketplace](https://console.cloud.google.com/marketplace) und suche den Eintrag **Claude Models on Google Cloud (Anthropic managed)**.
2. Wähle **Subscribe** und schließe den Kaufvorgang ab.
3. Kehre zum Eintrag zurück und wähle **Manage on Console**. Dadurch wird die Claude-Seite in der Google Cloud Console geöffnet.
Um später zur Claude-Seite zurückzukehren, wähle dein Projekt in der Google Cloud Console aus. Gehe dann zu **Agent Platform > Models > Claude Platform** und wähle **Anthropic managed**.
Aktiviere zwei Dienste in jedem Projekt, das Claude Models on Google Cloud (Anthropic managed) aufruft:
* `claude.googleapis.com` stellt die API für Claude Models on Google Cloud (Anthropic managed) bereit. Dieser Dienst definiert auch die IAM-Berechtigungen. Ohne ihn schlagen Aufrufe fehl.
* `anthropic-managed-claude.cloudpartnerservices.goog` ist der Marketplace-Dienst, der die Nutzung des Projekts deinem Abonnement zuordnet.
```bash CLI
gcloud services enable claude.googleapis.com \
anthropic-managed-claude.cloudpartnerservices.goog \
--project=my-project-id
```
Ersetze `my-project-id` durch deine Projekt-ID.
Du kannst beide auch über die Claude-Seite oder über **APIs & Services** aktivieren. Die Aktivierung ist ein einmaliger Schritt pro Projekt. Um zu prüfen, ob beide Dienste aktiviert sind, führe `gcloud services list --enabled --project=my-project-id` aus und suche nach beiden Namen.
1. Wähle auf der Claude-Seite **Activate**.
2. Gib im Anthropic-Einrichtungsablauf eine Kontakt-E-Mail-Adresse ein.
3. Öffne den Einrichtungslink, der an diese Adresse gesendet wurde.
4. Gib den Namen der Organisation, den Rechtsformtyp, das Land und den beabsichtigten Verwendungszweck ein.
5. Akzeptiere die Commercial Terms of Service und die Usage Policy von Anthropic.
Die Kontaktadresse wird nur für die Einrichtung und für Servicehinweise verwendet. Wie Personen die Claude Console nach der Einrichtung öffnen, erfährst du unter [Die Claude Console verwenden](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#using-the-claude-console).
Wenn deine Anthropic-Organisation aktiv ist, ändert sich die Schaltfläche auf der Claude-Seite zu **Open Claude Console**. Wähle sie aus. Google Cloud prüft deinen IAM-Zugriff. Anschließend leitet es deinen Browser zu `platform.claude.com` weiter. Du bist bei der neuen Organisation angemeldet.
Während du in der Claude Console bist, [finde deine Workspace-ID](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#find-your-workspace-id) und kopiere sie. Alle, die Claude Models on Google Cloud (Anthropic managed) aufrufen, benötigen sie. Gib sie an deine Entwickler weiter.
Um ein weiteres Projekt hinzuzufügen, wiederhole diese Schritte in diesem Projekt, beginnend mit Schritt 2.
### Fehlerbehebung bei der Kontoeinrichtung
Wenn bei der Einrichtung von Claude Models on Google Cloud (Anthropic managed) eines der folgenden Probleme auftritt, wende die jeweilige Lösung an:
* **`gcloud services enable` findet `anthropic-managed-claude.cloudpartnerservices.goog` nicht:** Führe den Befehl mit dem Konto aus, das den Marketplace-Kauf abgeschlossen hat, oder kontaktiere deinen Anthropic-Ansprechpartner.
* **Ein Berechtigungsfehler bei deinem ersten API-Aufruf:** Prüfe, ob `claude.googleapis.com` in dem Projekt aktiviert ist, das du aufrufst. Prüfe, ob der Aufrufer `roles/claude.user` oder `roles/claude.admin` für dieses Projekt hat. Was jede Rolle erlaubt, erfährst du unter [IAM-Rollen](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles). Eine neue Berechtigung oder ein neu aktivierter Dienst kann einen Moment brauchen, bis er wirksam wird.
* **„Signed in as a different account" nach dem Aufrufen des Einrichtungslinks:** Wähle **Log out and continue**. Verwende dann die E-Mail-Adresse, die du in Schritt 3 eingegeben hast.
* **Die Schaltfläche zeigt „Finish Setup" statt „Open Claude Console":** Deine Anthropic-Organisation existiert, aber ihre Einrichtung ist nicht abgeschlossen. Ein Administrator muss das Formular mit den Organisationsdetails ausfüllen.
* **Die Usage-Seite zeigt nach deinem ersten API-Aufruf keine Daten:** Es kann einige Minuten dauern, bis Nutzungsdaten in der Claude Console erscheinen.
## Zugriff verwalten
### IAM-Rollen
Claude Models on Google Cloud (Anthropic managed) hat drei vordefinierte IAM-Rollen. Vergib Rollen auf Projektebene.
| Rolle | Anzeigename | Was sie erlaubt |
| --------------------- | ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `roles/claude.viewer` | Claude Viewer | Jede `get`- und `list`-Berechtigung für Workspace-Ressourcen
Diese Rolle ist schreibgeschützt. |
| `roles/claude.user` | Claude User | Alles, was `roles/claude.viewer` erlaubt, plus das Erstellen und Ändern von Workspace-Ressourcen
Dazu gehören das Senden von Nachrichten und das Zählen von Token. Außerdem gehört die Verwaltung von Batches, Dateien, Skills und Claude Managed Agents-Ressourcen dazu. |
| `roles/claude.admin` | Claude Admin | Alles, was `roles/claude.user` erlaubt, plus die Berechtigungen, die für deine Anthropic-Organisation geprüft werden
Routen auf Organisationsebene wirken auf deine Anthropic-Organisation als Ganzes, nicht auf einen einzelnen Workspace. |
Mit dem folgenden Befehl kann beispielsweise ein Dienstkonto Claude Models on Google Cloud (Anthropic managed) aufrufen:
```bash CLI
gcloud projects add-iam-policy-binding my-project-id \
--member="serviceAccount:my-app@my-project-id.iam.gserviceaccount.com" \
--role="roles/claude.user"
```
Zu Berechtigungen, vordefinierten Rollen und Audit-Log-Typen siehe [IAM-Berechtigungen für Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/de/api/claude-models-on-google-cloud-anthropic-managed-iam-permissions).
Durch das Aktivieren von `claude.googleapis.com` wird ein Dienst-Agent für das Projekt erstellt. Entferne seine Rollenzuweisungen nicht. Wenn du sie entfernst, funktioniert Claude Models on Google Cloud (Anthropic managed) im Projekt nicht mehr.
### Die Claude Console verwenden
Mit Claude Models on Google Cloud (Anthropic managed) kannst du dich nicht mit einer E-Mail-Adresse bei deiner Anthropic-Organisation anmelden. Wähle stattdessen **Open Claude Console** auf der [Claude-Seite](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#set-up-your-account) in der Google Cloud Console. Google Cloud IAM steuert, wer die Claude Console öffnen kann. Von den drei vordefinierten [IAM-Rollen](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles) erlaubt nur `roles/claude.admin` für das Projekt das Öffnen der Claude Console.
### Workspaces
In Claude Models on Google Cloud (Anthropic managed) erstellt die Einrichtung deine Anthropic-Organisation mit einem Workspace, dem Default Workspace. Um weitere Workspaces zu erstellen, [öffne die Claude Console](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#using-the-claude-console) und gehe zu **Settings > Workspaces**. Auf derselben Seite kannst du jeden Workspace außer dem Default Workspace umbenennen oder archivieren. Jeder Workspace hat seine eigene [Workspace-ID](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#find-your-workspace-id). Dateien, Skills, Batches, Claude Managed Agents-Sessions und andere Workspace-Ressourcen gehören zu dem Workspace, dessen ID du [für die Anfrage festlegst](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#project-location-and-workspace-resolution).
Du vergibst [IAM-Rollen](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles) auf Projektebene, daher gilt eine Rolle für jeden Workspace in diesem Projekt. Wenn Teams getrennten Zugriff benötigen, gib jedem Team ein eigenes Google Cloud-Projekt. Jedes Projekt hat seine eigene Anthropic-Organisation, wiederhole also die [Einrichtungsschritte](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#set-up-your-account) in jedem Projekt, beginnend mit Schritt 2.
## Vor API-Aufrufen
Um Claude Models on Google Cloud (Anthropic managed) aufzurufen, benötigst du Folgendes:
1. Ein Google Cloud-Projekt mit einem aktiven Abonnement und einer Anthropic-Organisation, deren Einrichtung abgeschlossen ist. Siehe [Dein Konto einrichten](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#set-up-your-account).
2. Die installierte [gcloud CLI](https://cloud.google.com/sdk/docs/install) für die lokale Entwicklung.
3. Die Rolle `roles/claude.user`, für das Projekt an die Identität vergeben, die die Aufrufe durchführt.
4. Application Default Credentials für diese Identität. Siehe [Authentifizierung](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#authentication).
5. Deine Projekt-ID und deine [Workspace-ID](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#find-your-workspace-id).
Um die Rolle für die lokale Entwicklung deinem eigenen Konto zuzuweisen, führe den folgenden Befehl aus. Du benötigst die Berechtigung, die IAM-Richtlinie des Projekts zu ändern.
```bash CLI
gcloud projects add-iam-policy-binding my-project-id \
--member="user:you@example.com" \
--role="roles/claude.user"
```
Ersetze `my-project-id` durch deine Projekt-ID. Ersetze `you@example.com` durch die E-Mail-Adresse deines Google-Kontos. Um das Projekt zu sehen, das gcloud verwendet, führe `gcloud config get-value project` aus. Zu Dienstkonten und den anderen Rollen siehe [IAM-Rollen](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles).
### Deine Workspace-ID finden
Um deine Workspace-ID für Claude Models on Google Cloud (Anthropic managed) zu finden, [öffne die Claude Console](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#using-the-claude-console) und gehe zu **Settings > Workspaces**. Die ID beginnt mit `wrkspc_`. Wenn du die Claude Console nicht öffnen kannst, bitte jemanden, der sie öffnen kann, dir die ID zu schicken.
Lege das Projekt und den Workspace als Umgebungsvariablen fest, damit die SDK-Clients und die [`ant` CLI](https://platform.claude.com/docs/de/cli-sdks-libraries/cli/quickstart) sie übernehmen:
```bash CLI
export ANTHROPIC_GOOGLE_CLOUD_PROJECT="my-project-id"
export ANTHROPIC_GOOGLE_CLOUD_WORKSPACE_ID="wrkspc_01AbCdEf23GhIj"
```
### Ein SDK installieren
Der [SDK-Client](https://platform.claude.com/docs/de/cli-sdks-libraries/overview) für Claude Models on Google Cloud (Anthropic managed) ist `AnthropicGoogleCloud` (csharp: `AnthropicGoogleCloudClient`; go: `googlecloud.NewClient`; java: `GoogleCloudBackend`; php: `Anthropic\GoogleCloud\Client`; ruby: `Anthropic::GoogleCloudClient`). Der Client ermittelt deine Google-Anmeldedaten. Außerdem erstellt er die Basis-URL aus deinem Projekt, deinem Standort und deiner Workspace-ID.
SDK-Clients für Claude Models on Google Cloud (Anthropic managed) befinden sich in der Beta-Phase.
Installiere das Paket, das den Client bereitstellt:
```bash
pip install -U "anthropic[google_cloud]"
```
```bash
npm install @anthropic-ai/google-cloud-sdk
```
```bash
dotnet add package Anthropic.GoogleCloud
```
```bash
go get github.com/anthropics/anthropic-sdk-go
```
```kotlin Gradle
implementation("com.anthropic:anthropic-java:3.1.0")
implementation("com.anthropic:anthropic-java-google-cloud:3.1.0")
```
```xml Maven
com.anthropic
anthropic-java
3.1.0
com.anthropic
anthropic-java-google-cloud
3.1.0
```
```bash
composer require anthropic-ai/sdk google/auth
```
```bash
gem install anthropic googleauth
```
Um stattdessen die `ant` CLI zu verwenden, [installiere oder aktualisiere sie](https://platform.claude.com/docs/de/cli-sdks-libraries/cli/quickstart#installation) auf die neueste Version. Eine Version ohne Unterstützung für Claude Models on Google Cloud (Anthropic managed) ignoriert die `ANTHROPIC_GOOGLE_CLOUD_*`-Variablen. Sie tut dann eines der Folgenden:
* Sie sendet die Anfrage mit einer anderen von dir eingerichteten Anmeldeinformation an die Claude API
* Sie schlägt mit einem Authentifizierungsfehler fehl
## Anfragen stellen
Claude Models on Google Cloud (Anthropic managed) stellt Claude API-Endpunkte unter einer Basis-URL bereit, die dein Projekt, einen Standort und deinen Workspace benennt:
```text wrap
https://claude.googleapis.com/v1/projects/{project}/locations/global/workspaces/{workspace}/invoke
```
Die [Routen auf Organisationsebene](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles), deren Pfade mit `/v1/organizations/` beginnen, verwenden eine Basis-URL ohne den Workspace:
```text wrap
https://claude.googleapis.com/v1/projects/{project}/locations/global/claudeOrganization/invoke
```
Wenn du [die Basis-URL nicht festlegst](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#project-location-and-workspace-resolution), wählen die SDK-Clients für jede Anfrage zwischen diesen beiden.
Hänge den Claude API-Pfad an die Basis-URL an. Die [Messages API](https://platform.claude.com/docs/de/api/messages/create) befindet sich beispielsweise unter `.../invoke/v1/messages`. Drei Dinge unterscheiden sich von einer Claude API-Anfrage:
* **Basis-URL:** Die zuvor gezeigten projektbezogenen URLs anstelle von `https://api.anthropic.com`.
* **Authentifizierung:** Ein `Authorization: Bearer`-Header mit einem Google-Zugriffstoken. Sende keinen `x-api-key`-Header.
* **Workspace:** Die Workspace-ID ist Teil der URL. Sende keinen `anthropic-workspace-id`-Header.
Alles andere ist genauso wie bei der Claude API, einschließlich der folgenden Punkte:
* Die Header `anthropic-version` und `anthropic-beta`
* Der Anfragetext
* Streaming
* Die Antwort
Codebeispiele an anderer Stelle in dieser Dokumentation erstellen den Claude API-Client und lesen einen API-Key. Um eines davon mit Claude Models on Google Cloud (Anthropic managed) auszuführen, ersetze seinen Import und Client-Konstruktor durch die in den folgenden Beispielen. Wende bei einem cURL-Beispiel die drei zuvor aufgeführten Unterschiede an.
Bevor du diese Beispiele ausführst, schließe die Schritte unter [Vor API-Aufrufen](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#before-making-api-calls) ab.
```bash cURL
curl "https://claude.googleapis.com/v1/projects/$ANTHROPIC_GOOGLE_CLOUD_PROJECT/locations/global/workspaces/$ANTHROPIC_GOOGLE_CLOUD_WORKSPACE_ID/invoke/v1/messages" \
-H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
-H "content-type: application/json" \
-H "anthropic-version: 2023-06-01" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 1024,
"messages": [
{"role": "user", "content": "Hello, Claude"}
]
}'
```
```bash CLI
ant messages create \
--model claude-opus-5-5 \
--max-tokens 1024 \
--message '{role: user, content: "Hello, Claude"}'
```
```python Python
from anthropic import AnthropicGoogleCloud
client = AnthropicGoogleCloud()
message = client.messages.create(
model="claude-opus-5-5",
max_tokens=1024,
messages=[{"role": "user", "content": "Hello, Claude"}],
)
print(message)
```
```typescript TypeScript
import { AnthropicGoogleCloud } from "@anthropic-ai/google-cloud-sdk";
const client = new AnthropicGoogleCloud();
const message = await client.messages.create({
model: "claude-opus-5-5",
max_tokens: 1024,
messages: [{ role: "user", content: "Hello, Claude" }]
});
console.log(message);
```
```csharp C#
using Anthropic.GoogleCloud;
using Anthropic.Models.Messages;
var client = new AnthropicGoogleCloudClient();
var parameters = new MessageCreateParams
{
Model = Model.ClaudeOpus5_5,
MaxTokens = 1024,
Messages = [new UserMessageParam { Content = "Hello, Claude" }]
};
var message = await client.Messages.Create(parameters);
Console.WriteLine(message);
```
```go Go
import (
"context"
"fmt"
"github.com/anthropics/anthropic-sdk-go"
"github.com/anthropics/anthropic-sdk-go/googlecloud"
)
func main() {
client, err := googlecloud.NewClient(context.Background(), googlecloud.ClientConfig{})
if err != nil {
panic(err)
}
message, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 1024,
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("Hello, Claude")),
},
})
if err != nil {
panic(err)
}
fmt.Println(message)
}
```
```java Java
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.googlecloud.backends.GoogleCloudBackend;
import com.anthropic.models.messages.Message;
import com.anthropic.models.messages.MessageCreateParams;
import com.anthropic.models.messages.Model;
void main() {
AnthropicClient client = AnthropicOkHttpClient.builder()
.backend(GoogleCloudBackend.fromEnv())
.build();
Message message = client.messages().create(
MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(1024)
.addUserMessage("Hello, Claude")
.build()
);
IO.println(message);
}
```
```php PHP
use Anthropic\GoogleCloud\Client;
use Anthropic\Messages\Model;
$client = new Client();
$message = $client->messages->create(
model: Model::CLAUDE_OPUS_5_5,
maxTokens: 1024,
messages: [['role' => 'user', 'content' => 'Hello, Claude']],
);
echo $message;
```
```ruby Ruby
require "anthropic"
client = Anthropic::GoogleCloudClient.new
message = client.messages.create(
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 1024,
messages: [{ role: "user", content: "Hello, Claude" }]
)
puts message
```
Das cURL-Beispiel fordert bei gcloud ein Application Default Credentials-Token an. Zugriffstoken sind kurzlebig. Erzeuge für jede Sitzung ein neues, anstatt es zu speichern.
### API-Modell-IDs
Claude Models on Google Cloud (Anthropic managed) verwendet dieselben Modell-IDs wie die Claude API, zum Beispiel `claude-opus-5-5`. Zu den Modellen und ihren IDs siehe [Modellübersicht](https://platform.claude.com/docs/de/models/overview).
In Claude Models on Google Cloud (Anthropic managed) gibt eine Anfrage für ein Modell, das für deine Anthropic-Organisation nicht verfügbar ist, einen Fehler zurück. Die Fehlermeldung lautet `Model {model} is not available for this organization's inference configuration.`
## Auflösung von Projekt, Standort und Workspace
Clients für Claude Models on Google Cloud (Anthropic managed) übernehmen die Einstellungen in der folgenden Tabelle. Ein Wert, den du beim Erstellen des Clients übergibst, hat Vorrang vor der Umgebungsvariable. Um das Projekt und die Workspace-ID explizit festzulegen, übergib `project` (go: `Project`; java: `.project()`; csharp: `GoogleCloudClientOptions.Project`; cli: `--google-cloud-project`) und `workspace_id` (typescript, php: `workspaceId`; go: `WorkspaceID`; java: `.workspaceId()`; csharp: `GoogleCloudClientOptions.WorkspaceId`; cli: `--google-cloud-workspace-id`).
| Einstellung | Umgebungsvariable | Wenn nicht gesetzt |
| ------------ | ------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Projekt-ID | `ANTHROPIC_GOOGLE_CLOUD_PROJECT`, dann `GOOGLE_CLOUD_PROJECT` | Das Projekt, das Application Default Credentials meldet, sofern der Anmeldedatentyp eines enthält |
| Workspace-ID | `ANTHROPIC_GOOGLE_CLOUD_WORKSPACE_ID` | Der Client löst einen Fehler aus, sofern du nicht die Basis-URL festlegst. [Routen auf Organisationsebene](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles) benötigen keine Workspace-ID. |
| Standort | `ANTHROPIC_GOOGLE_CLOUD_LOCATION` | `global` |
| Basis-URL | `ANTHROPIC_GOOGLE_CLOUD_BASE_URL` | Abgeleitet aus Projekt, Standort und Workspace-ID |
Belasse den Standort bei `global`. Der Standort ist unabhängig davon, wo die Inferenz ausgeführt wird. Für reine US-Inferenz setze daher bei jeder Anfrage `inference_geo: "us"`, wie unter [Datenresidenz](https://platform.claude.com/docs/de/manage-claude/data-residency#inference-geo) beschrieben.
Die `ant` CLI übernimmt dieselben Einstellungen als Flags:
* **Projekt-ID:** `--google-cloud-project`
* **Workspace-ID:** `--google-cloud-workspace-id`
* **Standort:** `--google-cloud-location`
* **Basis-URL:** `--google-cloud-base-url`
Die CLI verwendet Claude Models on Google Cloud (Anthropic managed), wenn das Projekt, die Workspace-ID oder der Standort festgelegt ist. Das Festlegen von `GOOGLE_CLOUD_PROJECT`, der Basis-URL oder beidem reicht nicht aus.
## Authentifizierung
Jede Anfrage an Claude Models on Google Cloud (Anthropic managed) enthält ein Google OAuth 2.0-Zugriffstoken in einem `Authorization: Bearer`-Header. Das Token hat den Scope `https://www.googleapis.com/auth/cloud-platform`.
Google Cloud übernimmt den Zugriff. Sein Gateway unter `claude.googleapis.com` tut für jede Anfrage Folgendes:
1. Es prüft deine Google Cloud-Anmeldedaten.
2. Es prüft, ob der Aufrufer die IAM-Berechtigung besitzt, die die Anfrage benötigt. Falls nicht, gibt Google Cloud einen HTTP-403-Fehler zurück.
3. Es leitet die Anfrage an Anthropic weiter. Anthropic validiert die Anfrage.
Um Berechtigungen zu vergeben, siehe [IAM-Rollen](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles).
Die SDK-Clients beziehen das Token aus [Application Default Credentials](https://cloud.google.com/docs/authentication/application-default-credentials) (ADC). Jede Anmeldedatenquelle, die ADC unterstützt, funktioniert:
* **Lokale Entwicklung:** Führe `gcloud auth application-default login` aus.
* **Auf Google Cloud:** Der Client verwendet automatisch das Dienstkonto, das an die Workload angehängt ist, zum Beispiel auf Compute Engine, GKE oder Cloud Run.
* **Eine Dienstkonto-Schlüsseldatei:** Setze `GOOGLE_APPLICATION_CREDENTIALS` auf ihren Pfad.
* **Workload Identity Federation und Dienstkonto-Identitätswechsel:** Konfiguriere sie wie für jede andere Google Cloud API.
Prüfe, ob ADC funktioniert:
```bash CLI
gcloud auth application-default print-access-token
```
Claude Models on Google Cloud (Anthropic managed) verwendet keine API-Keys. In der Claude Console kannst du keine API-Keys für die Anthropic-Organisation erstellen, die bei der Einrichtung erstellt wird. Die SDK-Clients für Claude Models on Google Cloud (Anthropic managed) ignorieren diese Umgebungsvariablen:
* `ANTHROPIC_API_KEY`
* `ANTHROPIC_AUTH_TOKEN`
* `ANTHROPIC_BASE_URL`
### Rangfolge der Anmeldedaten
Der SDK-Client für Claude Models on Google Cloud (Anthropic managed) sucht in der folgenden Reihenfolge nach Anmeldedaten. Der Client verwendet die ersten, die er findet:
1. Ein Token-Provider, den du beim Erstellen des Clients als `token_provider` (typescript: `bearerTokenProvider`; csharp: `GoogleCloudClientOptions.TokenProvider`; go: `TokenSource`; java: `.bearerTokenSupplier()`; php: `tokenProvider`) übergibst. Es handelt sich um eine Funktion oder Token-Quelle, die ein Zugriffstoken zurückgibt. Der Client fordert bei jeder Anfrage ein Token von ihr an. Das Zwischenspeichern und Aktualisieren des Tokens liegt bei dir.
2. Ein Google-Anmeldedatenobjekt, das du beim Erstellen des Clients als `credentials` (typescript: `googleAuth`; csharp: `GoogleCloudClientOptions.GoogleCredential`; java: `.googleCredentials()`; php: `googleCredentials`; ruby: `google_credentials`) übergibst. Das Go SDK hat diese Option nicht.
3. Application Default Credentials.
Go und Java unterscheiden sich von den anderen SDKs:
* **Go:** Für Option 1 nimmt der Client eine `oauth2.TokenSource` entgegen. Er speichert das Token zwischen, bis es abläuft.
* **Java:** Verwende `GoogleCloudBackend.fromEnv()`, um Application Default Credentials und die Umgebungsvariablen aus [Auflösung von Projekt, Standort und Workspace](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#project-location-and-workspace-resolution) zu lesen.
Der Client hat keine eigene Umgebungsvariable für die Anmeldedaten. Verwende stattdessen `GOOGLE_APPLICATION_CREDENTIALS` von ADC.
Wenn deine Anfragen über einen Proxy laufen, der das Token für dich anhängt, setze `skip_auth` (typescript, php: `skipAuth`; go: `SkipAuth`; java: `.skipAuth()`; csharp: `GoogleCloudClientOptions.SkipAuth`). Der Client sendet dann keinen `Authorization`-Header. Du kannst diese Einstellung nicht mit den vorherigen Anmeldedatenoptionen kombinieren.
Wenn die `ant` CLI Claude Models on Google Cloud (Anthropic managed) verwendet, bezieht sie das Token immer aus Application Default Credentials. Sie akzeptiert keinen Token-Provider, kein Anmeldedatenobjekt und keine Skip-Auth-Einstellung.
Bevor du `ant` mit Claude Models on Google Cloud (Anthropic managed) verwendest, stelle sicher, dass nichts davon gesetzt ist:
* Ein API-Key
* Ein Auth-Token
* `--profile` oder `ANTHROPIC_PROFILE`, falls es ein [Konfigurationsprofil](https://platform.claude.com/docs/de/manage-claude/wif-reference#profile-configuration-file) benennt, mit dem sich die CLI authentifizieren kann
* Eine der Föderationsvariablen von Anthropic:
* `ANTHROPIC_FEDERATION_RULE_ID`
* `ANTHROPIC_ORGANIZATION_ID`
* `ANTHROPIC_SERVICE_ACCOUNT_ID`
* `ANTHROPIC_IDENTITY_TOKEN`
* `ANTHROPIC_IDENTITY_TOKEN_FILE`
Wenn eines davon gesetzt ist, verwendet die CLI diese Anmeldeinformation anstelle der Google Cloud-Einstellungen aus [Deine Workspace-ID finden](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#find-your-workspace-id). Wenn nur einige der Föderationsvariablen gesetzt sind, bricht die CLI mit einem Fehler ab. Wenn mehr als eine Anmeldeinformation gesetzt ist, gibt die CLI einen Hinweis aus, der die verwendete benennt.
Lass außerdem `ANTHROPIC_WORKSPACE_ID` und das Flag `--workspace-id` ungesetzt. Die CLI sendet diesen Wert weiterhin als `anthropic-workspace-id`-Header. Anfragen an Claude Models on Google Cloud (Anthropic managed) dürfen diesen Header nicht enthalten. Lege den Workspace stattdessen mit `--google-cloud-workspace-id` oder `ANTHROPIC_GOOGLE_CLOUD_WORKSPACE_ID` fest.
Wie die SDK-Clients sendet auch die CLI Anfragen für Claude Models on Google Cloud (Anthropic managed) nicht an `--base-url` oder `ANTHROPIC_BASE_URL`.
## Funktionsunterstützung
Dieser Abschnitt listet Funktionen auf, die auf Claude Models on Google Cloud (Anthropic managed) funktionieren, sowie Funktionen, die dort nicht unterstützt werden. Er listet nicht jede Claude API-Funktion auf und sagt nichts darüber aus, ob eine nicht aufgeführte Funktion funktioniert.
Die folgenden Funktionen funktionieren auf Claude Models on Google Cloud (Anthropic managed) genauso wie auf der Claude API:
* **Fast mode:** [Fast mode](https://platform.claude.com/docs/de/build-with-claude/fast-mode) für Claude Opus 5.5.
- **Beta-Funktionen:** Wenn eine Beta auf der Claude API auf ausgewählte Organisationen beschränkt ist, benötigt die bei der Einrichtung erstellte Anthropic-Organisation denselben Zugriff.
- **Tools:** [Tool-Nutzung](https://platform.claude.com/docs/de/agents-and-tools/tool-use/overview), einschließlich:
* Websuche
* Web-Abruf
* Codeausführung
* Das Memory-Tool
* Das Advisor-Tool
* Der MCP-Connector
- **Skills und Dateien:** [Agent Skills](https://platform.claude.com/docs/de/agents-and-tools/agent-skills/overview) und die [Files API](https://platform.claude.com/docs/de/build-with-claude/files).
- **Modellfähigkeiten:**
* [Prompt-Caching](https://platform.claude.com/docs/de/build-with-claude/prompt-caching)
* [Erweitertes Nachdenken](https://platform.claude.com/docs/de/build-with-claude/thinking)
* [Serverseitiger Fallback](https://platform.claude.com/docs/de/build-with-claude/refusals-and-fallback#server-side-fallback)
* [Streaming](https://platform.claude.com/docs/de/build-with-claude/streaming)
* [Strukturierte Ausgaben](https://platform.claude.com/docs/de/build-with-claude/structured-outputs)
* [Token-Zählung](https://platform.claude.com/docs/de/build-with-claude/token-counting)
- **Batches und Modelle:** Die [Message Batches API](https://platform.claude.com/docs/de/build-with-claude/batch-processing) und die Models API.
Um die [Compliance API](https://platform.claude.com/docs/de/manage-claude/compliance-api) für die bei der Einrichtung erstellte Anthropic-Organisation ein- oder auszuschalten, [öffne die Claude Console](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#using-the-claude-console), gehe zu **Settings > Compliance** und verwende den Schalter **Compliance API**.
Kundenverwaltete Verschlüsselungsschlüssel (CMEK) sind mit Google Cloud KMS-Schlüsseln verfügbar. Um CMEK für die bei der Einrichtung erstellte Anthropic-Organisation zu aktivieren, siehe [Kundenverwaltete Verschlüsselungsschlüssel](https://platform.claude.com/docs/de/manage-claude/cmek). Um einen Schlüssel einzurichten, folge [Google Cloud KMS für CMEK konfigurieren](https://platform.claude.com/docs/de/manage-claude/cmek-google-cloud-kms). Registriere, verifiziere und hänge den Schlüssel dann in der [Claude Console](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#using-the-claude-console) an, wie es der Tab **Claude Console** der Einrichtungsseite beschreibt.
### Claude Managed Agents
[Claude Managed Agents](https://platform.claude.com/docs/de/managed-agents/overview) ist über Claude Models on Google Cloud (Anthropic managed) verfügbar, einschließlich der folgenden Punkte:
* [Agents](https://platform.claude.com/docs/de/managed-agents/agent-setup)
* [Environments](https://platform.claude.com/docs/de/managed-agents/environments)
* [Sessions](https://platform.claude.com/docs/de/managed-agents/sessions)
* [Credential Vaults](https://platform.claude.com/docs/de/managed-agents/vaults)
* [Memory Stores](https://platform.claude.com/docs/de/managed-agents/memory)
* [Geplante Deployments](https://platform.claude.com/docs/de/managed-agents/scheduled-deployments)
* [Selbst gehostete Sandboxes](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes)
Der Zugriff wird geprüft, wenn eine Session oder ein Deployment erstellt wird, nicht während der Ausführung:
* **Laufende Sessions laufen weiter.** Wenn du der Identität, die eine Session erstellt hat, den Google Cloud-Zugriff entziehst, wird die Session nicht beendet. Um sie zu beenden, sende ihr ein einzelnes [`user.interrupt`-Event](https://platform.claude.com/docs/de/managed-agents/events-and-streaming#integrating-events). Sobald die Session `idle` ist, kannst du sie archivieren oder löschen.
* **Geplante Deployments laufen weiter.** Ein Deployment prüft den Zugriff seines Erstellers nicht bei jeder geplanten Ausführung erneut. Um es zu beenden, pausiere, aktualisiere oder archiviere es.
Wenn du einen Benutzer entfernst oder ein Dienstkonto rotierst, überprüfe die Sessions und Deployments, die diese Identität erstellt hat.
### Nicht unterstützte Funktionen
Folgendes wird auf Claude Models on Google Cloud (Anthropic managed) nicht unterstützt:
* **API-Keys:** Die Authentifizierung erfolgt ausschließlich über Google Cloud-Anmeldedaten.
* **MCP-Tunnel:** [MCP-Tunnel](https://platform.claude.com/docs/de/agents-and-tools/mcp-tunnels/overview) sind auf Claude Models on Google Cloud (Anthropic managed) nicht verfügbar.
* **[Memory Stores in selbst gehosteten Umgebungen](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-memory):** Memory Stores werden für Sessions in selbst gehosteten Umgebungen nicht unterstützt.
* **Vorgefertigte Worker für selbst gehostete Sandboxes:** Die [selbst gehosteten Worker](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-workers) in der `ant` CLI und in den Python-, TypeScript- und Go-SDKs unterstützen Claude Models on Google Cloud (Anthropic managed) nicht. Implementiere stattdessen deinen eigenen Worker, der die [Environments Work-Endpunkte](https://platform.claude.com/docs/de/api/beta/environments/work) direkt aufruft. Informationen zu den Rollen und Berechtigungen, die dein Worker benötigt, findest du unter [IAM-Berechtigungen für Environments](https://platform.claude.com/docs/de/api/claude-models-on-google-cloud-anthropic-managed-iam-permissions#environments).
### Kontextfenster
Die Größen des „context window" (Kontextfenster) auf Claude Models on Google Cloud (Anthropic managed) sind dieselben wie auf der Claude API. Zum Limit jedes Modells siehe [Kontextfenster](https://platform.claude.com/docs/de/build-with-claude/context-windows).
## Abrechnung, Ratenlimits und Protokollierung
### Ratenlimits
Anthropic verwaltet die „rate limits" (Ratenlimits) für Claude Models on Google Cloud (Anthropic managed). Um höhere Limits anzufordern, kontaktiere deinen Anthropic-Ansprechpartner oder [kontaktiere den Vertrieb](https://claude.com/contact-sales). Wie Ratenlimits gemessen und gemeldet werden, erfährst du unter [Ratenlimits](https://platform.claude.com/docs/de/api/rate-limits).
### Abrechnung
Claude Models on Google Cloud (Anthropic managed) wird über Google Cloud Marketplace abgerechnet. Anthropic misst deine Nutzung. Es meldet die Nutzung in Claude Consumption Units an Google Cloud. Die Kosten erscheinen auf deiner Google Cloud-Rechnung. Anthropic sendet keine separate Rechnung.
Nutzungs- und Kostendaten findest du auf den Seiten **Usage** und **Cost** in der [Claude Console](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#using-the-claude-console).
Wenn du eine Google Cloud-Ausgabenverpflichtung hast, wird die Nutzung darauf angerechnet, so wie andere Marketplace-Käufe.
### Datenaufbewahrung
Anthropic ist der Datenverarbeiter für Claude Models on Google Cloud (Anthropic managed). Einige unterstützende Dienste, wie die Trust-and-Safety-Systeme von Anthropic, verarbeiten Daten außerhalb von Google Cloud.
Claude Models on Google Cloud (Anthropic managed) folgt derselben Datenaufbewahrungsrichtlinie wie die Claude API. Siehe [API und Datenaufbewahrung](https://platform.claude.com/docs/de/manage-claude/api-and-data-retention). Zero Data Retention (ZDR) ist auf Anfrage verfügbar. Kontaktiere deinen Anthropic-Ansprechpartner.
Eine ZDR-Vereinbarung für eine andere Anthropic-Organisation wird nicht auf deine Organisation für Claude Models on Google Cloud (Anthropic managed) übertragen.
### Überwachung und Protokollierung
[Cloud Audit Logs](https://cloud.google.com/logging/docs/audit) zeichnet API-Aktivitäten für Claude Models on Google Cloud (Anthropic managed) in deinem Projekt auf. Die Einträge erscheinen unter dem Dienst `claude.googleapis.com`. Jede API-Route gehört zu einem von zwei Log-Typen:
* **Data Access-Logs:** Diese decken die meisten Routen ab, einschließlich Nachrichten, Batches, Dateien, Skills, Modelle und der meisten Claude Managed Agents-Ressourcen. Sie sind standardmäßig deaktiviert.
* **Admin Activity-Logs:** Diese decken die übrigen Routen ab, einschließlich der Routen für Verschlüsselungsschlüssel und der meisten Credential-Vault-Routen. Die Ausnahme ist die Route für `vaults.verify`, die zu Data Access gehört. Admin Activity-Logs sind immer aktiviert.
Um Anfragen aufzuzeichnen, aktiviere Data Access-Logs für `claude.googleapis.com` in den Audit-Log-Einstellungen deines Projekts.
Zu Audit-Log-Typen nach Route siehe [IAM-Berechtigungen für Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/de/api/claude-models-on-google-cloud-anthropic-managed-iam-permissions).
#### Anfrage-IDs
Erfolgreiche Antworten von Claude Models on Google Cloud (Anthropic managed) enthalten den Header [`request-id`](https://platform.claude.com/docs/de/api/errors#request-id).
## Umzug von einer bestehenden Anthropic-Organisation
Du kannst eine bestehende Anthropic-Organisation nicht in eine Organisation für Claude Models on Google Cloud (Anthropic managed) umwandeln. Das gilt auch für eine Organisation, die du direkt mit der Claude API verwendest.
Plane den Umzug als Umstellung auf eine neue Organisation:
* **Erstelle zuerst die neue Organisation.** Folge [Dein Konto einrichten](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#set-up-your-account).
* **Erstelle Zugriff und Konfiguration neu.** API-Keys, Workspaces und Claude Console-Einstellungen werden nicht übernommen. Vergib [IAM-Rollen](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles) für das Projekt, anstatt API-Keys zu erstellen. Um deine Workspaces neu zu erstellen, siehe [Workspaces](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#workspaces). Zu ZDR-Vereinbarungen siehe [Datenaufbewahrung](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#data-retention).
* **Plane für gespeicherte Ressourcen.** Dateien, Skills, Batches und Claude Managed Agents-Ressourcen verbleiben in der bestehenden Organisation.
* **Aktualisiere deine Integration.** Was sich ändert und was gleich bleibt, erfährst du unter [Anfragen stellen](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#making-requests). Zu nicht unterstützten Funktionen siehe [Nicht unterstützte Funktionen](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#features-not-supported).
* **Stelle nach deinem eigenen Zeitplan um.** Die beiden Organisationen sind unabhängig und können parallel Traffic verarbeiten. Du kannst Workloads schrittweise verlagern. Die bestehende Organisation behält ihre aktuelle Abrechnung. Bevor du Produktions-Traffic verlagerst, prüfe die [Ratenlimits](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#rate-limits).
## Migration von Claude Models on Google Cloud (Google managed)
Um zu Claude Models on Google Cloud (Anthropic managed) zu wechseln, führe die folgenden Schritte aus. Bevor du Workloads verschiebst, die auf einer ZDR-Vereinbarung beruhen, lies [Datenaufbewahrung](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#data-retention). Was sich beim Wechsel ändert, erfährst du unter [Wie sich die beiden Google Cloud-Angebote unterscheiden](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/overview#how-the-two-google-cloud-offerings-differ).
Führe jeden Schritt unter [Richte dein Konto ein](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#set-up-your-account) aus.
Weise jeder Identität, die Claude Models on Google Cloud (Anthropic managed) aufruft, `roles/claude.user` zu. Lege dein Projekt und deine Workspace-ID als Umgebungsvariablen fest. Für beides siehe [Bevor du API-Aufrufe durchführst](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#before-making-api-calls).
Installiere das Paket, das den Client für Claude Models on Google Cloud (Anthropic managed) bereitstellt. Siehe [Ein SDK installieren](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#install-an-sdk).
Ändere den Code, der deinen Client importiert und erstellt. Verwende `AnthropicGoogleCloud` (csharp: `AnthropicGoogleCloudClient`; go: `googlecloud.NewClient`; java: `GoogleCloudBackend`; php: `Anthropic\GoogleCloud\Client`; ruby: `Anthropic::GoogleCloudClient`) anstelle von `AnthropicVertex` (csharp: `AnthropicVertexClient`; go: `vertex.WithGoogleAuth`; java: `VertexBackend`; php: `Anthropic\Vertex\Client`; ruby: `Anthropic::VertexClient`). Ändere in einer cURL-Anfrage die URL, die Header und den Body. Dein aktueller Code erstellt einen Client für Claude Models on Google Cloud (Google managed). Der folgende Code erstellt diesen Client beispielsweise mit dem globalen Endpunkt:
```bash cURL
curl https://aiplatform.googleapis.com/v1/projects/MY_PROJECT_ID/locations/global/publishers/anthropic/models/claude-opus-5-5:rawPredict \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
-d '{
"anthropic_version": "vertex-2023-10-16",
"messages": [{"role": "user", "content": "Hey Claude!"}],
"max_tokens": 100
}'
```
Die `ant` CLI unterstützt Claude Models on Google Cloud (Google managed) nicht.
```python Python
from anthropic import AnthropicVertex
project_id = "MY_PROJECT_ID"
region = "global"
client = AnthropicVertex(project_id=project_id, region=region)
```
```typescript TypeScript
import { AnthropicVertex } from "@anthropic-ai/vertex-sdk";
const projectId = "MY_PROJECT_ID";
const region = "global";
const client = new AnthropicVertex({
projectId,
region
});
```
```csharp C#
using Anthropic.Vertex;
var projectId = "MY_PROJECT_ID";
var region = "global";
var client = new AnthropicVertexClient(new AnthropicVertexCredentials(region, projectId));
```
```go Go
import (
"context"
"github.com/anthropics/anthropic-sdk-go"
"github.com/anthropics/anthropic-sdk-go/vertex"
)
// ...
// Verwendet die Standard-Anmeldedaten von Google Cloud
client := anthropic.NewClient(
vertex.WithGoogleAuth(context.Background(), "global", "MY_PROJECT_ID"),
)
```
```java Java
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.vertex.backends.VertexBackend;
import com.google.auth.oauth2.GoogleCredentials;
void main() throws Exception {
AnthropicClient client = AnthropicOkHttpClient.builder()
.backend(
VertexBackend.builder()
.googleCredentials(GoogleCredentials.getApplicationDefault())
.region("global")
.project("MY_PROJECT_ID")
.build()
)
.build();
}
```
```php PHP
use Anthropic\Vertex;
$client = Vertex\Client::fromEnvironment(
region: 'global',
projectId: 'MY_PROJECT_ID',
);
```
```ruby Ruby
require "anthropic"
client = Anthropic::VertexClient.new(
region: "global",
project_id: "MY_PROJECT_ID"
)
```
Der folgende Code erstellt den Client für Claude Models on Google Cloud (Anthropic managed):
```bash cURL
curl "https://claude.googleapis.com/v1/projects/$ANTHROPIC_GOOGLE_CLOUD_PROJECT/locations/global/workspaces/$ANTHROPIC_GOOGLE_CLOUD_WORKSPACE_ID/invoke/v1/messages" \
-H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
-H "content-type: application/json" \
-H "anthropic-version: 2023-06-01" \
-d '{
"model": "claude-opus-5-5",
"max_tokens": 1024,
"messages": [
{"role": "user", "content": "Hello, Claude"}
]
}'
```
```bash CLI
ant messages create \
--model claude-opus-5-5 \
--max-tokens 1024 \
--message '{role: user, content: "Hello, Claude"}'
```
```python Python
from anthropic import AnthropicGoogleCloud
client = AnthropicGoogleCloud()
```
```typescript TypeScript
import { AnthropicGoogleCloud } from "@anthropic-ai/google-cloud-sdk";
const client = new AnthropicGoogleCloud();
```
```csharp C#
using Anthropic.GoogleCloud;
var client = new AnthropicGoogleCloudClient();
```
```go Go
import (
"context"
"github.com/anthropics/anthropic-sdk-go"
"github.com/anthropics/anthropic-sdk-go/googlecloud"
)
// ...
client, err := googlecloud.NewClient(context.Background(), googlecloud.ClientConfig{})
if err != nil {
panic(err)
}
```
```java Java
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.googlecloud.backends.GoogleCloudBackend;
void main() {
AnthropicClient client = AnthropicOkHttpClient.builder()
.backend(GoogleCloudBackend.fromEnv())
.build();
}
```
```php PHP
use Anthropic\GoogleCloud\Client;
$client = new Client();
```
```ruby Ruby
require "anthropic"
client = Anthropic::GoogleCloudClient.new
```
Der neue Client liest dein Projekt und deine Workspace-ID aus den Umgebungsvariablen, die du unter [Finde deine Workspace-ID](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#find-your-workspace-id) festgelegt hast. Du übergibst sie nicht beim Erstellen des Clients. Deine Messages-API-Aufrufe bleiben unverändert, mit Ausnahme der Modell-IDs und Funktionen im nächsten Schritt.
* **Modell-IDs:** Wenn du ein Modell vor Claude 4.6 verwendest, ersetze das `@` vor dem Snapshot-Datum in seiner ID durch einen Bindestrich. Zum Beispiel wird `claude-haiku-4-5@20251001` zu `claude-haiku-4-5-20251001`. Die Modelle und ihre IDs findest du unter [API-Modell-IDs](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#api-model-ids).
* **Funktionen:** Prüfe unter [Funktionsunterstützung](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#feature-support) jede Funktion, die dein Code verwendet.
* **Standort:** Wenn du heute einen Multi-Region- oder regionalen Endpunkt verwendest, prüfe, welchen Standort Claude Models on Google Cloud (Anthropic managed) verwendet. Siehe [Auflösung von Projekt, Standort und Workspace](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#project-location-and-workspace-resolution).
Führe die Anfrage unter [Anfragen stellen](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#making-requests) aus, um zu prüfen, ob deine Einrichtung funktioniert. Führe dann deinen eigenen Code aus. Wenn ein Aufruf mit einem Berechtigungsfehler fehlschlägt, siehe [Fehlerbehebung bei der Kontoeinrichtung](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#troubleshooting-account-setup). Bevor du Produktions-Traffic verschiebst, prüfe die [Ratenlimits](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#rate-limits).
## Nächste Schritte
Entdecke die Funktionen von Claude.
Schlage Berechtigungen, Rollen und Audit-Log-Typen nach.
Wenn sicherere und leistungsfähigere Modelle erscheinen, stellt Anthropic ältere Modelle regelmäßig ein. Sieh dir alle API-Abkündigungen zusammen mit empfohlenen Ersatzmodellen an.
Verwalte dein Abonnement und deine Abrechnung.