aryem.dev

Multi-Cloud Architecture: Lessons from Working with AWS, GCP, and Azure

6 min read

Multi-Cloud Architecture: Lessons from Working with AWS, GCP, and Azure

Over 7 years, I’ve built production systems on all three major cloud providers: AWS, Google Cloud Platform (GCP), and Microsoft Azure. Each has strengths and weaknesses. Here’s what I learned about when to use each, and how to navigate a multi-cloud world.

Cloud Provider Strengths

AWS: The Everything Store

Best for: Mature services, enterprise features, broadest service catalog

Standout services:

  • Lambda + API Gateway: Best-in-class serverless
  • S3: Industry standard object storage
  • RDS: Managed databases with every option
  • IAM: Most granular permission model

Use AWS when: You need battle-tested services, deep integrations, or enterprise compliance

GCP: AI/ML First

Best for: AI/ML workloads, modern data analytics, Kubernetes

Standout services:

  • Vertex AI: Best managed AI/ML platform
  • BigQuery: Unmatched data warehouse performance
  • GKE: Best managed Kubernetes
  • Cloud Functions: Excellent cold start times

Use GCP when: AI/ML is core to your product, or you’re building data-intensive applications

Azure: Enterprise Integration

Best for: Microsoft ecosystem, hybrid cloud, enterprise apps

Standout services:

  • Active Directory integration: Seamless enterprise auth
  • Azure Functions: .NET serverless done right
  • SignalR Service: Managed real-time communication
  • Cosmos DB: Global multi-master database

Use Azure when: You’re in the Microsoft ecosystem, need hybrid cloud, or building enterprise SaaS

Real-World Multi-Cloud Architecture

At Easygenerator, we use all three:

┌──────────────────────────────────────────────────┐
│            User Traffic                          │
└─────────┬────────────────────────────────────────┘
          │
          ↓
┌─────────────────────────────────────────────────┐
│   AWS CloudFront (CDN - Global)                 │
│   - Edge caching                                 │
│   - DDoS protection                              │
└─────────┬───────────────────────────────────────┘
          │
          ↓
┌─────────────────────────────────────────────────┐
│   AWS (Core Application)                         │
│   ┌─────────────────────────────────────────┐   │
│   │ • API Gateway + Lambda (API)            │   │
│   │ • RDS PostgreSQL (Data)                 │   │
│   │ • S3 (Media Storage)                    │   │
│   │ • ElastiCache Redis (Sessions)          │   │
│   │ • SQS + EventBridge (Messaging)         │   │
│   └─────────────────────────────────────────┘   │
└────────┬────────────────────────────────────────┘
         │
         └──────┬──────────────────┬──────────────
                │                  │
                ↓                  ↓
    ┌──────────────────┐  ┌───────────────────┐
    │  GCP (AI/ML)     │  │  Azure (Legacy)   │
    │                  │  │                   │
    │ • Vertex AI      │  │ • SignalR Service │
    │ • Speech API     │  │ • Blob Storage    │
    │ • Gemini         │  │                   │
    └──────────────────┘  └───────────────────┘

Why multi-cloud?

  • Best-of-breed: Use GCP’s AI where it excels
  • Migration: Gradual migration from Azure to AWS
  • Risk mitigation: Not locked into single vendor
  • Regional presence: Different providers better in different regions

Patterns for Multi-Cloud

1. Data Synchronization

Challenge: Keep data consistent across clouds

Solution: Event-driven replication

// AWS Lambda: Sync to GCP when data changes
export async function handleDynamoDBStream(event: DynamoDBStreamEvent) {
  for (const record of event.Records) {
    if (record.eventName === 'INSERT' || record.eventName === 'MODIFY') {
      const item = record.dynamodb?.NewImage;
 
      // Sync to GCP Firestore
      await replicateToGCP(item);
    }
  }
}
 
async function replicateToGCP(data: any) {
  const { Firestore } = require('@google-cloud/firestore');
  const firestore = new Firestore();
 
  await firestore.collection('users').doc(data.id).set(data);
}

2. Cross-Cloud Authentication

Challenge: Single sign-on across clouds

Solution: JWT tokens + JWKS

// AWS Lambda authorizer
export async function authorize(event: APIGatewayAuthorizerEvent) {
  const token = event.authorizationToken?.replace('Bearer ', '');
 
  // Verify JWT (works with Cognito, Auth0, Azure AD)
  const decoded = await verifyJWT(token, {
    jwksUri: process.env.JWKS_URI,  // Works with any provider
  });
 
  return generatePolicy(decoded.sub, 'Allow', event.methodArn);
}
 
// GCP Cloud Function uses same JWT
export async function gcpFunction(req: Request, res: Response) {
  const token = req.headers.authorization?.replace('Bearer ', '');
  const decoded = await verifyJWT(token, {
    jwksUri: process.env.JWKS_URI,  // Same JWKS endpoint
  });
 
  // Use decoded.sub as user ID
}

3. Multi-Cloud Monitoring

Challenge: Unified observability

Solution: Centralized logging and metrics

// Use DataDog / New Relic / Grafana Cloud for unified monitoring
import { Logger } from '@datadog/datadog-logging';
 
const logger = new Logger({
  apiKey: process.env.DATADOG_API_KEY,
  service: 'api',
  env: process.env.ENVIRONMENT,
  tags: {
    cloud: 'aws',  // or 'gcp' or 'azure'
  },
});
 
// Works identically on all clouds
logger.info('User signed in', { userId: '123', cloud: 'aws' });

Cost Comparison (Real Data)

For our workload (50K MAU, API-heavy SaaS):

ServiceAWSGCPAzure
Compute (serverless)$120$95$110
Database (managed)$85$110$95
Storage (object)$45$50$48
CDN$35$30$40
Monitoring$25$20$28
Total/month$310$305$321

Takeaway: Pricing is similar. Choose based on features, not cost alone.

When to Choose Each Cloud

Choose AWS when:

✅ Need widest service selection ✅ Startups (credits, ecosystem) ✅ Require most mature enterprise features ✅ Want largest community and resources

Choose GCP when:

✅ AI/ML is core to your product ✅ Data analytics and BigQuery workflows ✅ Need best Kubernetes experience ✅ Want simpler pricing models

Choose Azure when:

✅ Microsoft shop (.NET, Active Directory) ✅ Need hybrid cloud (on-prem + cloud) ✅ Selling to enterprises (they’re often Azure) ✅ Want tight Office 365 integration

Multi-Cloud Anti-Patterns

❌ Don’t: Split single application across clouds

Latency kills performance. Keep tightly coupled services in same cloud.

❌ Don’t: Use proprietary services everywhere

Use open standards (Postgres not DynamoDB, Kubernetes not ECS) if portability matters.

❌ Don’t: Over-abstract

Building cloud-agnostic layers costs engineering time. Only abstract if you’ll actually switch.

❌ Don’t: Ignore data transfer costs

Cross-cloud data transfer is expensive ($0.12/GB+). Keep data close to compute.

Multi-Cloud Best Practices

✅ Do: Use infrastructure as code

Terraform works across all clouds. CloudFormation/ARM/Deployment Manager lock you in.

# Terraform: One language, all clouds
provider "aws" {
  region = "us-east-1"
}
 
provider "google" {
  project = "my-project"
  region  = "us-central1"
}
 
resource "aws_s3_bucket" "media" {
  bucket = "media-bucket"
}
 
resource "google_storage_bucket" "ai_data" {
  name     = "ai-data-bucket"
  location = "US"
}

✅ Do: Centralize secrets management

Use Vault, AWS Secrets Manager (cross-cloud), or Parameter Store.

✅ Do: Plan for egress costs

Data leaving a cloud is expensive. Cache at edge, process in-cloud.

✅ Do: Use managed services

Don’t run your own Postgres/Redis/etc. Use RDS, Cloud SQL, or Azure Database.

My Recommendations

Starting a new project? → Choose one cloud. Multi-cloud adds complexity you don’t need early on. → Pick based on your team’s expertise and workload (AI → GCP, Enterprise → Azure, General → AWS)

Growing startup? → Stick with one cloud until you have clear reasons to expand → Use open standards (Postgres, Redis, Kubernetes) for future flexibility

Established company? → Multi-cloud makes sense for best-of-breed services → Keep blast radius small: use secondary cloud for specific workloads (AI, analytics) → Invest in automation (Terraform, unified monitoring)

Key Takeaways

  1. All three clouds are excellent: Choose based on workload, not hype
  2. Multi-cloud adds complexity: Only do it for good reasons
  3. AWS is Swiss Army knife: Broadest services, best for general-purpose
  4. GCP excels at AI/ML: Best choice for data-intensive and AI workloads
  5. Azure owns enterprise: If selling to corporations, Azure is an advantage
  6. Use IaC: Terraform enables multi-cloud without pain
  7. Centralize observability: DataDog/New Relic across all clouds

Navigating multi-cloud architecture? I’d love to discuss trade-offs and strategies. Connect on LinkedIn.

Graph View