AWS vs Azure vs GCP 2026: Complete Cloud Platform Comparison Guide

// AWS - Lambda Function with TypeScript
import { APIGatewayProxyHandler } from 'aws-lambda';
import { DynamoDBClient, GetItemCommand } from '@aws-sdk/client-dynamodb';

const dynamodb = new DynamoDBClient({});

export const handler: APIGatewayProxyHandler = async (event) => {
  const userId = event.pathParameters?.userId;
  
  if (!userId) {
    return {
      statusCode: 400,
      body: JSON.stringify({ error: 'userId is required' }),
    };
  }

  try {
    const result = await dynamodb.send(
      new GetItemCommand({
        TableName: process.env.USERS_TABLE!,
        Key: { id: { S: userId } },
      })
    );

    if (!result.Item) {
      return {
        statusCode: 404,
        body: JSON.stringify({ error: 'User not found' }),
      };
    }

    return {
      statusCode: 200,
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        id: result.Item.id.S,
        name: result.Item.name.S,
        email: result.Item.email.S,
      }),
    };
  } catch (error) {
    console.error('Error:', error);
    return {
      statusCode: 500,
      body: JSON.stringify({ error: 'Internal server error' }),
    };
  }
};

// Azure - Function with TypeScript
import { AzureFunction, Context, HttpRequest } from '@azure/functions';
import { CosmosClient } from '@azure/cosmos';

const cosmosClient = new CosmosClient(process.env.COSMOS_CONNECTION_STRING!);
const database = cosmosClient.database('mydb');
const container = database.container('users');

const httpTrigger: AzureFunction = async (
  context: Context,
  req: HttpRequest
): Promise<void> => {
  const userId = req.params.userId;

  if (!userId) {
    context.res = {
      status: 400,
      body: { error: 'userId is required' },
    };
    return;
  }

  try {
    const { resource: user } = await container
      .item(userId, userId)
      .read();

    if (!user) {
      context.res = {
        status: 404,
        body: { error: 'User not found' },
      };
      return;
    }

    context.res = {
      status: 200,
      headers: { 'Content-Type': 'application/json' },
      body: {
        id: user.id,
        name: user.name,
        email: user.email,
      },
    };
  } catch (error) {
    context.log.error('Error:', error);
    context.res = {
      status: 500,
      body: { error: 'Internal server error' },
    };
  }
};

export default httpTrigger;

// GCP - Cloud Function with TypeScript
import { HttpFunction } from '@google-cloud/functions-framework';
import { Firestore } from '@google-cloud/firestore';

const firestore = new Firestore();
const usersCollection = firestore.collection('users');

export const getUser: HttpFunction = async (req, res) => {
  // Enable CORS
  res.set('Access-Control-Allow-Origin', '*');
  
  if (req.method === 'OPTIONS') {
    res.set('Access-Control-Allow-Methods', 'GET');
    res.status(204).send('');
    return;
  }

  const userId = req.params[0] || req.query.userId;

  if (!userId) {
    res.status(400).json({ error: 'userId is required' });
    return;
  }

  try {
    const userDoc = await usersCollection.doc(userId as string).get();

    if (!userDoc.exists) {
      res.status(404).json({ error: 'User not found' });
      return;
    }

    const userData = userDoc.data()!;
    res.status(200).json({
      id: userDoc.id,
      name: userData.name,
      email: userData.email,
    });
  } catch (error) {
    console.error('Error:', error);
    res.status(500).json({ error: 'Internal server error' });
  }
};

# AWS EKS - Create cluster
eksctl create cluster \
  --name my-cluster \
  --region us-west-2 \
  --nodegroup-name standard-workers \
  --node-type t3.medium \
  --nodes 3 \
  --nodes-min 1 \
  --nodes-max 5 \
  --managed

# Azure AKS - Create cluster
az aks create \
  --resource-group myResourceGroup \
  --name myAKSCluster \
  --node-count 3 \
  --node-vm-size Standard_DS2_v2 \
  --enable-addons monitoring \
  --generate-ssh-keys

# GCP GKE - Create cluster (Autopilot - recommended)
gcloud container clusters create-auto my-cluster \
  --region us-central1 \
  --project my-project

| Feature                | AWS EKS        | Azure AKS      | GCP GKE         |
|-----------------------|----------------|----------------|------------------|
| Control Plane Cost    | $0.10/hr       | Free           | Free (Autopilot) |
| Node Management       | Managed/Fargate| Managed        | Autopilot/Standard|
| Max Nodes per Cluster | 5,000          | 5,000          | 15,000           |
| GPU Support           | Yes            | Yes            | Yes              |
| Spot/Preemptible      | Yes            | Yes            | Yes              |
| Multi-region          | Manual         | Manual         | Native           |
| Service Mesh          | App Mesh       | Open Service Mesh| Anthos Service Mesh|
| GitOps Integration    | Flux           | GitOps (Flux)  | Config Sync      |

// AWS - DynamoDB with single-table design
import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
import { 
  DynamoDBDocumentClient, 
  PutCommand, 
  QueryCommand,
  TransactWriteCommand,
} from '@aws-sdk/lib-dynamodb';

const client = new DynamoDBClient({});
const docClient = DynamoDBDocumentClient.from(client);

const TABLE_NAME = process.env.TABLE_NAME!;

// Single-table design patterns
export async function createOrder(order: Order) {
  const now = new Date().toISOString();
  
  // Transaction to create order and update inventory
  await docClient.send(
    new TransactWriteCommand({
      TransactItems: [
        // Create order record
        {
          Put: {
            TableName: TABLE_NAME,
            Item: {
              PK: `USER#${order.userId}`,
              SK: `ORDER#${order.id}`,
              GSI1PK: `ORDER#${order.id}`,
              GSI1SK: `ORDER#${order.id}`,
              type: 'ORDER',
              ...order,
              createdAt: now,
            },
          },
        },
        // Create order items
        ...order.items.map((item) => ({
          Put: {
            TableName: TABLE_NAME,
            Item: {
              PK: `ORDER#${order.id}`,
              SK: `ITEM#${item.productId}`,
              type: 'ORDER_ITEM',
              ...item,
            },
          },
        })),
        // Update inventory
        ...order.items.map((item) => ({
          Update: {
            TableName: TABLE_NAME,
            Key: {
              PK: `PRODUCT#${item.productId}`,
              SK: `PRODUCT#${item.productId}`,
            },
            UpdateExpression: 'SET inventory = inventory - :qty',
            ConditionExpression: 'inventory >= :qty',
            ExpressionAttributeValues: {
              ':qty': item.quantity,
            },
          },
        })),
      ],
    })
  );
}

// Query user's orders
export async function getUserOrders(userId: string) {
  const result = await docClient.send(
    new QueryCommand({
      TableName: TABLE_NAME,
      KeyConditionExpression: 'PK = :pk AND begins_with(SK, :sk)',
      ExpressionAttributeValues: {
        ':pk': `USER#${userId}`,
        ':sk': 'ORDER#',
      },
      ScanIndexForward: false, // Newest first
      Limit: 20,
    })
  );
  
  return result.Items;
}

# GCP Vertex AI - Training and deploying a model
from google.cloud import aiplatform

aiplatform.init(
    project='my-project',
    location='us-central1',
)

# Create a custom training job
job = aiplatform.CustomTrainingJob(
    display_name='my-training-job',
    script_path='trainer/task.py',
    container_uri='us-docker.pkg.dev/vertex-ai/training/pytorch-gpu.1-13:latest',
    requirements=['transformers', 'datasets'],
    model_serving_container_image_uri=(
        'us-docker.pkg.dev/vertex-ai/prediction/pytorch-gpu.1-13:latest'
    ),
)

# Run training
model = job.run(
    dataset=my_dataset,
    model_display_name='my-model',
    replica_count=1,
    machine_type='n1-standard-8',
    accelerator_type='NVIDIA_TESLA_T4',
    accelerator_count=1,
)

# Deploy model to endpoint
endpoint = model.deploy(
    machine_type='n1-standard-4',
    accelerator_type='NVIDIA_TESLA_T4',
    accelerator_count=1,
    min_replica_count=1,
    max_replica_count=5,
)

# Make predictions
predictions = endpoint.predict(
    instances=[{'text': 'Sample input for prediction'}]
)

# Azure OpenAI - Using GPT models
from openai import AzureOpenAI

client = AzureOpenAI(
    api_key=os.environ['AZURE_OPENAI_KEY'],
    api_version='2024-02-01',
    azure_endpoint=os.environ['AZURE_OPENAI_ENDPOINT'],
)

# Chat completion
response = client.chat.completions.create(
    model='gpt-4',  # Deployment name
    messages=[
        {'role': 'system', 'content': 'You are a helpful assistant.'},
        {'role': 'user', 'content': 'Explain cloud computing in simple terms.'},
    ],
    temperature=0.7,
    max_tokens=500,
)

print(response.choices[0].message.content)

# Embeddings for RAG
embedding_response = client.embeddings.create(
    model='text-embedding-ada-002',
    input='Cloud computing is the delivery of computing services.',
)

embedding = embedding_response.data[0].embedding

| Service Type          | AWS              | Azure            | GCP              |
|----------------------|------------------|------------------|------------------|
| Compute (gen-purpose)| $0.0464/hr (m5)  | $0.046/hr (D2v3) | $0.0475/hr (n1)  |
| Spot/Preemptible     | 60-90% discount  | Up to 90%        | 60-91% discount  |
| Managed K8s Control  | $0.10/hr         | Free             | Free (Autopilot) |
| Object Storage (GB)  | $0.023           | $0.018           | $0.020           |
| Serverless (1M invoc)| $0.20            | $0.20            | $0.40            |
| Data Transfer (GB)   | $0.09            | $0.087           | $0.12            |
| Managed PostgreSQL   | $0.018/hr (db.t3)| $0.034/hr        | $0.017/hr        |

Note: Prices vary by region and are subject to change. All major providers offer:
- Free tier for new accounts
- Committed use discounts (1-3 year)
- Enterprise discount programs
- Spot/preemptible instances for non-critical workloads

# Terraform multi-cloud example
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
    google = {
      source  = "hashicorp/google"
      version = "~> 5.0"
    }
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "~> 3.0"
    }
  }
}

# Primary workloads on AWS
resource "aws_eks_cluster" "primary" {
  name     = "primary-cluster"
  role_arn = aws_iam_role.eks.arn
  version  = "1.28"

  vpc_config {
    subnet_ids = aws_subnet.eks[*].id
  }
}

# Analytics on GCP BigQuery
resource "google_bigquery_dataset" "analytics" {
  dataset_id  = "analytics"
  location    = "US"
  project     = var.gcp_project
}

# DR/Backup on Azure
resource "azurerm_recovery_services_vault" "backup" {
  name                = "backup-vault"
  location            = azurerm_resource_group.backup.location
  resource_group_name = azurerm_resource_group.backup.name
  sku                 = "Standard"
}