--- # === IDENTITY === id: software/system-design/global-dns-load-balancing/2026 canonical_question: "How do I design global DNS and load balancing?" aliases: - "global DNS load balancing architecture" - "GeoDNS vs Anycast vs GSLB comparison" - "design global server load balancing system" - "DNS-based traffic routing multi-region" - "how to implement global traffic management" - "multi-region load balancing with DNS failover" - "anycast IP load balancing architecture" - "Route 53 latency routing vs Cloudflare load balancing" entity_type: software_reference domain: software > system-design > global_dns_load_balancing region: global jurisdiction: global temporal_scope: 2020-2026 # === VERIFICATION === last_verified: 2026-02-23 confidence: 0.92 version: 1.0 first_published: 2026-02-23 # === TEMPORAL VALIDITY === temporal_validity: status: stable last_breaking_change: "Cloudflare adaptive load balancing GA (2024), Route 53 Application Recovery Controller (2023)" next_review: 2026-08-22 change_sensitivity: medium # === CONSTRAINTS === constraints: - "DNS TTL floor: Never set TTL below 30s in production — resolver caching varies and ultra-low TTLs increase query volume 10-50x without proportional failover improvement" - "Anycast requires a /24 IPv4 or /48 IPv6 prefix minimum — you must own or lease an IP block and coordinate BGP announcements with each datacenter" - "Health checks must run from multiple vantage points — a single probe location creates false positives from network partitions" - "DNS-only load balancing cannot enforce session affinity — if sticky sessions are required, combine with L7 load balancing or use cookie-based persistence" - "GeoDNS accuracy degrades with VPN/proxy users and EDNS Client Subnet (ECS) non-compliance — always implement fallback logic" # === SKIP CONDITIONS === skip_this_unit_if: - condition: "User needs L4/L7 load balancing within a single datacenter (NGINX, HAProxy local setup)" use_instead: "Local load balancer configuration guides (NGINX/HAProxy upstream docs)" - condition: "User needs CDN configuration, not DNS-level traffic routing" use_instead: "CDN architecture documentation (Cloudflare CDN, CloudFront)" - condition: "User needs internal service mesh routing (Envoy, Istio, Linkerd)" use_instead: "Service mesh architecture guides" # === AGENT HINTS === inputs_needed: - key: routing_strategy question: "What is your primary routing goal?" type: choice options: ["Lowest latency", "Geographic compliance (data sovereignty)", "Cost optimization", "Disaster recovery / failover"] - key: scale question: "What is your expected global request volume?" type: choice options: ["<10K req/s (small)", "10K-500K req/s (medium)", ">500K req/s (large-scale)"] - key: infrastructure question: "Where are your backend servers deployed?" type: choice options: ["Single cloud provider (AWS/GCP/Azure)", "Multi-cloud", "On-premises + cloud hybrid", "Edge / CDN-first"] # === DISTRIBUTION === canonical_source: "https://knowledgelib.io/software/system-design/global-dns-load-balancing/2026" suggested_citation: "Source: knowledgelib.io — AI Knowledge Library (verified 2026-02-23)" # === RELATED UNITS === related_kos: related_to: - id: "software/system-design/chat-app-at-scale/2026" label: "Chat App at Scale" - id: "software/system-design/e-commerce-platform/2026" label: "E-Commerce Platform Design" - id: "software/debugging/ssl-tls-certificate-errors/2026" label: "SSL/TLS Certificate Errors" solves: - id: "software/debugging/nodejs-econnrefused/2026" label: "Node.js ECONNREFUSED Errors" often_confused_with: - id: "software/system-design/search-engine/2026" label: "Search Engine Design (uses DNS but different scope)" # === SOURCES (7 authoritative sources) === sources: - id: src1 title: "Load Balancing Reference Architecture" author: Cloudflare url: https://developers.cloudflare.com/reference-architecture/architectures/load-balancing/ type: official_docs published: 2025-01-15 reliability: high - id: src2 title: "Choosing a Routing Policy" author: Amazon Web Services url: https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy.html type: official_docs published: 2025-06-01 reliability: high - id: src3 title: "Cloud Load Balancing Overview" author: Google Cloud url: https://docs.google.com/load-balancing/docs/load-balancing-overview type: official_docs published: 2025-03-01 reliability: high - id: src4 title: "Global Server Load Balancing with HAProxy" author: HAProxy Technologies url: https://www.haproxy.com/documentation/haproxy-enterprise/enterprise-modules/global-server-load-balancing/ type: official_docs published: 2025-01-01 reliability: high - id: src5 title: "Global Server Load Balancing with NGINX Plus" author: NGINX url: https://docs.nginx.com/nginx/deployment-guides/global-server-load-balancing/ type: official_docs published: 2025-02-01 reliability: high - id: src6 title: "How GSLB Improves Reliability Across Multi-Cloud Environments" author: Splunk url: https://www.splunk.com/en_us/blog/learn/global-server-load-balancing-gslb.html type: technical_blog published: 2024-09-15 reliability: moderate_high - id: src7 title: "Geo-DNS, Anycast, and GSLB: Best Approach for Global Performance" author: DynConD url: https://www.dyncond.com/geo-dns-anycast-and-gslb-whats-the-best-approach-for-global-performance/ type: technical_blog published: 2024-11-20 reliability: moderate_high --- # Global DNS and Load Balancing Architecture ## TL;DR - **Bottom line**: Global DNS load balancing routes users to the nearest healthy backend using a combination of GeoDNS, Anycast, and health-checked weighted records — choose your strategy based on latency requirements, compliance constraints, and infrastructure topology. - **Key tool/command**: `aws route53 create-health-check` + latency/geolocation routing policies (or Cloudflare Load Balancing with steering policies) - **Watch out for**: Setting DNS TTL too low (causes query floods) or too high (causes slow failover) — 60-300s is the sweet spot for most GSLB deployments. - **Works with**: AWS Route 53, Cloudflare, Google Cloud DNS, Azure Traffic Manager, HAProxy ALOHA, NGINX Plus, PowerDNS, NS1. ## Constraints - DNS TTL floor: Never set TTL below 30s — resolver caching varies wildly and ultra-low TTLs increase query volume 10-50x without proportional failover benefit - Anycast requires owning/leasing a /24 IPv4 or /48 IPv6 block and coordinating BGP with every datacenter provider - Health checks must run from multiple geographic vantage points (minimum 3 regions) to avoid false positives from network partitions - DNS-only load balancing cannot enforce session affinity — combine with L7 LB or cookie persistence when stateful sessions are required - GeoDNS accuracy degrades with VPN/proxy users and resolvers that do not support EDNS Client Subnet (ECS) ## Quick Reference | Component | Role | Technology Options | Scaling Strategy | |---|---|---|---| | Authoritative DNS | Responds to client DNS queries with region-optimal IPs | Route 53, Cloudflare DNS, Google Cloud DNS, NS1, PowerDNS | Anycast nameservers, horizontal replication | | GeoDNS Routing | Maps client IP geolocation to nearest datacenter | Route 53 Geolocation, Cloudflare Geo Steering, GCP routing policies | GeoIP database updates, ECS support | | Latency-Based Routing | Returns IPs of lowest-latency region for each client | Route 53 Latency, Cloudflare Dynamic Steering, NS1 Filter Chains | Continuous latency probing from edge PoPs | | Weighted Routing | Distributes traffic by percentage across endpoints | Route 53 Weighted, Cloudflare Weighted steering, HAProxy GSLB | Adjust weights per capacity; canary deployments | | Anycast Network | Single IP advertised from multiple PoPs via BGP | Cloudflare (built-in), GCP Global LB, custom BGP (BIRD/FRR) | Add PoPs, BGP community-based traffic engineering | | Health Checks | Detect unhealthy backends and remove from DNS | Route 53 Health Checks, Cloudflare Monitors, HAProxy agent checks | Multi-region probes, configurable thresholds | | L4/L7 Load Balancer | Local traffic distribution within each datacenter | NGINX, HAProxy, Envoy, AWS ALB/NLB, GCP Backend Services | Horizontal scaling, connection draining | | Failover Controller | Automatic rerouting on region-level outage | Route 53 Failover, Cloudflare Failover steering, GCP auto-failover | Primary/secondary/tertiary hierarchy | | SSL/TLS Termination | Terminates HTTPS at the edge before backend routing | Cloudflare SSL, AWS ACM + ALB, GCP Managed Certificates | Edge termination, certificate auto-renewal | | Monitoring & Observability | Track DNS resolution, latency, failover events | Cloudflare Analytics, Route 53 query logs, Prometheus + Grafana | Alerting on failover events, TTL violations | | DNS Caching Layer | Reduce query load on authoritative servers | Resolver TTL caching, local BIND/Unbound caches | Tune TTL 60-300s; cache warming | | Edge Compute | Run logic at DNS/HTTP edge for routing decisions | Cloudflare Workers, Lambda@Edge, Fastly Compute | Latency-based A/B testing, custom routing rules | ## Decision Tree ``` START ├── Need data sovereignty / compliance routing? │ ├── YES → Use GeoDNS with jurisdiction-locked regions │ │ (Route 53 Geolocation or Cloudflare Geo Steering) │ └── NO ↓ ├── Need sub-100ms failover with zero DNS propagation delay? │ ├── YES → Use Anycast IP with L7 health checks │ │ (GCP Global LB, Cloudflare proxy, custom BGP) │ └── NO ↓ ├── Need lowest-latency routing across 3+ regions? │ ├── YES → Use latency-based routing with health checks │ │ (Route 53 Latency + failover, Cloudflare Dynamic Steering) │ └── NO ↓ ├── Need canary/blue-green deployments? │ ├── YES → Use weighted routing (e.g., 90/10 split) │ │ (Route 53 Weighted, Cloudflare Weighted Steering) │ └── NO ↓ ├── <10K req/s with 2-3 regions? │ ├── YES → Simple DNS round-robin with health checks │ │ (Any managed DNS provider) │ └── NO ↓ └── DEFAULT → Combine Anycast (edge) + GeoDNS (regional) + L7 LB (local) This is the standard architecture for >100K req/s global services ``` ## Step-by-Step Guide ### 1. Define regions and deploy backends Identify 2-6 geographic regions based on your user distribution. Deploy identical application stacks in each region with independent databases or read replicas. [src1] ```bash # Example: List your target regions and endpoints # Region: us-east-1 → alb-us-east.example.com # Region: eu-west-1 → alb-eu-west.example.com # Region: ap-south-1 → alb-ap-south.example.com ``` **Verify**: Confirm each regional endpoint is independently accessible — `curl -s -o /dev/null -w "%{http_code}" https://alb-us-east.example.com/health` → expected: `200` ### 2. Configure health checks from multiple vantage points Set up health checks that probe each backend from at least 3 geographic locations. Configure failure thresholds (typically 3 consecutive failures) and check intervals (10-30s). [src2] ```bash # AWS Route 53: Create health check aws route53 create-health-check --caller-reference "us-east-$(date +%s)" \ --health-check-config '{ "FullyQualifiedDomainName": "alb-us-east.example.com", "Port": 443, "Type": "HTTPS", "ResourcePath": "/health", "RequestInterval": 10, "FailureThreshold": 3, "Regions": ["us-east-1", "eu-west-1", "ap-southeast-1"] }' ``` **Verify**: `aws route53 get-health-check-status --health-check-id ` → all reporters show `Success` ### 3. Set up DNS routing policy Choose and configure your primary routing strategy (latency, geolocation, or weighted). Associate health checks with each record set. [src2] ```bash # AWS Route 53: Latency-based routing with health check aws route53 change-resource-record-sets --hosted-zone-id Z1234567890 \ --change-batch '{ "Changes": [{ "Action": "CREATE", "ResourceRecordSet": { "Name": "api.example.com", "Type": "A", "SetIdentifier": "us-east-1", "Region": "us-east-1", "TTL": 60, "ResourceRecords": [{"Value": "203.0.113.10"}], "HealthCheckId": "hc-us-east-id" } }] }' # Repeat for each region with appropriate SetIdentifier and Region ``` **Verify**: `dig api.example.com +short` from different regions returns region-appropriate IPs ### 4. Configure local load balancers per region In each region, deploy L4/L7 load balancers (NGINX, HAProxy, or cloud ALBs) to distribute traffic across local backend instances. [src4] ```haproxy # HAProxy: Regional backend configuration frontend http_front bind *:443 ssl crt /etc/ssl/certs/example.pem default_backend app_servers backend app_servers balance roundrobin option httpchk GET /health http-check expect status 200 server app1 10.0.1.10:8080 check inter 5s fall 3 rise 2 server app2 10.0.1.11:8080 check inter 5s fall 3 rise 2 server app3 10.0.1.12:8080 check inter 5s fall 3 rise 2 ``` **Verify**: `echo "show stat" | socat /var/run/haproxy.sock stdio | grep app_servers` → all servers show `UP` ### 5. Implement failover hierarchy Configure primary, secondary, and tertiary failover targets so that regional failures cascade to the next-best region automatically. [src1] ```bash # Cloudflare: Configure failover pool priority via API curl -X PATCH "https://api.cloudflare.com/client/v4/zones/{zone_id}/load_balancers/{lb_id}" \ -H "Authorization: Bearer $CF_TOKEN" \ -H "Content-Type: application/json" \ --data '{ "default_pools": ["pool-us-east", "pool-eu-west", "pool-ap-south"], "fallback_pool": "pool-us-west", "steering_policy": "dynamic_latency", "session_affinity": "cookie" }' ``` **Verify**: Disable primary pool health endpoint, then `dig example.com` → should return secondary pool IPs within TTL window ### 6. Set up monitoring and alerting Monitor DNS resolution times, failover events, health check flaps, and regional traffic distribution. Alert on anomalies. [src6] ```bash # Prometheus: Query DNS resolution latency # Use blackbox_exporter to probe your DNS # prometheus.yml scrape config: # - job_name: 'dns_probe' # metrics_path: /probe # params: # module: [dns_example] # static_configs: # - targets: ['api.example.com'] # relabel_configs: # - source_labels: [__address__] # target_label: __param_target # Alert rule: DNS failover detected # alert: DNSFailoverTriggered # expr: probe_dns_lookup_time_seconds > 1 # for: 2m ``` **Verify**: Trigger a test failover and confirm alerts fire within expected thresholds ## Code Examples ### Terraform: Route 53 Latency-Based Routing with Health Checks > Full script: [terraform-route-53-latency-based-routing-with-heal.txt](scripts/terraform-route-53-latency-based-routing-with-heal.txt) (26 lines) ```hcl # Input: Multi-region ALB endpoints # Output: Latency-routed DNS with automatic failover resource "aws_route53_health_check" "us_east" { fqdn = "alb-us-east.example.com" port = 443 # ... (see full script) ``` ### HAProxy: GSLB with DNS-Based Backend Resolution ```haproxy # Input: DNS-discovered backend servers across regions # Output: Load-balanced traffic with health-aware routing resolvers cloudns nameserver dns1 8.8.8.8:53 nameserver dns2 1.1.1.1:53 resolve_retries 3 timeout resolve 1s timeout retry 1s hold valid 60s accepted_payload_size 8192 frontend gslb_front bind *:443 ssl crt /etc/ssl/certs/example.pem default_backend regional_backends backend regional_backends balance leastconn option httpchk GET /health http-check expect status 200 # DNS-resolved servers — IPs update automatically server-template us-east- 3 us-east.example.com:443 \ check inter 10s fall 3 rise 2 ssl verify required \ resolvers cloudns resolve-prefer ipv4 server-template eu-west- 3 eu-west.example.com:443 \ check inter 10s fall 3 rise 2 ssl verify required \ resolvers cloudns resolve-prefer ipv4 ``` ### Python: Programmatic DNS Health Check Monitor > Full script: [python-programmatic-dns-health-check-monitor.py](scripts/python-programmatic-dns-health-check-monitor.py) (52 lines) ```python # Input: List of endpoints and regions # Output: Health status map with latency metrics import dns.resolver # dnspython==2.6.1 import requests # requests==2.31.0 import time # ... (see full script) ``` ## Anti-Patterns ### Wrong: Single-region health check for global DNS ```yaml # BAD — health check from one location only # A network partition between probe and backend triggers false failover health_check: type: HTTPS endpoint: alb-us-east.example.com probe_region: us-east-1 # Single point of failure! failure_threshold: 1 # Too aggressive! ``` ### Correct: Multi-region health checks with sensible thresholds ```yaml # GOOD — probes from 3+ regions, requires consensus health_check: type: HTTPS endpoint: alb-us-east.example.com probe_regions: - us-east-1 - eu-west-1 - ap-southeast-1 failure_threshold: 3 # 3 consecutive failures request_interval: 10 # Every 10 seconds ``` ### Wrong: DNS TTL of 0 or 5 seconds for "instant" failover ```bash # BAD — TTL=5 causes massive query amplification # Resolvers may ignore TTL < 30s anyway (RFC 8767) api.example.com. 5 IN A 203.0.113.10 # Result: 100x query volume, no real failover improvement ``` ### Correct: TTL 60-300s balanced with active health checks ```bash # GOOD — TTL=60 provides fast-enough failover with manageable query volume # Health checks trigger DNS update; clients see new IP within 60s max api.example.com. 60 IN A 203.0.113.10 # Combined with Route 53 health checks: actual failover time = ~70-90s ``` ### Wrong: GeoDNS without fallback for unmapped regions ```python # BAD — users from unmapped regions get NXDOMAIN or random routing geo_routing = { "US": "203.0.113.10", "EU": "198.51.100.10", # No default! Users from Africa, South America, etc. get nothing } ``` ### Correct: GeoDNS with explicit default fallback ```python # GOOD — every region has a path, unmapped locations get best-effort routing geo_routing = { "US": "203.0.113.10", "EU": "198.51.100.10", "AP": "192.0.2.10", "DEFAULT": "203.0.113.10", # Fallback to lowest-latency PoP } ``` ### Wrong: Mixing Anycast with long-lived TCP connections without session persistence ``` # BAD — BGP route changes mid-connection cause TCP resets # Anycast works great for DNS (UDP) and short HTTP requests # But long-lived WebSocket/gRPC streams will break on route flaps anycast_ip: 198.51.100.1 → backend-pool (no session tracking) ``` ### Correct: Anycast for initial connection + session affinity for stateful protocols ``` # GOOD — Anycast handles initial routing, then L7 LB pins the session Client → Anycast IP (198.51.100.1) → Nearest edge PoP (BGP) → L7 Load Balancer (session cookie / consistent hashing) → Specific backend instance (pinned for connection lifetime) ``` ## Common Pitfalls - **TTL caching ignored by resolvers**: Some ISP resolvers cache DNS records beyond the stated TTL (RFC 8767 allows stale serving). Fix: design for worst-case TTL of 2x your configured value; use Anycast if you need faster failover. [src1] - **EDNS Client Subnet (ECS) not supported by resolver**: When the client's recursive resolver does not pass ECS, GeoDNS routes based on resolver location, not user location — users on Google Public DNS (8.8.8.8) may be misrouted. Fix: use Anycast as primary strategy; GeoDNS as secondary. [src7] - **Health check flapping causing DNS churn**: An overloaded backend oscillates between healthy/unhealthy, causing rapid DNS changes that confuse caches. Fix: set `rise` threshold (e.g., 3 consecutive successes) before re-adding a backend; implement circuit breakers. [src4] - **Forgetting to pre-lower TTL before migration**: Changing DNS records while TTL is 3600s means old records persist for up to 1 hour. Fix: lower TTL to 60s at least 48 hours before any DNS migration, then restore after. [src2] - **Single cloud provider DNS as the only authority**: If Route 53 has an outage, your entire global routing fails. Fix: use multi-provider DNS (Route 53 + Cloudflare, or NS1 + Google Cloud DNS) with matching record sets. [src6] - **Not testing failover in production-like conditions**: Failover works in staging but real traffic patterns cause unexpected behavior (e.g., thundering herd on secondary region). Fix: run regular chaos engineering drills — disable a region during low-traffic windows and measure recovery. [src3] - **Ignoring DNS propagation in deployment pipelines**: CI/CD deploys new code to a region then immediately routes traffic there, but DNS may still point elsewhere. Fix: deploy code first, verify health checks pass, then update DNS routing (blue-green at DNS level). [src1] - **Asymmetric capacity across regions**: GeoDNS sends equal traffic to all regions but one region has half the capacity. Fix: use weighted routing to match traffic distribution to provisioned capacity; implement auto-scaling triggers. [src2] ## Diagnostic Commands ```bash # Check DNS resolution from multiple locations dig api.example.com +short @8.8.8.8 dig api.example.com +short @1.1.1.1 # Trace full DNS resolution path dig api.example.com +trace # Check DNS response with ECS (EDNS Client Subnet) dig api.example.com +subnet=198.51.100.0/24 @8.8.8.8 # Verify TTL values dig api.example.com +noall +answer # Test health check endpoint curl -s -o /dev/null -w "HTTP %{http_code} in %{time_total}s\n" https://api.example.com/health # Check Route 53 health check status aws route53 get-health-check-status --health-check-id # List Cloudflare load balancer pool health curl -s "https://api.cloudflare.com/client/v4/zones/{zone}/load_balancers/pools/{pool}/health" \ -H "Authorization: Bearer $CF_TOKEN" | jq '.result' # Monitor DNS resolution latency over time while true; do echo "$(date +%T) $(dig api.example.com +noall +stats | grep 'Query time')" sleep 10 done # Check BGP route for Anycast IP (requires looking glass) whois -h whois.radb.net 198.51.100.0/24 ``` ## Version History & Compatibility | Technology | Current Version | Key Changes | Notes | |---|---|---|---| | AWS Route 53 | 2013-04-01 API | Application Recovery Controller (2023), IP-based routing (2022) | Most routing policies since launch are backwards-compatible | | Cloudflare LB | Adaptive (2024) | Adaptive load balancing GA, DNS-only LB mode, custom rules | Steering policies: off, geo, random, dynamic_latency, proximity, least_outstanding_requests, least_connections | | GCP Cloud DNS | v1 | Global anycast, routing policies (WRR, geolocation) (2022) | Integrated with Global External HTTP(S) LB | | HAProxy GSLB | 2.9+ / ALOHA 15+ | DNS resolution in backends, server-templates | GSLB module requires ALOHA or Enterprise edition | | NGINX Plus | R30+ | DNS SRV discovery, upstream resolve, geo module | GSLB requires NGINX Plus (not open-source NGINX) | ## When to Use / When Not to Use | Use When | Don't Use When | Use Instead | |---|---|---| | You have backends in 2+ geographic regions and need to route users to the nearest | All backends are in a single datacenter or region | Local L4/L7 load balancer (HAProxy, NGINX, ALB) | | You need automatic failover with <2 min recovery time | You need sub-second failover for real-time systems | Anycast with BGP failover or service mesh | | You need data sovereignty compliance (EU data stays in EU) | You have no regulatory/compliance requirements for data locality | Latency-based routing (simpler) | | You are running multi-cloud and need cloud-agnostic routing | You are fully committed to a single cloud provider | Cloud-native load balancing (ALB, Cloud LB) | | You need canary/blue-green deployments at the region level | You need canary deployments within a single cluster | Kubernetes Ingress with traffic splitting | | You need to distribute traffic based on capacity (weighted) | All regions have identical capacity | Simple GeoDNS or latency routing | ## Important Caveats - DNS is fundamentally a best-effort routing layer — you cannot guarantee all clients will follow your TTL or routing hints (corporate proxies, legacy resolvers, and mobile networks may cache aggressively) - Anycast provides near-instant failover for stateless protocols (DNS, HTTP) but can cause TCP connection resets during BGP convergence for long-lived connections - Cloud provider GSLB services (Route 53, Cloudflare LB, GCP GLB) are significantly easier to operate than self-managed Anycast/GeoDNS, but create vendor lock-in at the DNS layer - Health checks consume resources on your backends — at scale (many probes x many regions x short intervals), health check traffic itself can be significant - Latency-based routing on Route 53 measures latency to AWS regions, not to your specific backends — actual user experience may differ if your backends are not in the same region as the ALB endpoint ## Related Units - [Chat App at Scale](/software/system-design/chat-app-at-scale/2026) - [E-Commerce Platform Design](/software/system-design/e-commerce-platform/2026) - [SSL/TLS Certificate Errors](/software/debugging/ssl-tls-certificate-errors/2026) - [Node.js ECONNREFUSED Errors](/software/debugging/nodejs-econnrefused/2026)