AWS for AI/Agent Developers — Day 5: Multi-Region Agent Routing with Route53

Your agent runs in one region. Users everywhere. Latency kills the experience — a 2-second LLM call from us-east-1 feels fine locally, but from Southeast Asia it’s 4 seconds. Add DNS resolution, TLS negotiation, network hops, and you’ve lost the user.

Today we build multi-region routing for agents:

Route53 latency-based routing — DNS resolves to the region with lowest latency for each user
Active-passive failover — if us-east-1 goes down, traffic shifts to eu-west-1
CloudFront — cache agent responses at 450+ edge locations, not just 3 AWS regions
Global Accelerator — TCP/UDP traffic for agents that can’t use DNS-based routing

1
                         ┌─────────────────────────┐
2
                         │      Route53            │
3
                         │  Latency-based DNS      │
4
                         │  Health checks          │
5
                         │  Failover policies      │
6
                         └────┬──────────┬─────────┘
7
                              │          │
8
                    ┌─────────┘          └─────────┐
9
                    ▼                               ▼
10
           ┌────────────────┐             ┌────────────────┐
11
           │  us-east-1     │             │  eu-west-1     │
12
           │  (Primary)     │             │  (Secondary)   │
13
           │                │             │                │
14
           │  ┌──────────┐  │             │  ┌──────────┐  │
15
           │  │ ALB      │  │             │  │ ALB      │  │
16
           │  │ Agent    │  │             │  │ Agent    │  │
17
           │  │ Service  │  │             │  │ Service  │  │
18
           │  └──────────┘  │             │  └──────────┘  │
19
           │                │             │                │
20
           │  DynamoDB      │  ◄────►     │  DynamoDB      │
21
           │  Global Table  │             │  Global Table  │
22
           └────────────────┘             └────────────────┘
23
                              │
24
                              │
25
                    ┌─────────▼──────────┐
26
                    │  CloudFront (CDN)  │
27
                    │  450+ edge nodes   │
28
                    │  Cache agent GET   │
29
                    │  responses         │
30
                    └────────────────────┘

Step 1: Deploy Agent in Two Regions#

You already have the infrastructure from Days 1-4. Deploy it in us-east-1 (primary) and eu-west-1 (secondary).

1
# Deploy ECS-based agent in us-east-1 (Day 1)
2
aws ecs create-service \
3
  --cluster mcp-server-cluster \
4
  --service-name github-issue-mcp \
5
  --task-definition github-issue-mcp \
6
  --desired-count 2 \
7
  --launch-type FARGATE \
8
  --network-configuration "awsvpcConfiguration={subnets=[subnet-us-east-1a,subnet-us-east-1b],securityGroups=[sg-xxx]}" \
9
  --load-balancers "targetGroupArn=<tg-arn-us-east-1>,containerName=mcp-server,containerPort=3001" \
10
  --region us-east-1
11

12
# Same thing in eu-west-1
13
aws ecs create-service \
14
  --cluster mcp-server-cluster \
15
  --service-name github-issue-mcp \
16
  --task-definition github-issue-mcp \
17
  --desired-count 2 \
18
  --launch-type FARGATE \
19
  --network-configuration "awsvpcConfiguration={subnets=[subnet-eu-west-1a,subnet-eu-west-1b],securityGroups=[sg-yyy]}" \
20
  --load-balancers "targetGroupArn=<tg-arn-eu-west-1>,containerName=mcp-server,containerPort=3001" \
21
  --region eu-west-1

State replication#

DynamoDB Global Tables already replicate sessions across regions (Day 2). No extra work.

Cache warming#

ElastiCache Redis is regional. In failover, sessions that were in Redis hit DynamoDB instead (a bit slower, but still works).

Step 2: Route53 Latency-Based Routing#

Create agent subdomain#

1
# Create latency-based record set for us-east-1
2
aws route53 change-resource-record-sets \
3
  --hosted-zone-id ZONE_ID \
4
  --change-batch '{
5
    "Changes": [
6
      {
7
        "Action": "CREATE",
8
        "ResourceRecordSet": {
9
          "Name": "agent.yourdomain.com.",
10
          "Type": "A",
11
          "SetIdentifier": "us-east-1",
12
          "Region": "us-east-1",
13
          "AliasTarget": {
14
            "HostedZoneId": "'"$(aws elbv2 describe-load-balancers --names mcp-server-alb --region us-east-1 --query 'LoadBalancers[0].CanonicalHostedZoneId' --output text)"'",
15
            "DNSName": "'"$(aws elbv2 describe-load-balancers --names mcp-server-alb --region us-east-1 --query 'LoadBalancers[0].DNSName' --output text)"'",
16
            "EvaluateTargetHealth": true
17
          },
18
          "Failover": "PRIMARY",
19
          "HealthCheckId": "'"$HEALTH_CHECK_US"'""
20
        }
21
      },
22
      {
23
        "Action": "CREATE",
24
        "ResourceRecordSet": {
25
          "Name": "agent.yourdomain.com.",
26
          "Type": "A",
27
          "SetIdentifier": "eu-west-1",
28
          "Region": "eu-west-1",
29
          "AliasTarget": {
30
            "HostedZoneId": "'"$(aws elbv2 describe-load-balancers --names mcp-server-alb --region eu-west-1 --query 'LoadBalancers[0].CanonicalHostedZoneId' --output text)"'",
31
            "DNSName": "'"$(aws elbv2 describe-load-balancers --names mcp-server-alb --region eu-west-1 --query 'LoadBalancers[0].DNSName' --output text)"'",
32
            "EvaluateTargetHealth": true
33
          },
34
          "Failover": "SECONDARY",
35
          "HealthCheckId": "'"$HEALTH_CHECK_EU"'""
36
        }
37
      }
38
    ]
39
  }'

Step 3: Health Checks#

Route53 health checks determine whether a region is healthy. If us-east-1 fails, Route53 automatically routes traffic to eu-west-1.

1
# Health check for us-east-1 ALB
2
aws route53 create-health-check \
3
  --caller-reference "agent-us-east-1-$(date +%s)" \
4
  --health-check-config '{
5
    "Type": "HTTPS",
6
    "FullyQualifiedDomainName": "'"$(aws elbv2 describe-load-balancers --names mcp-server-alb --region us-east-1 --query 'LoadBalancers[0].DNSName' --output text)"'",
7
    "Port": 443,
8
    "ResourcePath": "/health",
9
    "RequestInterval": 30,
10
    "FailureThreshold": 3,
11
    "MeasureLatency": true,
12
    "EnableSNI": true
13
  }'
14

15
# Same for eu-west-1
16
aws route53 create-health-check \
17
  --caller-reference "agent-eu-west-1-$(date +%s)" \
18
  --health-check-config '{
19
    "Type": "HTTPS",
20
    "FullyQualifiedDomainName": "'"$(aws elbv2 describe-load-balancers --names mcp-server-alb --region eu-west-1 --query 'LoadBalancers[0].DNSName' --output text)"'",
21
    "Port": 443,
22
    "ResourcePath": "/health",
23
    "RequestInterval": 30,
24
    "FailureThreshold": 3,
25
    "MeasureLatency": true,
26
    "EnableSNI": true
27
  }'

Calculate your latency budget:#

Hop	us-east-1	eu-west-1
Client DNS	20-50ms	20-50ms
Route53 latency routing	10ms	10ms
TLS handshake	30ms	30ms
ALB processing	5ms	5ms
LLM call (Bedrock)	2-5s	2-5s
Tool execution	200-500ms	200-500ms
DynamoDB read	5-10ms	5-10ms
Response transfer	50ms (local) / 200ms (transatlantic)	50ms

For users in Asia, us-east-1 adds 150-200ms vs eu-west-1. Route53 picks the closer region automatically.

Step 4: CloudFront for Edge Caching#

For agent responses that are cacheable (documentation lookups, static analysis results, common queries), CloudFront can serve from 450+ edge locations instead of routing to your agent infrastructure at all.

1
# Create CloudFront distribution pointing to our agent
2
aws cloudfront create-distribution \
3
  --origin-domain-name "agent.yourdomain.com" \
4
  --default-root-object "" \
5
  --default-cache-behavior '{
6
    "TargetOriginId": "agent-origin",
7
    "ViewerProtocolPolicy": "redirect-to-https",
8
    "AllowedMethods": {
9
      "Quantity": 2,
10
      "Items": ["GET", "HEAD"],
11
      "CachedMethods": {
12
        "Quantity": 2,
13
        "Items": ["GET", "HEAD"]
14
      }
15
    },
16
    "ForwardedValues": {
17
      "QueryString": true,
18
      "Cookies": { "Forward": "none" },
19
      "Headers": {
20
        "Quantity": 1,
21
        "Items": ["Authorization"]
22
      }
23
    },
24
    "MinTTL": 60,
25
    "DefaultTTL": 300,
26
    "MaxTTL": 3600
27
  }' \
28
  --enabled \
29
  --comment "Agent CDN - Cache agent responses at edge"

What to cache at edge vs what to pass through:

Cacheable	Not cacheable
Static docs, FAQ responses	Real-time agent reasoning
Knowledge base lookups	User-specific prompts
Tool schema definitions	Session state changes
Health check responses	WebSocket streams
Config metadata	Write operations (create, delete)

Step 5: Global Accelerator for TCP/UDP Agents#

Route53 handles DNS routing well, but DNS changes take time to propagate (TTL-dependent). Global Accelerator uses Anycast IPs — traffic enters the AWS network at the closest edge and is routed internally to the optimal region.

This is important for agents that need:

Fast failover (<1s, vs DNS’s 30-60s TTL propagation)
TCP/UDP protocols (MCP STDIO alternative transports)
Non-HTTP agents (gRPC, raw TCP sockets)

1
# Create Global Accelerator
2
ACCELERATOR_ARN=$(aws globalaccelerator create-accelerator \
3
  --name agent-global-accelerator \
4
  --ip-address-type IPV4 \
5
  --enabled \
6
  --query 'Accelerator.AcceleratorArn' --output text)
7

8
# Get the two Anycast IPs
9
aws globalaccelerator describe-accelerator \
10
  --accelerator-arn $ACCELERATOR_ARN \
11
  --query 'Accelerator.IpSets[0].IpAddresses'
12

13
# Create listener (port 443, TCP)
14
LISTENER_ARN=$(aws globalaccelerator create-listener \
15
  --accelerator-arn $ACCELERATOR_ARN \
16
  --port-ranges '[{"FromPort": 443, "ToPort": 443}]' \
17
  --protocol TCP \
18
  --client-affinity NONE \
19
  --query 'Listener.ListenerArn' --output text)
20

21
# Create endpoint group for us-east-1
22
aws globalaccelerator create-endpoint-group \
23
  --listener-arn $LISTENER_ARN \
24
  --endpoint-group-region us-east-1 \
25
  --traffic-dial-percentage 100 \
26
  --health-check-port 443 \
27
  --health-check-protocol HTTPS \
28
  --health-check-path /health \
29
  --endpoint-configurations '[{
30
    "EndpointId": "'"$(aws elbv2 describe-load-balancers --names mcp-server-alb --region us-east-1 --query 'LoadBalancers[0].LoadBalancerArn' --output text)"'",
31
    "Weight": 100
32
  }]'
33

34
# Same for eu-west-1
35
aws globalaccelerator create-endpoint-group \
36
  --listener-arn $LISTENER_ARN \
37
  --endpoint-group-region eu-west-1 \
38
  --traffic-dial-percentage 100 \
39
  --health-check-port 443 \
40
  --health-check-protocol HTTPS \
41
  --health-check-path /health \
42
  --endpoint-configurations '[{
43
    "EndpointId": "'"$(aws elbv2 describe-load-balancers --names mcp-server-alb --region eu-west-1 --query 'LoadBalancers[0].LoadBalancerArn' --output text)"'",
44
    "Weight": 50
45
  }]'

Route53 vs Global Accelerator:

Feature	Route53	Global Accelerator
Protocol	HTTP/HTTPS only	TCP/UDP + HTTP/HTTPS
Failover time	30-60s (DNS TTL)	<1s (Anycast)
Latency optimization	DNS-level	Network-level
Session persistence	Limited	Client affinity
Cost	Included with hosted zone	~$0.025/hr per accelerator

Step 6: Full Agent Failover Test#

1
#!/bin/bash
2
# failover-test.sh — Test multi-region agent failover
3

4
REGION_CHECK_ENDPOINT="agent.yourdomain.com/health"
5
PRIMARY_REGION="us-east-1"
6
SECONDARY_REGION="eu-west-1"
7

8
echo "=== 1. Normal state: both regions healthy ==="
9
curl -s -o /dev/null -w "Status: %{http_code}, Latency: %{time_total}s, IP: %{remote_ip}\n" \
10
  https://agent.yourdomain.com/health
11

12
echo ""
13
echo "=== 2. Get current routing from multiple locations ==="
14
for endpoint in "us-east-1" "eu-west-1" "ap-southeast-1"
15
do
16
  echo "Probing from $endpoint:"
17
  # Using Route53 resolver to simulate different client locations
18
  dig agent.yourdomain.com @8.8.8.8 +short
19
  dig agent.yourdomain.com @1.1.1.1 +short
20
  dig agent.yourdomain.com @208.67.222.222 +short
21
done
22

23
echo ""
24
echo "=== 3. Simulate us-east-1 failure ==="
25
# Block health check access to simulate ALB failure
26
aws ec2 revoke-security-group-ingress \
27
  --group-id <alb-sg-us-east-1> \
28
  --protocol tcp --port 443 \
29
  --source-group <health-check-sg>
30

31
echo "Waiting for Route53 health check to fail (90s)..."
32
sleep 90
33
# Kill ALB instances
34
aws autoscaling set-desired-capacity \
35
  --auto-scaling-group-name <asg-us-east-1> \
36
  --desired-capacity 0
37

38
echo ""
39
echo "=== 4. Verify failover to eu-west-1 ==="
40
curl -s -o /dev/null -w "Status: %{http_code}, Latency: %{time_total}s\n" \
41
  https://agent.yourdomain.com/health
42

43
echo ""
44
echo "=== 5. Restore us-east-1 ==="
45
aws autoscaling set-desired-capacity \
46
  --auto-scaling-group-name <asg-us-east-1> \
47
  --desired-capacity 2
48

49
aws autoscaling update-auto-scaling-group \
50
  --auto-scaling-group-name <asg-us-east-1> \
51
  --health-check-type ELB --health-check-grace-period 60
52

53
echo "Waiting for health check recovery..."
54
sleep 60
55

56
aws ec2 authorize-security-group-ingress \
57
  --group-id <alb-sg-us-east-1> \
58
  --protocol tcp --port 443 \
59
  --source-group <health-check-sg>
60

61
echo ""
62
echo "=== 6. Verify recovery ==="
63
curl -s -o /dev/null -w "Status: %{http_code}, Latency: %{time_total}s\n" \
64
  https://agent.yourdomain.com/health
65

66
echo ""
67
echo "=== Failover test complete ==="

Step 7: Client-Side Multi-Region Awareness#

For agents that need session awareness across regions (e.g., same conversation, different region), the client sends its region preference:

1
const agentClient = {
2
  region: await detectClosestRegion(),
3

4
  async detectClosestRegion(): Promise<string> {
5
    // Probe each region endpoint
6
    const regions = ["us-east-1", "eu-west-1", "ap-southeast-1"];
7
    const latencies = await Promise.all(
8
      regions.map(async (region) => {
9
        const start = Date.now();
10
        try {
11
          await fetch(`https://agent-${region}.yourdomain.com/ping`);
12
          return { region, latency: Date.now() - start };
13
        } catch {
14
          return { region, latency: Infinity };
15
        }
16
      })
17
    );
18
    return latencies.sort((a, b) => a.latency - b.latency)[0].region;
19
  },
20

21
  async tell(prompt: string) {
22
    const region = this.region;
23
    const url = `https://agent-${region}.yourdomain.com/agent`;
24

25
    return fetch(url, {
26
      method: "POST",
27
      headers: { "Content-Type": "application/json" },
28
      body: JSON.stringify({
29
        prompt,
30
        sessionId: this.sessionId,
31
        currentRegion: region,
32
      }),
33
    });
34
  },
35
};

Cost Breakdown#

Component	Monthly
Second region (ECS Fargate, ALB)	~$55/mo
DynamoDB Global Tables replication	~$20-40/mo
Route53 latency records (2 regions)	~$1/mo
Route53 health checks (2 checks × 3 locations)	~$6/mo
CloudFront (10GB, 100K requests)	~$5/mo
Global Accelerator (optional)	~$18/mo
Total additional for DR	~$87-125/mo

For a single region agent costing ~ $69/mo (from Day 1), adding multi-region DR costs roughly 1.5-2× the base infrastructure. Worth it if agent downtime costs more than ~$ 4/day.

Summary#

Layer	Technology	Purpose
DNS routing	Route53 latency-based	Route to nearest region
Failover	Route53 active-passive	Auto-detect and route around failures
Edge caching	CloudFront	Serve cacheable responses from 450+ locations
Anycast routing	Global Accelerator	TCP/UDP agents, sub-second failover
State replication	DynamoDB Global Tables	Session survival across regions
Health checks	Route53 health checks	Monitor region health

Checklist:#

Day	Topic
1	Deploy MCP Server on ECS Fargate ✅
2	Agent State with DynamoDB Global Tables ✅
3	LLM Caching with ElastiCache + Bedrock ✅
4	Serverless Agent with Lambda + Bedrock ✅
5	Multi-Region Agent Routing with Route53 ✅
6	CI/CD for AI Agents with CodePipeline

Series: AWS for AI/Agent Developers. Day 5: Multi-region agent routing — Route53 latency-based routing, active-passive failover, CloudFront edge caching, Global Accelerator for TCP/UDP.