Global Multi-Cloud Load Balancing & Traffic Routing

This project demonstrates how to deploy and configure a globally distributed, multi-cloud load balancing and traffic routing setup. The goal is to have our services (running on VMs or containers) in AWS, Azure, and Google Cloud, and route incoming traffic to the nearest or most optimal location using each platform’s global routing features. This approach is essential in the real world to achieve:

• High availability: Traffic is automatically rerouted if one region becomes unavailable.
• Low latency: Users are served from the closest or best-performing region.
• Scalability: Each cloud can auto-scale resources based on demand.
• Flexibility: Having multiple clouds reduces vendor lock-in and leverages the best features of each provider.

We will create a simple “Hello World” service on each cloud platform, then configure global routing so that a single endpoint routes traffic to the nearest or best-performing service instance. We’ll show how to do each step via the Cloud Provider Web Console (GUI) and the CLI.

Note: Every step below indicates both Manual Steps (GUI) and CLI steps together, so you can choose the method you prefer.

AWS Configuration

Step 1: Create an EC2 Instance or ECS Container

• Manual (Console)
  Sign in to the AWS Management Console.
  Navigate to EC2.
  Click Launch Instances, choose a free-tier eligible Amazon Linux AMI.
  Select the t2.micro instance type (free tier).
  Configure defaults and set a key pair for SSH.
  Under User data, optionally insert a startup script that runs a simple HTTP server on port 80 (e.g., python3 -m http.server 80).
  Launch the instance.

Step 2: Set Up AWS Global Accelerator or Route 53

• Manual (Console)
  Go to AWS Global Accelerator (or Route 53 → Create Hosted Zone if you prefer DNS-based routing).
  For Global Accelerator:
  Click Create accelerator and attach the EC2 instance endpoint or an Application Load Balancer if you created one in front of the instance.
  For Route 53:
  Create a new public hosted zone, add a record set (A record) pointing to the instance’s public IP (or the ALB DNS name).
  Use Latency Routing Policy to direct traffic to the nearest region.

• CLI (Global Accelerator example)

Create a Global Accelerator

Login :

az login

Create resource group :

az group create --name my-global-rg --location eastus

Create VM (with open port 80) :

az vm create \

--resource-group my-global-rg \

--name MyGlobalAppAzure \

--image UbuntuLTS \

--size Standard_B1s \

--admin-username azureuser \

--generate-ssh-keys

Open port 80 :

az vm open-port --port 80 --resource-group my-global-rg --name MyGlobalAppAzure

SSH into VM and start simple HTTP server

Example:

az ssh vm --resource-group my-global-rg --name MyGlobalAppAzure

sudo apt-get update && sudo apt-get install -y python3

nohup python3 -m http.server 80 &

Create a Front Door profile :

az afd profile create \

--resource-group my-global-rg \

--name MyGlobalFrontDoor \

--sku Standard_AzureFrontDoor

Create an endpoint and attach your VM’s IP as a backend :

az afd endpoint create \

--resource-group my-global-rg \

--profile-name MyGlobalFrontDoor \

--endpoint-name my-global-endpoint

Add a backend to the endpoint (you need the public IP of your VM):

az afd backend create \

--resource-group my-global-rg \

--profile-name MyGlobalFrontDoor \

--endpoint-name my-global-endpoint \

--backend-name my-azure-backend \

--address <PUBLIC_IP_OF_VM> \

--host-header <PUBLIC_IP_OF_VM>

Configure routing rules:

az afd route create ...

(Configure further for latency-based routing, custom domains, etc.)

Google Cloud Configuration

Step 1: Create a VM (Compute Engine) or a Cloud Run Service

• Manual (Console)
  Sign in to the Google Cloud Console.
  Go to Compute Engine → VM instances → Create Instance.
  Choose the e2-micro machine type (in the always-free usage for certain regions).
  Allow HTTP traffic.
  Deploy and install a simple HTTP server (similar to above).OR
  Use Cloud Run for a fully managed container.
  Create a new service from a container image (e.g., gcr.io/cloudrun/hello).
  Allow unauthenticated invocations.
• CLI
  Authenticate
  gcloud auth login
  gcloud config set project <YOUR_PROJECT_ID>
  
  Create a VM
  gcloud compute instances create my-global-gcp-vm \
  --machine-type=e2-micro \
  --image-family=debian-11 \
  --image-project=debian-cloud \
  --tags=http-server \
  --zone=us-central1-a
  
  Allow HTTP traffic
  gcloud compute firewall-rules create allow-http \
  --allow=tcp:80 \
  --target-tags=http-server
  
  (SSH in and run your Python HTTP server or any other web app)

gcloud compute url-maps create my-global-url-map \

--default-service=my-backend-service

gcloud compute target-http-proxies create my-global-proxy \

--url-map=my-global-url-map

gcloud compute forwarding-rules create my-global-forwarding-rule \

--global \

--target-http-proxy=my-global-proxy \

--ports=80

(You would also need to create a backend service and health check referencing your instance or Cloud Run service.)

• Insufficient IAM Permissions: Ensure you have the Owner or Editor roles on each cloud project/subscription.
• Firewall Block: Double-check firewall rules and security groups (port 80 or 443) across all platforms.
• Domain Configuration: If custom domains are used, verify DNS records point to the correct load balancing endpoints.
• Staying in Free Tier: Monitor usage on each platform. Long-running services could exceed free usage limits if traffic is heavy.
• Health Checks Failing: Ensure your simple HTTP server or container is actually responding on the correct port and path.