Multi-Cloud Strategy: AWS, Azure, and GCP in 2025

# AWS EKS
apiVersion: eks.amazonaws.com/v1
kind: Cluster
metadata:
  name: my-cluster
spec:
  version: "1.28"
  roleArn: arn:aws:iam::123456789:role/EKSRole
  vpc:
    securityGroups:
      - sg-0123456789

---
# Azure AKS
apiVersion:aks.azure.com/v1
kind: Cluster
metadata:
  name: my-cluster
spec:
  kubernetesVersion: "1.28"
  servicePrincipalProfile:
    clientId: <app-id>
    secret: <password>

---
# GCP GKE
apiVersion: container.googleapis.com/v1
kind: Cluster
metadata:
  name: my-cluster
spec:
  releaseChannel:
    channel: REGULAR
  nodePool:
    - name: default-pool

# Workload assessment template
workloads:
  - name: web-application
    requirements:
      compute:
        cpu: 4
        memory: 16GB
      storage:
        type: ssd
        size: 100GB
      network:
        latency: <50ms
        regions: [us-east, eu-west]
      compliance:
        - gdpr
        - soc2
    recommended_cloud: aws  # Best for this workload

  - name: ml-training
    requirements:
      compute:
        gpu: true
        nodes: 8
      storage:
        type: object
        size: 10TB
    recommended_cloud: gcp  # Best GPU pricing

  - name: windows-workloads
    requirements:
      os: windows
      license: existing
    recommended_cloud: azure  # Best Windows integration

# Cross-cloud data sync example
import boto3
from azure.storage.blob import BlobClient
from google.cloud import storage

class MultiCloudSync:
    def __init__(self):
        self.aws = boto3.client('s3')
        self.azure = BlobClient()
        self.gcp = storage.Client()
    
    def replicate_bucket(self, bucket_name, target):
        """Replicate data across clouds"""
        
        if target == 'aws':
            # Get from GCP
            blobs = self.gcp.list_blobs(bucket_name)
            for blob in blobs:
                self.aws.upload_fileobj(
                    blob.download_as_bytes(),
                    bucket_name,
                    blob.name
                )
        
        elif target == 'gcp':
            # Get from AWS
            objects = self.aws.list_objects_v2(Bucket=bucket_name)
            for obj in objects['Contents']:
                blob = self.gcp.bucket(bucket_name).blob(obj['Key'])
                blob.upload_from_string(
                    self.aws.get_object(
                        Bucket=bucket_name,
                        Key=obj['Key']
                    )['Body'].read()
                )

# Abstract cloud-specific implementations
class StorageProvider:
    def __init__(self, provider: str, config: dict):
        if provider == 'aws':
            self.client = AWSStorage(config)
        elif provider == 'azure':
            self.client = AzureStorage(config)
        elif provider == 'gcp':
            self.client = GCPStorage(config)
    
    def upload(self, path, data):
        return self.client.upload(path, data)
    
    def download(self, path):
        return self.client.download(path)

# Terraform multi-cloud example
provider "aws" {
  region = "us-east-1"
}

provider "azurerm" {
  features {}
  subscription_id = var.azure_sub_id
  tenant_id       = var.azure_tenant_id
}

provider "google" {
  project = "my-project"
  region  = "us-central1"
}

# AWS resources
resource "aws_instance" "web" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"
}

# Azure resources  
resource "azurerm_resource_group" "main" {
  name     = "multi-cloud-rg"
  location = "eastus"
}

# GCP resources
resource "google_compute_instance" "web" {
  name         = "web-server"
  machine_type = "e2-micro"
  zone         = "us-central1-a"
}

# Build once, run anywhere
FROM node:18-alpine
WORKDIR /app
COPY . .
RUN npm ci --only=production
CMD ["node", "server.js"]

# Kubernetes - same manifest works everywhere
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
        - name: myapp
          image: myregistry/myapp:v1
          ports:
            - containerPort: 8080

# Right-sizing recommendations
optimization:
  - type: compute
    action: right-size
    tools:
      - aws: AWS Compute Optimizer
      - azure: Azure Advisor
      - gcp: Recommender API
      
  - type: storage
    action: tiering
    tiers:
      - hot: frequently accessed
      - cold: archive, >90 days
      
  - type: commitments
    action: reserved
    savings: up-to-72%

# Trying to make everything portable
multi_cloud:
  abstraction_layer: complete
  complexity: maximum
  
# Result: Over-engineered, slow

# Only abstract what's needed
multi_cloud:
  portability: selective
  critical_components: ["containers", "data_layer"]
  
# Result: Pragmatic, maintainable

# Cross-cloud traffic ignored
data_transfer:
  cost: 0
  
# Reality: Cross-cloud can be expensive

# Account for egress costs
data_transfer:
  egress_per_GB: $0.09  # AWS
  budget: $10000/month

# Assuming identical services
aws_s3 == azure_blob == gcp_storage
# Reality: Different APIs, features, performance

# Account for differences
services:
  s3:
    strength: ecosystem
  blob:
    strength: windows_integration
  gcs:
    strength: analytics