Claude Code × Amazon Bedrock Komplettleitfaden | Claude produktiv auf AWS betreiben

„Ich möchte die Claude-API in einer Produktionsanwendung nutzen, aber die Verwaltung von API-Schlüsseln ist mir zu riskant” oder „Unsere interne Sicherheitsrichtlinie erlaubt es nicht, Daten außerhalb von AWS zu verarbeiten” — für diese Probleme ist Amazon Bedrock die beste Lösung.

Als ich für ein Projekt KI in einen API-Server auf ECS integriert habe, nutzte ich zunächst die Anthropic-API direkt. Ein Sicherheits-Review bemängelte jedoch das „Management von API-Schlüsseln für externe Dienste”. Nach dem Wechsel zu Bedrock wird die Authentifizierung vollständig über IAM-Rollen abgewickelt – kein API-Key-Management mehr. Dieser Artikel erklärt alles von der Bedrock-Implementierung mit Claude Code bis zum Produktionsbetrieb.

---

Was ist Amazon Bedrock?

Amazon Bedrock ist ein verwalteter KI-Modelldienst von AWS. Über eine einheitliche API können mehrere Modelle aufgerufen werden – darunter Claude (Anthropic), Llama (Meta) und Titan (Amazon).

Warum Bedrock nutzen?

Aspekt	Anthropic API	Amazon Bedrock
Authentifizierung	API-Schlüssel	AWS IAM-Rolle
Abrechnung	Direkt bei Anthropic	In AWS-Abrechnung integriert
VPC-Unterstützung	Nicht vorhanden	Vollständig privat mit PrivateLink
Datenhaltung	Anthropic-Richtlinien	AWS-Richtlinien
Compliance	SOC2 usw.	SOC2 / ISO27001 / HIPAA usw.

Die Anthropic-API ist für Privatprojekte praktisch, aber für Enterprise-, Finanz- und Medizinbereiche wird Bedrock zunehmend zur einzigen Option.

---

Schritt 1: Ersteinrichtung

Modellzugriff beantragen

Zuerst müssen Sie im AWS-Konsole den Zugriff auf Claude-Modelle beantragen.

# Liste der verfügbaren Modelle abrufen
aws bedrock list-foundation-models \
  --by-provider anthropic \
  --region us-east-1 \
  --query 'modelSummaries[].{id:modelId, name:modelName}'

# Beispielausgabe
[
  {"id": "anthropic.claude-opus-4-5",     "name": "Claude Opus 4.5"},
  {"id": "anthropic.claude-sonnet-4-6",   "name": "Claude Sonnet 4.6"},
  {"id": "anthropic.claude-haiku-4-5-20251001", "name": "Claude Haiku 4.5"}
]

Wichtig: Die primären verfügbaren Regionen sind us-east-1 (Virginia) und us-west-2 (Oregon). Die Tokyo-Region kann über Cross-region inference genutzt werden.

SDK-Installation

npm install @anthropic-ai/sdk @aws-sdk/client-bedrock-runtime

---

Schritt 2: Grundlegende Implementierung

Anthropic SDK mit eingebautem Bedrock-Support verwenden (Empfohlen)

Das offizielle Anthropic-SDK bietet eingebauten Bedrock-Support. Da die Syntax nahezu identisch mit der regulären Anthropic-API ist, sind die Migrationskosten aus bestehendem Code minimal.

// src/lib/bedrock-client.ts
import Anthropic from "@anthropic-ai/sdk";

// Keine Anmeldeinformationen nötig, wenn IAM-Rolle verwendet wird (z.B. Lambda/ECS)
const bedrock = new Anthropic.AnthropicBedrock({
  awsRegion: process.env.AWS_REGION ?? "us-east-1",
  // Während der lokalen Entwicklung wird automatisch das AWS CLI-Profil verwendet
});

export async function generateText(
  prompt: string,
  options: { model?: string; maxTokens?: number } = {}
): Promise<string> {
  const { model = "anthropic.claude-sonnet-4-6", maxTokens = 1024 } = options;

  const response = await bedrock.messages.create({
    model,
    max_tokens: maxTokens,
    messages: [{ role: "user", content: prompt }],
  });

  return response.content[0].type === "text" ? response.content[0].text : "";
}

Bedrock-Modell-IDs unterscheiden sich von der Anthropic-API:

Anthropic API: claude-sonnet-4-6
Bedrock:       anthropic.claude-sonnet-4-6  (Präfix hinzugefügt)

Streaming-Unterstützung

Streaming ist für lange Antworten unerlässlich.

// src/lib/bedrock-stream.ts
export async function* streamText(
  prompt: string,
  model = "anthropic.claude-sonnet-4-6"
): AsyncGenerator<string> {
  const stream = await bedrock.messages.stream({
    model,
    max_tokens: 4096,
    messages: [{ role: "user", content: prompt }],
  });

  for await (const chunk of stream) {
    if (
      chunk.type === "content_block_delta" &&
      chunk.delta.type === "text_delta"
    ) {
      yield chunk.delta.text;
    }
  }
}

// Verwendungsbeispiel (Next.js App Router)
export async function POST(req: Request) {
  const { prompt } = await req.json();
  const encoder = new TextEncoder();

  const stream = new ReadableStream({
    async start(controller) {
      for await (const text of streamText(prompt)) {
        controller.enqueue(encoder.encode(text));
      }
      controller.close();
    },
  });

  return new Response(stream, {
    headers: { "Content-Type": "text/event-stream" },
  });
}

---

Schritt 3: Lambda + Bedrock-Muster

Die am häufigsten verwendete Architektur für serverlose KI-Funktionen.

claude -p "
Implementiere folgende Lambda-Funktion in src/lambda/ai-handler.ts:
- Nimm prompt und maxTokens aus dem Event entgegen
- Rufe Bedrock (claude-sonnet-4-6) auf und gib das Ergebnis zurück
- Behandle Fehler: ThrottlingException (Retry) und ValidationException (400)
- Protokolliere die Ausführungszeit
- Initialisiere den Client außerhalb des Handlers (Cold-Start-Optimierung)
"

// src/lambda/ai-handler.ts
import { Handler, APIGatewayProxyEvent, APIGatewayProxyResult } from "aws-lambda";
import Anthropic from "@anthropic-ai/sdk";

// Initialisierung im Modulbereich (wird bei Container-Wiederverwendung gecacht)
const bedrock = new Anthropic.AnthropicBedrock({
  awsRegion: process.env.AWS_REGION,
});

export const handler: Handler<APIGatewayProxyEvent, APIGatewayProxyResult> = async (event) => {
  const startTime = Date.now();

  try {
    const { prompt, maxTokens = 512 } = JSON.parse(event.body ?? "{}");

    if (!prompt) {
      return { statusCode: 400, body: JSON.stringify({ error: "prompt is required" }) };
    }

    const response = await bedrock.messages.create({
      model: "anthropic.claude-sonnet-4-6",
      max_tokens: maxTokens,
      messages: [{ role: "user", content: prompt }],
    });

    const duration = Date.now() - startTime;
    console.log(JSON.stringify({
      level: "INFO",
      duration_ms: duration,
      input_tokens: response.usage.input_tokens,
      output_tokens: response.usage.output_tokens,
    }));

    return {
      statusCode: 200,
      body: JSON.stringify({
        text: response.content[0].type === "text" ? response.content[0].text : "",
        usage: response.usage,
      }),
    };
  } catch (error: any) {
    if (error.name === "ThrottlingException") {
      console.warn("Rate limited by Bedrock, client should retry");
      return { statusCode: 429, body: JSON.stringify({ error: "Rate limited, please retry" }) };
    }
    console.error("Bedrock error:", error);
    return { statusCode: 500, body: JSON.stringify({ error: "AI generation failed" }) };
  }
};

Lambda IAM-Richtlinie

// IAM-Konfiguration mit CDK
import * as iam from "aws-cdk-lib/aws-iam";

lambdaFunction.addToRolePolicy(new iam.PolicyStatement({
  effect: iam.Effect.ALLOW,
  actions: [
    "bedrock:InvokeModel",
    "bedrock:InvokeModelWithResponseStream",
  ],
  resources: [
    `arn:aws:bedrock:us-east-1::foundation-model/anthropic.claude-sonnet-4-6`,
    `arn:aws:bedrock:us-east-1::foundation-model/anthropic.claude-haiku-4-5-20251001`,
  ],
}));

---

Schritt 4: RAG (Retrieval-Augmented Generation) Implementierung

Ein Muster, bei dem Claude interne Dokumente oder Produktinformationen liest und Fragen beantwortet.

claude -p "
Implementiere ein RAG-System mit Bedrock Knowledge Base.

Architektur:
- Dokumente in S3 speichern
- Vektorindizierung mit Bedrock Knowledge Base
- Dokumente basierend auf Nutzerfragen abrufen
- Antworten mit Claude Sonnet generieren

Implementierung mit TypeScript + AWS SDK v3.
Knowledge Base-ID aus der Umgebungsvariable KNOWLEDGE_BASE_ID lesen.
"

// src/lib/rag.ts
import {
  BedrockAgentRuntimeClient,
  RetrieveAndGenerateCommand,
} from "@aws-sdk/client-bedrock-agent-runtime";

const agentClient = new BedrockAgentRuntimeClient({ region: "us-east-1" });

export async function ragQuery(question: string): Promise<{
  answer: string;
  citations: string[];
}> {
  const response = await agentClient.send(
    new RetrieveAndGenerateCommand({
      input: { text: question },
      retrieveAndGenerateConfiguration: {
        type: "KNOWLEDGE_BASE",
        knowledgeBaseConfiguration: {
          knowledgeBaseId: process.env.KNOWLEDGE_BASE_ID!,
          modelArn: `arn:aws:bedrock:us-east-1::foundation-model/anthropic.claude-sonnet-4-6`,
          retrievalConfiguration: {
            vectorSearchConfiguration: { numberOfResults: 5 },
          },
        },
      },
    })
  );

  const answer = response.output?.text ?? "";
  const citations = (response.citations ?? [])
    .flatMap((c) => c.retrievedReferences ?? [])
    .map((r) => r.location?.s3Location?.uri ?? "")
    .filter(Boolean);

  return { answer, citations };
}

---

Schritt 5: Kostenoptimierung

// Hilfsprogramm zur Modellauswahl
type TaskType = "classify" | "extract" | "summarize" | "generate" | "complex";

const MODEL_MAP: Record<TaskType, string> = {
  classify: "anthropic.claude-haiku-4-5-20251001",  // $0.80/1M Eingabe-Token
  extract:  "anthropic.claude-haiku-4-5-20251001",
  summarize: "anthropic.claude-sonnet-4-6",          // $3.00/1M Eingabe-Token
  generate: "anthropic.claude-sonnet-4-6",
  complex:  "anthropic.claude-opus-4-5",             // $15.00/1M Eingabe-Token
};

export function selectModel(task: TaskType): string {
  return MODEL_MAP[task];
}

Eingabekosten mit Prompt-Caching senken

// Prompt-Caching ist auch in Bedrock verfügbar
const response = await bedrock.messages.create({
  model: "anthropic.claude-sonnet-4-6",
  max_tokens: 1024,
  system: [
    {
      type: "text",
      text: longSystemPrompt,
      cache_control: { type: "ephemeral" },  // 5 Minuten Cache
    },
  ],
  messages: [{ role: "user", content: userQuery }],
});

---

5 häufige Fallstricke

1. Region wird nicht unterstützt

Claude on Bedrock ist nicht in allen Regionen verfügbar. Stand 2026 sind us-east-1 und us-west-2 die primären Regionen. Für die Nutzung aus Tokyo aktivieren Sie Cross-region inference.

// Cross-region inference Modell-ARN verwenden
const crossRegionModelArn = 
  "arn:aws:bedrock:us-east-1::foundation-model/anthropic.claude-sonnet-4-6";

2. Modellzugriff vergessen zu beantragen

In Bedrock müssen Sie für jedes Modell einen „Model access”-Antrag stellen. Das Aufrufen eines Modells ohne Antrag führt zu einer AccessDeniedException. Stellen Sie den Antrag immer, bevor Sie mit Claude Code beginnen.

3. Lambda-Timeout zu kurz

Claude-Antworten können 10–30 Sekunden dauern. Der Lambda-Standard von 3 Sekunden wird definitiv zu einem Timeout führen. Setzen Sie ihn auf mindestens 30 Sekunden, bei längeren Generierungen auf 60–300 Sekunden.

4. Bedrock-Modell-IDs mit Anthropic-API-IDs verwechseln

❌ Anthropic-API-ID direkt verwenden: "claude-sonnet-4-6"
✅ Bedrock-ID: "anthropic.claude-sonnet-4-6"

5. Cross-region inference-Latenz nicht berücksichtigen

Der Aufruf von Modellen in us-east-1 aus Tokyo fügt eine Netzwerk-Roundtrip-Latenz von ca. 100–200ms hinzu. Nutzen Sie Streaming, um die wahrgenommene Latenz bei zeitkritischen Anwendungen zu reduzieren.

---

Zusammenfassung

Aufgabe	Claude Codes Beitrag
Grundimplementierung	Generiert AnthropicBedrock-Client und Funktionen
Lambda-Integration	Generiert Handler und IAM-Richtlinie zusammen
RAG-Implementierung	Generiert automatisch Knowledge-Base-Integrationscode
Kostenoptimierung	Entwirft Modellauswahllogik nach Aufgabentyp
Fehlerbehebung	Identifiziert Ursache und schlägt Lösung aus Fehlerprotokollen vor

Entwickeln mit Claude Code, Produktionsbetrieb auf Bedrock — diese Kombination erfüllt alle Anforderungen an Sicherheit, Kosten und Skalierbarkeit. Starten Sie mit dem kostenlosen Bedrock-Test, und für den Produktionsbetrieb genügt die Konfiguration der IAM-Rolle.

Verwandte Artikel

• Claude Code × AWS Lambda Komplettleitfaden
• Claude Code × AWS IAM Komplettleitfaden
• Vollständiger Leitfaden zur 90%-igen Reduzierung der Claude-Code-API-Kosten

Referenzen

• Amazon Bedrock Offizielle Dokumentation
• Anthropic SDK Bedrock-Unterstützung
• Bedrock Modell-ID-Liste