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:

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"}]
)