--- title: Claude in Microsoft Foundry url: https://platform.claude.com/docs/de/build-with-claude/claude-in-microsoft-foundry description: Greife über Microsoft Foundry mit Azure-nativen Endpunkten und Authentifizierung auf Claude-Modelle zu. --- Diese Anleitung zeigt dir, wie du Claude in Microsoft Foundry einrichtest und API-Aufrufe mit einem der Client-SDKs von Anthropic oder mit direkten HTTP-Anfragen durchführst. Wenn du Claude in Microsoft Foundry nutzt, wird dir die Claude-Nutzung über den Azure Marketplace in Rechnung gestellt. Du kannst Claude-Modelle wie Claude Fable 5.1, Claude Opus 5.5, Claude Opus 5, Claude Opus 4.8, Claude Sonnet 5.5, Claude Sonnet 5 und Claude Haiku 5.5 sowie Funktionen wie das [„context window" (Kontextfenster) mit 1M Token](https://platform.claude.com/docs/de/build-with-claude/context-windows) nutzen und dabei die Kosten über dein Azure-Abonnement verwalten. Claude ist in Foundry-Ressourcen in den Bereitstellungstypen Global Standard und US Data Zone Standard verfügbar und wird in Claude Consumption Units über den Azure Marketplace abgerechnet. Details findest du unter [Preise für Claude in Microsoft Foundry](https://platform.claude.com/docs/de/about-claude/pricing#claude-in-microsoft-foundry-pricing). ## Hosting-Optionen Claude-Modelle in Microsoft Foundry sind in zwei Hosting-Optionen verfügbar. Du wählst die Hosting-Option, wenn du das Deployment konfigurierst. | | Hosted on Azure | Hosted on Anthropic | | --------------------- | ---------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Wo die Inferenz läuft | Von Anthropic betriebener Dienst auf Azure-Infrastruktur | Von Anthropic betriebener Dienst auf Anthropic-Infrastruktur | | Modellverfügbarkeit | Die neuesten Modelle der Opus-, Sonnet- und Haiku-Familien | Alle in Microsoft Foundry verfügbaren Claude-Modelle | | Bereitstellungstypen | Global Standard, US Data Zone Standard | Global Standard | | Empfohlen für | Die meisten Workloads | [Zugriff auf Funktionen oder Modelle, die noch nicht auf Azure gehostet werden](https://platform.claude.com/docs/de/build-with-claude/claude-in-microsoft-foundry#additional-features-not-supported-when-hosted-on-azure) | Claude Sonnet 5.5 unterstützt nur Global-Standard-Deployments. Anthropic agiert als unabhängiger Auftragsverarbeiter für Microsoft. Kunden, die Claude über Microsoft Foundry nutzen, unterliegen den Datennutzungsbedingungen von Anthropic. Bei auf Azure gehosteten Deployments verbleiben Prompts und Completions innerhalb von Azure. Nur Nutzungsmetadaten und von den Sicherheitssystemen von Anthropic markierte Inhalte werden an Anthropic übertragen. Anthropic hält seine Sicherheits- und Datenzusagen weiterhin ein. ## Voraussetzungen Bevor du beginnst, stelle sicher, dass du Folgendes hast: * Ein aktives Azure-Abonnement * Zugriff auf das [Foundry-Portal](https://ai.azure.com/) * Die installierte [Azure CLI](https://learn.microsoft.com/en-us/cli/azure/install-azure-cli) (erforderlich für die Entra-ID-Beispiele mit cURL und CLI, ansonsten optional) * Eine Azure-RBAC-Rolle, die dir die Nutzung der Ressource erlaubt, z. B. **Foundry User** (früher Azure AI User) oder **Cognitive Services User** ## Ein SDK installieren Die [Client-SDKs](https://platform.claude.com/docs/de/cli-sdks-libraries/overview) von Anthropic unterstützen Foundry über ein plattformspezifisches Paket oder eine Client-Klasse. Die Beispiele auf dieser Seite zeigen außerdem Anfragen mit cURL und der ant CLI. Informationen zur Einrichtung der CLI findest du im [CLI-Schnellstart](https://platform.claude.com/docs/de/cli-sdks-libraries/cli/quickstart). Foundry wird von den SDKs für C#, Go, Java, PHP, Python und TypeScript unterstützt. Im Ruby-SDK ist Foundry derzeit nicht verfügbar. ```bash pip install -U "anthropic" # Für die Entra ID-Authentifizierung installiere zusätzlich die Azure Identity-Bibliothek pip install azure-identity ``` ```bash npm install @anthropic-ai/foundry-sdk # Für die Entra ID-Authentifizierung installiere zusätzlich die Azure Identity-Bibliothek npm install @azure/identity ``` ```bash dotnet add package Anthropic.Foundry ``` ```bash go get github.com/anthropics/anthropic-sdk-go/foundry # Für die Authentifizierung mit Entra ID installiere zusätzlich die Azure Identity-Bibliothek go get github.com/Azure/azure-sdk-for-go/sdk/azidentity ``` ```kotlin implementation("com.anthropic:anthropic-java:2.73.0") implementation("com.anthropic:anthropic-java-foundry:2.73.0") // Für die Entra ID-Authentifizierung füge zusätzlich die Azure Identity-Bibliothek hinzu implementation("com.azure:azure-identity:1.18.3") ``` ```xml com.anthropic anthropic-java 2.73.0 com.anthropic anthropic-java-foundry 2.73.0 com.azure azure-identity 1.18.3 ``` ```bash composer require "anthropic-ai/sdk" "guzzlehttp/guzzle:^7" ``` ```bash # Das Ruby SDK unterstützt Foundry noch nicht nativ (siehe die Authentifizierungs- # Beispiele zur Nutzung des Standard-Ruby-SDK als Workaround) # Gemfile gem "anthropic" ``` ## Bereitstellung Foundry verwendet eine zweistufige Hierarchie: **Ressourcen** enthalten deine Sicherheits- und Abrechnungskonfiguration, während **Deployments** die Modellinstanzen sind, die du über die API aufrufst. Du erstellst zuerst eine Foundry-Ressource und anschließend ein oder mehrere Claude-Deployments darin. ### Foundry-Ressourcen bereitstellen Erstelle eine Foundry-Ressource, die erforderlich ist, um Dienste in Azure zu nutzen und zu verwalten. Du kannst diesen Anweisungen folgen, um eine [Foundry-Ressource](https://learn.microsoft.com/en-us/azure/ai-services/multi-service-resource?pivots=azportal#create-a-new-azure-ai-foundry-resource) zu erstellen. Alternativ kannst du mit dem Erstellen eines [Foundry-Projekts](https://learn.microsoft.com/en-us/azure/foundry/how-to/create-projects) beginnen, was das Erstellen einer Foundry-Ressource beinhaltet. So stellst du deine Ressource bereit: 1. Navigiere zum [Foundry-Portal](https://ai.azure.com/). 2. Erstelle eine neue Foundry-Ressource oder wähle eine bestehende aus. 3. Konfiguriere die Zugriffsverwaltung mit von Azure ausgestellten API-Keys oder Entra ID (früher Azure Active Directory) für rollenbasierte Zugriffskontrolle. 4. Konfiguriere die Ressource optional als Teil eines privaten Netzwerks (Azure Virtual Network), um den Netzwerkzugriff auf deine Ressource einzuschränken. 5. Notiere dir deinen Ressourcennamen. Du verwendest ihn als `{resource}` in API-Endpunkten (zum Beispiel `https://{resource}.services.ai.azure.com/anthropic/v1/*`). ### Foundry-Deployments erstellen Nachdem du deine Ressource erstellt hast, stelle ein Claude-Modell bereit, um es für API-Aufrufe verfügbar zu machen. Diese Schritte beschreiben das neue Foundry-Portal (der Schalter **New Foundry** ist aktiviert): 1. Melde dich beim Foundry-Portal an. Wähle auf der Startseite des Portals **Discover** in der Navigation oben rechts und dann **Models** im linken Bereich, um den Modellkatalog zu öffnen. 2. Suche nach einem Claude-Modell und wähle es aus (zum Beispiel claude-opus-5-5). Jedes Modell erscheint nur einmal im Katalog, unabhängig davon, wie viele Hosting-Optionen es unterstützt. 3. Wähle auf der Modellkarte **Deploy** und dann **Custom settings**, um den Bereich mit den Deployment-Einstellungen zu öffnen. Wenn du stattdessen **Default settings** wählst, wird das Deployment bei Modellen, die in beiden Hosting-Optionen verfügbar sind, automatisch als Hosted on Azure konfiguriert. 4. Prüfe bei deinem ersten Claude-Deployment die Bedingungen des Azure Marketplace, wähle eine Branche aus und wähle **Agree and Proceed**, um die Bedingungen zu akzeptieren und das Azure-Marketplace-Angebot zu abonnieren. 5. Konfiguriere das Deployment: * **Deployment name:** Standardmäßig die Modell-ID, du kannst ihn aber anpassen (zum Beispiel `my-claude-deployment`). Der Deployment-Name kann nach der Erstellung nicht mehr geändert werden. * **Region scope:** Wähle Global oder, bei auf Azure gehosteten Modellen, Data Zone. Die Auswahl von Data Zone erstellt ein US-Data-Zone-Standard-Deployment, das die Inferenz innerhalb der Vereinigten Staaten hält und dem Setzen von [`inference_geo: "us"`](https://platform.claude.com/docs/de/manage-claude/data-residency#inference-geo) in der Claude API entspricht. Wähle für Claude Sonnet 5.5 Global. * **Model version:** Erweitere **Model version settings** und wähle eine Version aus dem Dropdown-Menü **Model version**. Jede [Hosting-Option](https://platform.claude.com/docs/de/build-with-claude/claude-in-microsoft-foundry#hosting-options) wird als separate Modellversion aufgeführt und mit ihrer Hosting-Option gekennzeichnet (zum Beispiel Version 1 für Hosted on Anthropic, Version 2 für Hosted on Azure). 6. Wähle **Deploy** und warte, bis die Bereitstellung abgeschlossen ist. 7. Wähle nach der Bereitstellung **Build** in der Navigation oben rechts, dann **Models** im linken Bereich und öffne dein Deployment. Der Tab **Details** zeigt die **Target URI** (deine Endpunkt-URL) und den **Key** (deinen API-Key). Wenn der Schalter **New Foundry** deaktiviert ist, befindest du dich im klassischen Portal-Layout. Öffne dort **Model catalog** im linken Bereich, um ein Modell zu finden und bereitzustellen, und öffne **Models + endpoints** (unter **My assets**), um deine Deployments und deren Endpunktdetails anzuzeigen. Der von dir gewählte Deployment-Name wird zu dem Wert, den du im Parameter `model` deiner API-Anfragen übergibst. Du kannst mehrere Deployments desselben Modells mit unterschiedlichen Namen erstellen, um separate Konfigurationen oder Ratenlimits zu verwalten. ## Authentifizierung Claude in Microsoft Foundry unterstützt zwei Authentifizierungsmethoden: API-Keys und Entra-ID-Token. Beide Methoden verwenden auf Azure gehostete Endpunkte im Format `https://{resource}.services.ai.azure.com/anthropic/v1/*`. ### Authentifizierung mit API-Key Nachdem du deine Foundry-Claude-Ressource bereitgestellt hast, kannst du einen API-Key aus dem Foundry-Portal abrufen: 1. Wähle im Foundry-Portal **Build** in der Navigation oben rechts und dann **Models** im linken Bereich. 2. Öffne dein Claude-Deployment und wähle den Tab **Details**. 3. Kopiere den Wert **Key** (und notiere dir die **Target URI** für deinen Endpunkt). 4. Verwende in deinen Anfragen entweder den Header `api-key` oder `x-api-key`, oder übergib ihn an das SDK. Der Foundry-Client des SDK benötigt einen API-Key sowie entweder einen Ressourcennamen oder eine Basis-URL und liest diese automatisch aus den folgenden Umgebungsvariablen, sofern sie definiert sind: * `ANTHROPIC_FOUNDRY_API_KEY` - Dein API-Key * `ANTHROPIC_FOUNDRY_RESOURCE` - Dein Ressourcenname (zum Beispiel `example-resource`) * `ANTHROPIC_FOUNDRY_BASE_URL` - Alternative zum Ressourcennamen: die vollständige Basis-URL (zum Beispiel `https://example-resource.services.ai.azure.com/anthropic/`). Das C#-SDK liest diese Variable nicht: Es erstellt die Basis-URL immer aus dem Ressourcennamen. Die Parameter `resource` und `base_url` schließen sich gegenseitig aus. Gib entweder den Ressourcennamen an (aus dem das SDK die URL als `https://{resource}.services.ai.azure.com/anthropic/` erstellt) oder direkt die vollständige Basis-URL. **Beispiel mit API-Key:** ```bash cURL curl https://{resource}.services.ai.azure.com/anthropic/v1/messages \ -H "content-type: application/json" \ -H "api-key: YOUR_AZURE_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -d '{ "model": "claude-opus-5-5", "max_tokens": 1024, "messages": [ {"role": "user", "content": "Hello!"} ] }' ``` ```bash CLI # ant liest ANTHROPIC_API_KEY und sendet ihn als x-api-key, was Foundry akzeptiert export ANTHROPIC_API_KEY="YOUR_AZURE_API_KEY" ant messages create \ --base-url https://example-resource.services.ai.azure.com/anthropic \ --model claude-opus-5-5 \ --max-tokens 1024 \ --message '{role: user, content: "Hello!"}' \ --transform content ``` ```python Python import os from anthropic import AnthropicFoundry client = AnthropicFoundry( api_key=os.environ.get("ANTHROPIC_FOUNDRY_API_KEY"), resource="example-resource", # your resource name ) message = client.messages.create( model="claude-opus-5-5", max_tokens=1024, messages=[{"role": "user", "content": "Hello!"}], ) print(message.content) ``` ```typescript TypeScript import AnthropicFoundry from "@anthropic-ai/foundry-sdk"; const client = new AnthropicFoundry({ apiKey: process.env.ANTHROPIC_FOUNDRY_API_KEY, resource: "example-resource" // your resource name }); const message = await client.messages.create({ model: "claude-opus-5-5", max_tokens: 1024, messages: [{ role: "user", content: "Hello!" }] }); console.log(message.content); ``` ```csharp C# using Anthropic.Foundry; using Anthropic.Models.Messages; // Der C#-Client erstellt die Basis-URL immer aus dem Ressourcennamen. // Er liest ANTHROPIC_FOUNDRY_BASE_URL nicht aus. var client = new AnthropicFoundryClient( new AnthropicFoundryApiKeyCredentials( Environment.GetEnvironmentVariable("ANTHROPIC_FOUNDRY_API_KEY")!, "example-resource" ) ); var response = await client.Messages.Create(new MessageCreateParams { Model = "claude-opus-5-5", MaxTokens = 1024, Messages = [new() { Role = Role.User, Content = "Hello!" }], }); Console.WriteLine( string.Join("", response.Content .Select(block => block.Value) .OfType() .Select(textBlock => textBlock.Text))); ``` ```go Go package main import ( "context" "fmt" "os" "github.com/anthropics/anthropic-sdk-go" "github.com/anthropics/anthropic-sdk-go/foundry" ) func main() { client, err := foundry.NewClient(foundry.ClientConfig{ APIKey: os.Getenv("ANTHROPIC_FOUNDRY_API_KEY"), Resource: "example-resource", // your resource name }) if err != nil { panic(err) } message, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{ Model: "claude-opus-5-5", MaxTokens: 1024, Messages: []anthropic.MessageParam{ anthropic.NewUserMessage(anthropic.NewTextBlock("Hello!")), }, }) if err != nil { panic(err) } fmt.Println(message.Content) } ``` ```java Java import com.anthropic.client.AnthropicClient; import com.anthropic.client.okhttp.AnthropicOkHttpClient; import com.anthropic.foundry.backends.FoundryBackend; import com.anthropic.models.messages.MessageCreateParams; void main() { // Benötigt Umgebungsvariablen: ANTHROPIC_FOUNDRY_API_KEY, ANTHROPIC_FOUNDRY_RESOURCE AnthropicClient client = AnthropicOkHttpClient.builder() .backend(FoundryBackend.fromEnv()) .build(); MessageCreateParams params = MessageCreateParams.builder() .model("claude-opus-5-5") .maxTokens(1024) .addUserMessage("Hello!") .build(); client.messages().create(params).content().stream() .flatMap(block -> block.text().stream()) .forEach(textBlock -> IO.println(textBlock.text())); } ``` ```php PHP use Anthropic\Foundry; $client = Foundry\Client::withCredentials( apiKey: getenv('ANTHROPIC_FOUNDRY_API_KEY'), baseUrl: 'https://example-resource.services.ai.azure.com/anthropic', ); $message = $client->messages->create( maxTokens: 1024, messages: [ ['role' => 'user', 'content' => 'Hello!'] ], model: 'claude-opus-5-5', ); echo array_find($message->content, fn ($block) => $block->type === 'text')->text; ``` ```ruby Ruby # Das Ruby SDK unterstützt Foundry noch nicht nativ. Dieses Beispiel nutzt das # Standard-Ruby-SDK als Workaround. Übergib Anmeldedaten explizit: ohne # sie greift der Client auf die Umgebungsvariablen ANTHROPIC_API_KEY oder # ANTHROPIC_AUTH_TOKEN zurück und könnte Claude-API-Anmeldedaten # an deinen Foundry-Endpunkt senden. Features, die Foundry # nicht unterstützt, schlagen serverseitig statt clientseitig fehl. Für volle # Foundry-Unterstützung verwende die SDKs für C#, Go, Java, PHP, Python oder TypeScript. require "anthropic" client = Anthropic::Client.new( base_url: "https://example-resource.services.ai.azure.com/anthropic", api_key: ENV.fetch("ANTHROPIC_FOUNDRY_API_KEY") ) message = client.messages.create( model: "claude-opus-5-5", max_tokens: 1024, messages: [{role: "user", content: "Hello!"}] ) puts message.content.find { it.type == :text }.text ``` Bewahre deine API-Keys sicher auf. Committe sie niemals in die Versionskontrolle und teile sie nicht öffentlich. Jeder mit Zugriff auf deinen API-Key kann über deine Foundry-Ressource Anfragen an Claude stellen. ### Microsoft-Entra-Authentifizierung Mit der Entra-ID-Authentifizierung kannst du den Zugriff mit Azure RBAC verwalten, die Identitätsverwaltung deiner Organisation einbinden und die manuelle Handhabung von API-Keys vermeiden. So verwendest du Entra-ID-Tokens: 1. Aktiviere die [Microsoft-Entra-ID-Authentifizierung](https://learn.microsoft.com/en-us/azure/ai-foundry/model-inference/how-to/configure-entra-id) für deine Foundry-Ressource. 2. Rufe ein Zugriffstoken von Entra ID ab. 3. Verwende das Token im Header `Authorization: Bearer {TOKEN}`. **Beispiel mit Entra ID:** ```bash cURL # Microsoft Entra ID-Token abrufen ACCESS_TOKEN=$(az account get-access-token --resource https://ai.azure.com --query accessToken -o tsv) # Anfrage mit Token senden. Ersetze {resource} durch deinen Ressourcennamen curl https://{resource}.services.ai.azure.com/anthropic/v1/messages \ -H "content-type: application/json" \ -H "Authorization: Bearer $ACCESS_TOKEN" \ -H "anthropic-version: 2023-06-01" \ -d '{ "model": "claude-opus-5-5", "max_tokens": 1024, "messages": [ {"role": "user", "content": "Hello!"} ] }' ``` ```bash CLI # Microsoft Entra ID-Token abrufen ACCESS_TOKEN=$(az account get-access-token --resource https://ai.azure.com --query accessToken -o tsv) # Anfrage mit Token senden. Ersetze {resource} durch deinen Ressourcennamen # env -u entfernt ANTHROPIC_API_KEY, den die CLI sonst anstelle des Tokens senden würde env -u ANTHROPIC_API_KEY ANTHROPIC_AUTH_TOKEN="$ACCESS_TOKEN" ant messages create \ --base-url https://{resource}.services.ai.azure.com/anthropic \ --model claude-opus-5-5 \ --max-tokens 1024 \ --message '{role: user, content: "Hello!"}' ``` ```python Python from anthropic import AnthropicFoundry from azure.identity import DefaultAzureCredential, get_bearer_token_provider # Microsoft Entra ID-Token über das Token-Provider-Muster abrufen token_provider = get_bearer_token_provider( DefaultAzureCredential(), "https://ai.azure.com/.default" ) # Client mit Entra ID-Authentifizierung erstellen client = AnthropicFoundry( resource="example-resource", # your resource name azure_ad_token_provider=token_provider, # Use token provider for Entra ID auth ) # Anfrage senden message = client.messages.create( model="claude-opus-5-5", max_tokens=1024, messages=[{"role": "user", "content": "Hello!"}], ) print(message.content) ``` ```typescript TypeScript import AnthropicFoundry from "@anthropic-ai/foundry-sdk"; import { DefaultAzureCredential, getBearerTokenProvider } from "@azure/identity"; // Entra-ID-Token über das Token-Provider-Muster abrufen const credential = new DefaultAzureCredential(); const tokenProvider = getBearerTokenProvider(credential, "https://ai.azure.com/.default"); // Client mit Entra-ID-Authentifizierung erstellen const client = new AnthropicFoundry({ resource: "example-resource", // your resource name azureADTokenProvider: tokenProvider // Use token provider for Entra ID auth }); // Anfrage senden const message = await client.messages.create({ model: "claude-opus-5-5", max_tokens: 1024, messages: [{ role: "user", content: "Hello!" }] }); console.log(message.content); ``` ```csharp C# using Anthropic.Foundry; using Anthropic.Models.Messages; using Azure.Identity; var client = new AnthropicFoundryClient( new AnthropicFoundryIdentityTokenCredentials( new DefaultAzureCredential(), "example-resource" ) ); var response = await client.Messages.Create(new MessageCreateParams { Model = "claude-opus-5-5", MaxTokens = 1024, Messages = [new() { Role = Role.User, Content = "Hello!" }], }); Console.WriteLine( string.Join("", response.Content .Select(block => block.Value) .OfType() .Select(textBlock => textBlock.Text))); ``` ```go Go package main import ( "context" "fmt" "github.com/Azure/azure-sdk-for-go/sdk/azcore/policy" "github.com/Azure/azure-sdk-for-go/sdk/azidentity" "github.com/anthropics/anthropic-sdk-go" "github.com/anthropics/anthropic-sdk-go/foundry" ) func main() { credential, err := azidentity.NewDefaultAzureCredential(nil) if err != nil { panic(err) } tokenProvider := func(ctx context.Context) (string, error) { token, err := credential.GetToken(ctx, policy.TokenRequestOptions{ Scopes: []string{foundry.EntraIDScope}, }) return token.Token, err } client, err := foundry.NewClient(foundry.ClientConfig{ Resource: "example-resource", // your resource name AzureADTokenProvider: tokenProvider, }) if err != nil { panic(err) } message, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{ Model: "claude-opus-5-5", MaxTokens: 1024, Messages: []anthropic.MessageParam{ anthropic.NewUserMessage(anthropic.NewTextBlock("Hello!")), }, }) if err != nil { panic(err) } fmt.Println(message.Content) } ``` ```java Java import com.anthropic.client.AnthropicClient; import com.anthropic.client.okhttp.AnthropicOkHttpClient; import com.anthropic.foundry.backends.FoundryBackend; import com.anthropic.models.messages.MessageCreateParams; import com.azure.identity.AuthenticationUtil; import com.azure.identity.DefaultAzureCredentialBuilder; import java.util.function.Supplier; void main() { Supplier bearerTokenSupplier = AuthenticationUtil.getBearerTokenSupplier( new DefaultAzureCredentialBuilder().build(), "https://ai.azure.com/.default" ); AnthropicClient client = AnthropicOkHttpClient.builder() .backend(FoundryBackend.builder() .bearerTokenSupplier(bearerTokenSupplier) .resource("example-resource") .build()) .build(); MessageCreateParams params = MessageCreateParams.builder() .model("claude-opus-5-5") .maxTokens(1024) .addUserMessage("Hello!") .build(); client.messages().create(params).content().stream() .flatMap(block -> block.text().stream()) .forEach(textBlock -> IO.println(textBlock.text())); } ``` ```php PHP use Anthropic\Foundry; // Hole dir ein Entra ID-Zugriffstoken, zum Beispiel mit der Azure CLI: // az account get-access-token --resource https://ai.azure.com \ // --query accessToken -o tsv $token = getenv('AZURE_ACCESS_TOKEN'); $client = Foundry\Client::withCredentials( authToken: $token, baseUrl: 'https://example-resource.services.ai.azure.com/anthropic', ); $message = $client->messages->create( maxTokens: 1024, messages: [ ['role' => 'user', 'content' => 'Hello!'] ], model: 'claude-opus-5-5', ); echo array_find($message->content, fn ($block) => $block->type === 'text')->text; ``` ```ruby Ruby # Das Ruby SDK unterstützt Foundry noch nicht nativ. Dieses Beispiel verwendet das # Standard-Ruby-SDK als Workaround mit einem statischen Entra-ID-Token: Automatische # Token-Aktualisierung ist nicht integriert, daher muss deine Anwendung Tokens # selbst aktualisieren (sie laufen meist nach 1 Stunde ab). Übergib Anmeldedaten explizit: # ohne sie greift der Client auf die Umgebungsvariablen ANTHROPIC_API_KEY oder # ANTHROPIC_AUTH_TOKEN zurück. Für volle Foundry-Unterstützung verwende # die SDKs für C#, Go, Java, PHP, Python oder TypeScript. require "anthropic" # Hol dir ein Entra-ID-Zugriffstoken, zum Beispiel mit der Azure CLI: # az account get-access-token --resource https://ai.azure.com \ # --query accessToken -o tsv client = Anthropic::Client.new( base_url: "https://example-resource.services.ai.azure.com/anthropic", auth_token: ENV.fetch("AZURE_ACCESS_TOKEN") ) message = client.messages.create( model: "claude-opus-5-5", max_tokens: 1024, messages: [{role: "user", content: "Hello!"}] ) puts message.content.find { it.type == :text }.text ``` ## Korrelations-Request-IDs Foundry fügt zur Fehlersuche und Nachverfolgung Request-Kennungen in die HTTP-Antwort-Header ein. Wenn du den Support kontaktierst, gib sowohl den Wert `request-id` als auch `apim-request-id` (Azure API Management) an, damit die Teams deine Anfrage in den Systemen von Anthropic und Azure schnell finden und untersuchen können. ## Funktionsunterstützung Claude in Microsoft Foundry unterstützt die meisten Claude-Funktionen. Alle derzeit unterstützten Funktionen findest du in der [Funktionsübersicht](https://platform.claude.com/docs/de/build-with-claude/overview). ### Kontextfenster Claude Fable 5.1, Claude Fable 5, Claude Opus 5.5, Claude Opus 5, Claude Opus 4.8, Claude Opus 4.7, Claude Opus 4.6, Claude Sonnet 5.5, Claude Sonnet 5, Claude Sonnet 4.6 und Claude Haiku 5.5 haben in Microsoft Foundry ein [Kontextfenster mit 1M Token](https://platform.claude.com/docs/de/build-with-claude/context-windows). Andere Claude-Modelle, einschließlich Claude Sonnet 4.5 (abgekündigt), haben ein Kontextfenster mit 200k Token. ### Claude-Funktionen, die für Claude in Microsoft Foundry nicht unterstützt werden * Admin API * Advisor-Tool * Claude Managed Agents * Compliance API * Models API * Message Batches API * Serverseitiges Fallback (der [Parameter `fallbacks`](https://platform.claude.com/docs/de/build-with-claude/refusals-and-fallback#server-side-fallback); verwende stattdessen das [clientseitige Fallback-Muster](https://platform.claude.com/docs/de/build-with-claude/refusals-and-fallback#client-side-fallback)) * Toolsets für [Computer Use](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool) und [Browser Use](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool) (`computer_toolset_20260801` und `browser_toolset_20260801` sind derzeit auf Microsoft Foundry nicht verfügbar; die Beta-Versionen des Computer-Use-Tools bleiben für die unter [Frühere Tool-Versionen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#earlier-tool-versions) aufgeführten Modelle verfügbar) ### Zusätzliche Funktionen, die beim Hosting auf Azure nicht unterstützt werden Die folgenden Funktionen sind für auf Anthropic gehostete Deployments verfügbar, werden aber für auf Azure gehostete Deployments nicht unterstützt: * [Code-Ausführung](https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool) * Versionen der Tools [Web Search](https://platform.claude.com/docs/de/agents-and-tools/tool-use/web-search-tool) und [Web Fetch](https://platform.claude.com/docs/de/agents-and-tools/tool-use/web-fetch-tool), die neuer sind als `web_search_20250305` und `web_fetch_20250910`. Auf Azure gehostete Deployments unterstützen nur diese Basisversionen, sodass dynamisches Filtern, Response-Einbindung und Cache-Umgehung nicht verfügbar sind. * [Agent Skills](https://platform.claude.com/docs/de/agents-and-tools/agent-skills/overview) * [Programmatisches Tool-Calling](https://platform.claude.com/docs/de/agents-and-tools/tool-use/programmatic-tool-calling) * [Files API](https://platform.claude.com/docs/de/build-with-claude/files) Anfragen, die diese Funktionen gegen ein auf Azure gehostetes Deployment verwenden, geben absichtlich einen Fehler `400 Bad Request` zurück. Claude Code erkennt auf Azure gehostete Deployments und passt seinen Funktionsumfang automatisch an. ## API-Antworten API-Antworten von Claude in Microsoft Foundry folgen dem standardmäßigen [Antwortformat der Claude API](https://platform.claude.com/docs/de/api/messages/create). Dazu gehört das Objekt `usage` in den Antwort-Bodys, das detaillierte Informationen zum Token-Verbrauch deiner Anfragen liefert. Das Objekt `usage` ist über alle Plattformen hinweg konsistent (Claude API, Amazon Bedrock, Claude Platform on AWS, Foundry und Google Cloud). Details zu Foundry-spezifischen Antwort-Headern findest du unter [Korrelations-Request-IDs](https://platform.claude.com/docs/de/build-with-claude/claude-in-microsoft-foundry#correlation-request-ids). ## API-Modell-IDs und Deployments Die Lebenszyklusbegriffe („Deprecated“ (abgekündigt), „Retired“ (eingestellt)) sind unter [Modell-Abkündigungen](https://platform.claude.com/docs/de/about-claude/model-deprecations) definiert. Microsoft Foundry folgt dem Lebenszyklus-Zeitplan der Claude API. Die folgenden Claude-Modelle sind über Foundry verfügbar: | Model | Default deployment name | Hosted on Azure | Hosted on Anthropic | | :---------------------------------------------------------------------------------------------------- | :---------------------- | :-------------: | :-----------------: | | Claude Fable 5.1 | `claude-fable-5-1` | | ✓ | | Claude Mythos 5.1 ([limited availability](https://support.claude.com/en/articles/14604842)) | `claude-mythos-5-1` | | ✓ | | Claude Fable 5 | `claude-fable-5` | | ✓ | | Claude Mythos 5 ([limited availability](https://support.claude.com/en/articles/14604842)) | `claude-mythos-5` | | ✓ | | Claude Opus 5.5 | `claude-opus-5-5` | ✓ | ✓ | | Claude Opus 5 | `claude-opus-5` | ✓ | ✓ | | Claude Opus 4.8 | `claude-opus-4-8` | ✓ | ✓ | | Claude Opus 4.7 | `claude-opus-4-7` | | ✓ | | Claude Opus 4.6 | `claude-opus-4-6` | | ✓ | | Claude Opus 4.5 | `claude-opus-4-5` | | ✓ | | Claude Sonnet 5.5 | `claude-sonnet-5-5` | ✓ | ✓ | | Claude Sonnet 5 | `claude-sonnet-5` | ✓ | ✓ | | Claude Sonnet 4.6 | `claude-sonnet-4-6` | | ✓ | | Claude Sonnet 4.5 ([deprecated](https://platform.claude.com/docs/de/about-claude/model-deprecations)) | `claude-sonnet-4-5` | | ✓ | | Claude Haiku 5.5 | `claude-haiku-5-5` | ✓ | ✓ | | Claude Haiku 4.5 | `claude-haiku-4-5` | ✓ | ✓ | Standardmäßig entsprechen die Deployment-Namen den in der obigen Tabelle gezeigten Modell-IDs. Du kannst jedoch im Foundry-Portal benutzerdefinierte Deployments mit anderen Namen erstellen, um unterschiedliche Konfigurationen, Versionen oder Ratenlimits zu verwalten. Verwende in deinen API-Anfragen den Deployment-Namen (nicht unbedingt die Modell-ID). [Claude Mythos Preview](https://anthropic.com/glasswing) ist eine Research Preview, die eingeladenen Kunden auf Microsoft Foundry zur Verfügung steht. Du wechselst auf ein neueres Claude-Modell? Führe in Claude Code `/claude-api migrate` aus, um Modell-ID-Austausche und inkompatible Parameteränderungen in deiner gesamten Codebasis anzuwenden. Der Skill erkennt, auf welche Cloud-Plattform dein Code abzielt, und passt Modell-ID-Formate und Funktionsänderungen für diese Plattform an. Siehe [Migration auf ein neueres Claude-Modell](https://platform.claude.com/docs/de/agents-and-tools/agent-skills/claude-api-skill#migrating-to-a-newer-claude-model). ## Abrechnung Claude in Microsoft Foundry wird über den [Azure Marketplace](https://azuremarketplace.microsoft.com/) abgerechnet. Die Nutzung wird in Claude Consumption Units (CCUs) angegeben, stündlich gemessen und monatlich nachträglich auf deiner Azure-Rechnung ausgewiesen. CCUs sind keine vorausbezahlten Guthaben. Es gibt kein CCU-Guthaben und keine CCU-Verpflichtung. Den CCU-Preis, die Umrechnungsmechanik und die Token-Raten pro Modell findest du unter [Preise für Claude in Microsoft Foundry](https://platform.claude.com/docs/de/about-claude/pricing#claude-in-microsoft-foundry-pricing). ## Zwischen Hosting-Optionen migrieren So verschiebst du ein bestehendes Deployment von einer Hosting-Option zur anderen: 1. Erstelle ein neues Deployment der anderen Hosting-Version des Modells (Hosted on Azure oder Hosted on Anthropic). Dies kann in derselben Foundry-Ressource oder in einer neuen erfolgen. 2. Aktualisiere deine Anwendung, sodass sie den neuen Deployment-Namen im Parameter `model` übergibt. 3. Lösche das alte Deployment, sobald der Traffic umgezogen ist. Wenn sich das neue Deployment in derselben Foundry-Ressource befindet, bleiben deine Endpunkt-URL und Authentifizierung unverändert. Wenn du eine neue Ressource erstellt hast, aktualisiere den Endpunkt und die Anmeldedaten deiner Anwendung, sodass sie darauf verweisen. ## Monitoring und Logging Azure bietet Monitoring und Logging für deine Claude-Nutzung über standardmäßige Azure-Muster: * **Azure Monitor:** Verfolge API-Nutzung, Latenz und Fehlerraten * **Azure Log Analytics:** Frage Request-/Response-Logs ab und analysiere sie * **Cost Management:** Überwache und prognostiziere die mit der Claude-Nutzung verbundenen Kosten Anthropic empfiehlt, deine Aktivität mindestens auf rollierender 30-Tage-Basis zu protokollieren, um Nutzungsmuster zu verstehen und mögliche Probleme zu untersuchen. Die Logging-Dienste von Azure werden innerhalb deines Azure-Abonnements konfiguriert. Das Aktivieren des Loggings gewährt weder Microsoft noch Anthropic Zugriff auf deine Inhalte über das hinaus, was für Abrechnung und Dienstbetrieb erforderlich ist. ## Fehlerbehebung ### Authentifizierungsfehler **Fehler:** `401 Unauthorized` oder `Invalid API key` * **Lösung:** Überprüfe, ob dein API-Key korrekt ist. Du findest ihn im Foundry-Portal auf dem Tab **Details** deines Deployments (unter **Build** > **Models**). * **Lösung:** Wenn du Microsoft Entra ID verwendest, stelle sicher, dass dein Zugriffstoken gültig und nicht abgelaufen ist. Token laufen in der Regel nach 1 Stunde ab. **Fehler:** `403 Forbidden` * **Lösung:** Deinem Azure-Konto fehlen möglicherweise die erforderlichen Berechtigungen. Stelle sicher, dass dir die passende Azure-RBAC-Rolle zugewiesen ist (zum Beispiel **Foundry User** (früher Azure AI User) oder **Cognitive Services User**). ### Ratenlimitierung **Fehler:** `429 Too Many Requests` * **Lösung:** Du hast dein „rate limit“ (Ratenlimit) überschritten. Implementiere exponentielles Backoff und Retry-Logik in deiner Anwendung. * **Lösung:** Erwäge, über das Azure-Portal oder den Azure-Support eine Erhöhung des Ratenlimits zu beantragen. #### Ratenlimit-Header Foundry fügt die standardmäßigen Ratenlimit-Header von Anthropic (`anthropic-ratelimit-tokens-limit`, `anthropic-ratelimit-tokens-remaining`, `anthropic-ratelimit-tokens-reset`, `anthropic-ratelimit-input-tokens-limit`, `anthropic-ratelimit-input-tokens-remaining`, `anthropic-ratelimit-input-tokens-reset`, `anthropic-ratelimit-output-tokens-limit`, `anthropic-ratelimit-output-tokens-remaining` und `anthropic-ratelimit-output-tokens-reset`) nicht in Antworten ein. Verwalte die Ratenlimitierung stattdessen über die Monitoring-Tools von Azure. ### Modell- und Deployment-Fehler **Fehler:** `Model not found` oder `Deployment not found` * **Lösung:** Überprüfe, ob du den richtigen Deployment-Namen verwendest. Wenn du kein benutzerdefiniertes Deployment erstellt hast, verwende die Standard-Modell-ID (zum Beispiel claude-opus-5-5). * **Lösung:** Stelle sicher, dass das Modell/Deployment in deiner Azure-Region verfügbar ist. **Fehler:** `Invalid model parameter` * **Lösung:** Der Parameter model sollte deinen Deployment-Namen enthalten, der im Foundry-Portal angepasst werden kann. Überprüfe, ob das Deployment existiert und korrekt konfiguriert ist. ## Nächste Schritte Entdecke die erweiterten Funktionen und Fähigkeiten von Claude. Erfahre mehr über die Preisstruktur von Anthropic für Modelle und Funktionen. Wenn sicherere und leistungsfähigere Modelle erscheinen, stellt Anthropic ältere regelmäßig ein. Sieh dir alle API-Abkündigungen zusammen mit empfohlenen Nachfolgern an. ## Zusätzliche Ressourcen Durchsuche Anthropic-Modelle im Foundry-Katalog. Sieh dir die Preisdetails von Microsoft für Azure AI Foundry an. Sieh dir die Preisdetails von Anthropic pro Modell an. Verwalte deine Azure-Ressourcen.