Claude on Amazon Bedrock: AWS Integration Guide

Why Claude on Bedrock?

If your infrastructure is already on AWS, Bedrock is the most natural way to integrate Claude. Here are the advantages:

Claude on Bedrock vs. Anthropic direct vs. the other clouds: the honest tradeoffs

The Bedrock-vs-direct conversation on r/aws, r/devops, r/ClaudeAI, and r/LocalLLaMA has stabilised around predictable tradeoffs. Here's what teams actually weigh.

When Bedrock is the right choice:

• →You're already on AWS with committed spend. AWS Savings Plans and existing enterprise discount programs can apply, and Bedrock invoicing folds into your existing AWS bill. Finance likes one vendor.
• →You need HIPAA, FedRAMP, SOC 2, or ISO 27001. The AWS compliance programs cover Bedrock. The AWS HIPAA eligibility page lists Bedrock explicitly.
• →You need VPC isolation. Bedrock with PrivateLink keeps traffic off the public internet. Anthropic's direct API is public by default.
• →You want one audit log. AWS CloudTrail captures all Bedrock calls alongside the rest of your AWS activity. Useful for regulated industries.

When direct Anthropic API is the right choice:

• →Access to the newest models first. Anthropic typically ships new models to their direct API before Bedrock. If you need frontier capabilities on day one, direct is faster.
• →Features like prompt caching and message batching arrive on direct first. Bedrock catches up but lags.
• →Simpler billing for individuals and small teams. A credit card and API key beats AWS IAM setup for most solo builders.
• →Lower minimum friction. For prototyping and early development, direct is faster.

Multi-cloud context:

• →Google Cloud Vertex AI also hosts Claude with similar enterprise posture. Pick the cloud you're already on.
• →Microsoft Azure AI Foundry hosts Claude alongside OpenAI models. Useful if you want both in one compliance envelope.
• →OpenRouter and LiteLLM let you abstract the cloud choice, so you can swap providers without code changes. Worth considering for teams that don't want long-term lock-in.

Operational gotchas the docs don't emphasise:

• →Region parity lags. Not all Claude models are in all AWS regions. Check the Bedrock model availability page before architecting.
• →Quotas are per-region, per-account. Heavy usage requires quota increase requests and lead time. Plan ahead.
• →Cross-region inference smooths capacity but changes latency and compliance footprint. Read Anthropic's Bedrock cross-region docs before enabling.
• →Prompt formats can diverge. Minor differences between Bedrock's wrapping and direct API wrapping. SDK abstractions handle this, but hand-rolled code needs care.
• →Bedrock Guardrails are AWS-native content filtering; they're good but they don't replace Anthropic's own safety work. Use both for regulated industries.

The honest framing: Bedrock vs. direct isn't really about quality; it's about compliance, procurement, and existing cloud commitments. Teams on AWS with real compliance needs go Bedrock; individuals and teams on prototypes go direct; multi-cloud shops use abstraction layers. None is universally correct. Match the choice to your actual constraints, not to what the marketing pages emphasise.

Setup: Step by Step

1. Enable Model Access

In the AWS console:

1. →Navigate to Amazon Bedrock > Model access
2. →Click Manage model access
3. →Select the Anthropic models (Claude Opus, Sonnet, Haiku)
4. →Submit the request (approval is usually instantaneous)

2. Configure IAM

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "bedrock:InvokeModel",
        "bedrock:InvokeModelWithResponseStream"
      ],
      "Resource": [
        "arn:aws:bedrock:us-east-1::foundation-model/anthropic.claude-sonnet-4-20250514-v1:0",
        "arn:aws:bedrock:us-east-1::foundation-model/anthropic.claude-opus-4-20250918-v1:0"
      ]
    }
  ]
}

IAM best practices:

• →Use the principle of least privilege (one model per role)
• →Create specific roles per application
• →Add conditions (source IP, access hours)
• →Enable CloudTrail for auditing

3. Install the SDK

pip install boto3 anthropic[bedrock]

Code Examples

Basic Call with boto3

import boto3
import json

# Bedrock Runtime client
client = boto3.client(
    service_name="bedrock-runtime",
    region_name="us-east-1"
)

# Claude request
body = json.dumps({
    "anthropic_version": "bedrock-2023-05-31",
    "max_tokens": 1024,
    "messages": [
        {
            "role": "user",
            "content": "Explain the benefits of infrastructure as code."
        }
    ]
})

response = client.invoke_model(
    modelId="anthropic.claude-sonnet-4-20250514-v1:0",
    contentType="application/json",
    accept="application/json",
    body=body
)

result = json.loads(response["body"].read())
print(result["content"][0]["text"])

With the Anthropic SDK (Recommended)

import anthropic

# Automatically uses AWS credentials
client = anthropic.AnthropicBedrock(
    aws_region="us-east-1"
)

message = client.messages.create(
    model="anthropic.claude-sonnet-4-20250514-v1:0",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "What are the AWS services for machine learning?"}
    ]
)

print(message.content[0].text)

Streaming

import anthropic

client = anthropic.AnthropicBedrock(aws_region="us-east-1")

with client.messages.stream(
    model="anthropic.claude-sonnet-4-20250514-v1:0",
    max_tokens=2048,
    messages=[{"role": "user", "content": "Write a microservices migration guide."}]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

Bedrock vs Direct API Pricing

Bedrock cost reduction options:

• →Provisioned Throughput: Guaranteed throughput, reduced pricing for high volumes
• →Batch Inference: Batch processing with 50% reduction
• →Cross-Region Inference: Automatic region optimization

Bedrock Guardrails

Bedrock guardrails add a configurable security layer around Claude.

# Call with guardrails
response = client.invoke_model(
    modelId="anthropic.claude-sonnet-4-20250514-v1:0",
    contentType="application/json",
    accept="application/json",
    body=body,
    guardrailIdentifier="my-guardrail-id",
    guardrailVersion="1"
)

Enterprise Architecture

Typical Architecture

Lambda + Claude

import json
import boto3

bedrock = boto3.client("bedrock-runtime")

def lambda_handler(event, context):
    """Lambda function calling Claude via Bedrock."""
    user_question = event.get("question", "")
    
    body = json.dumps({
        "anthropic_version": "bedrock-2023-05-31",
        "max_tokens": 1024,
        "messages": [{"role": "user", "content": user_question}]
    })
    
    response = bedrock.invoke_model(
        modelId="anthropic.claude-sonnet-4-20250514-v1:0",
        body=body
    )
    
    result = json.loads(response["body"].read())
    
    return {
        "statusCode": 200,
        "body": json.dumps({
            "answer": result["content"][0]["text"],
            "tokens_used": result["usage"]
        })
    }

Monitoring with CloudWatch

import boto3

cloudwatch = boto3.client("cloudwatch")

# Create an alarm on invocation count
cloudwatch.put_metric_alarm(
    AlarmName="bedrock-claude-high-usage",
    MetricName="Invocations",
    Namespace="AWS/Bedrock",
    Statistic="Sum",
    Period=3600,
    Threshold=10000,
    ComparisonOperator="GreaterThanThreshold",
    EvaluationPeriods=1,
    AlarmActions=["arn:aws:sns:us-east-1:123456:alerts"],
    Dimensions=[{
        "Name": "ModelId",
        "Value": "anthropic.claude-sonnet-4-20250514-v1:0"
    }]
)

Available Metrics

Migrating from the Direct API

If you're already using the direct Anthropic API, migration to Bedrock is straightforward:

# Before (Direct API)
# client = anthropic.Anthropic(api_key="sk-ant-...")
# model = "claude-sonnet-4-20250514"

# After (Bedrock)
client = anthropic.AnthropicBedrock(aws_region="us-east-1")
model = "anthropic.claude-sonnet-4-20250514-v1:0"

# The rest of the code is identical
message = client.messages.create(
    model=model,
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello"}]
)