AWS Lambda vs Google Cloud Run vs Azure Container Instances

# Lambda container runtime
FROM public.ecr.aws/lambda/python:3.9

# Copy function code
COPY app.py ${LAMBDA_TASK_ROOT}

# Install dependencies
COPY requirements.txt .
RUN pip install -r requirements.txt --target "${LAMBDA_TASK_ROOT}"

# Set the CMD to your handler
CMD [ "app.lambda_handler" ]

# Lambda function handler
import json
import boto3
from typing import Dict, Any

def lambda_handler(event: Dict[str, Any], context) -> Dict[str, Any]:
    """
    Lambda function handler supporting both API Gateway and direct invocation
    """
    # Parse input
    if 'body' in event:
        # API Gateway event
        body = json.loads(event['body']) if event['body'] else {}
        headers = event.get('headers', {})
    else:
        # Direct invocation
        body = event
        headers = {}
    
    # Business logic
    result = process_request(body)
    
    # Return response
    return {
        'statusCode': 200,
        'headers': {
            'Content-Type': 'application/json',
            'Access-Control-Allow-Origin': '*'
        },
        'body': json.dumps(result)
    }

def process_request(data: Dict[str, Any]) -> Dict[str, Any]:
    """Process the actual request"""
    # Example: Data processing pipeline
    s3 = boto3.client('s3')
    dynamodb = boto3.resource('dynamodb')
    
    # Process data and return result
    return {
        'message': 'Processing complete',
        'timestamp': context.aws_request_id
    }

# Cloud Run optimized container
FROM gcr.io/distroless/python3-debian11

# Set environment variables
ENV PYTHONUNBUFFERED True
ENV PORT 8080

# Copy application code
COPY --from=builder /app /app
WORKDIR /app

# Run the web service on container startup
CMD exec gunicorn --bind :$PORT --workers 1 --threads 8 --timeout 0 main:app

# Cloud Run Flask application
import os
import logging
from flask import Flask, request, jsonify
from google.cloud import firestore, storage
import functions_framework

app = Flask(__name__)

# Initialize Google Cloud clients
db = firestore.Client()
storage_client = storage.Client()

@app.route('/', methods=['GET', 'POST'])
def handle_request():
    """Handle HTTP requests"""
    try:
        if request.method == 'POST':
            data = request.get_json()
            result = process_data(data)
            return jsonify(result), 200
        else:
            return jsonify({'status': 'healthy', 'service': 'cloud-run-app'}), 200
    
    except Exception as e:
        logging.error(f"Error processing request: {str(e)}")
        return jsonify({'error': 'Internal server error'}), 500

def process_data(data):
    """Process incoming data"""
    # Store in Firestore
    doc_ref = db.collection('requests').document()
    doc_ref.set({
        'data': data,
        'timestamp': firestore.SERVER_TIMESTAMP,
        'processed': True
    })
    
    return {'id': doc_ref.id, 'status': 'processed'}

if __name__ == '__main__':
    port = int(os.environ.get('PORT', 8080))
    app.run(debug=True, host='0.0.0.0', port=port)

# Azure Container Instance deployment
apiVersion: 2021-03-01
location: eastus
name: myapp-container-group
properties:
  containers:
  - name: web-app
    properties:
      image: myregistry.azurecr.io/myapp:latest
      resources:
        requests:
          cpu: 1.0
          memoryInGb: 2.0
      ports:
      - protocol: tcp
        port: 80
      environmentVariables:
      - name: DATABASE_URL
        secureValue: postgresql://user:pass@host:5432/db
  - name: sidecar-logger
    properties:
      image: fluent/fluent-bit:latest
      resources:
        requests:
          cpu: 0.1
          memoryInGb: 0.5
      volumeMounts:
      - name: logs
        mountPath: /var/log
  restartPolicy: Always
  osType: Linux
  ipAddress:
    type: Public
    ports:
    - protocol: tcp
      port: 80
    dnsNameLabel: myapp-unique-dns
  volumes:
  - name: logs
    emptyDir: {}

# Performance monitoring example
import time
import psutil
import json
from datetime import datetime

def monitor_performance(func):
    """Decorator to monitor function performance"""
    def wrapper(*args, **kwargs):
        start_time = time.time()
        start_memory = psutil.Process().memory_info().rss / 1024 / 1024
        
        # Execute function
        result = func(*args, **kwargs)
        
        end_time = time.time()
        end_memory = psutil.Process().memory_info().rss / 1024 / 1024
        
        metrics = {
            'execution_time': end_time - start_time,
            'memory_used': end_memory - start_memory,
            'peak_memory': end_memory,
            'timestamp': datetime.utcnow().isoformat()
        }
        
        # Log metrics (different per platform)
        log_metrics(metrics)
        
        return result
    return wrapper

def log_metrics(metrics):
    """Platform-specific metric logging"""
    import os
    platform = os.environ.get('CLOUD_PLATFORM', 'unknown')
    
    if platform == 'aws':
        # CloudWatch custom metrics
        import boto3
        cloudwatch = boto3.client('cloudwatch')
        cloudwatch.put_metric_data(
            Namespace='ServerlessApp',
            MetricData=[
                {
                    'MetricName': 'ExecutionTime',
                    'Value': metrics['execution_time'],
                    'Unit': 'Seconds'
                },
                {
                    'MetricName': 'MemoryUsed',
                    'Value': metrics['memory_used'],
                    'Unit': 'Megabytes'
                }
            ]
        )
    elif platform == 'gcp':
        # Cloud Monitoring
        from google.cloud import monitoring_v3
        client = monitoring_v3.MetricServiceClient()
        # Send metrics to Cloud Monitoring
    elif platform == 'azure':
        # Application Insights
        from applicationinsights import TelemetryClient
        tc = TelemetryClient(os.environ.get('APPINSIGHTS_INSTRUMENTATIONKEY'))
        tc.track_metric('ExecutionTime', metrics['execution_time'])

# Cost calculation examples
def calculate_monthly_costs():
    """Calculate estimated monthly costs for different scenarios"""
    
    scenarios = {
        'low_traffic': {
            'requests_per_month': 100000,
            'avg_duration_ms': 200,
            'memory_mb': 128
        },
        'medium_traffic': {
            'requests_per_month': 1000000,
            'avg_duration_ms': 500,
            'memory_mb': 512
        },
        'high_traffic': {
            'requests_per_month': 10000000,
            'avg_duration_ms': 1000,
            'memory_mb': 1024
        }
    }
    
    for scenario_name, config in scenarios.items():
        print(f"\n{scenario_name.upper()} SCENARIO:")
        print(f"Requests: {config['requests_per_month']:,}")
        print(f"Duration: {config['avg_duration_ms']}ms")
        print(f"Memory: {config['memory_mb']}MB")
        print("---")
        
        # AWS Lambda costs
        lambda_cost = calculate_lambda_cost(config)
        print(f"AWS Lambda: ${lambda_cost:.2f}")
        
        # Cloud Run costs
        cloud_run_cost = calculate_cloud_run_cost(config)
        print(f"Cloud Run: ${cloud_run_cost:.2f}")
        
        # Azure ACI costs (assuming always-on for comparison)
        aci_cost = calculate_aci_cost(config)
        print(f"Azure ACI: ${aci_cost:.2f}")

def calculate_lambda_cost(config):
    requests = config['requests_per_month']
    duration_sec = config['avg_duration_ms'] / 1000
    memory_gb = config['memory_mb'] / 1024
    
    request_cost = (requests / 1000000) * 0.20
    compute_cost = requests * duration_sec * memory_gb * 0.0000166667
    
    return request_cost + compute_cost

def calculate_cloud_run_cost(config):
    requests = config['requests_per_month']
    duration_sec = config['avg_duration_ms'] / 1000
    vcpu = 1  # 1 vCPU
    memory_gb = config['memory_mb'] / 1024
    
    request_cost = (requests / 1000000) * 0.40
    cpu_cost = requests * duration_sec * vcpu * 0.000024
    memory_cost = requests * duration_sec * memory_gb * 0.0000025
    
    return request_cost + cpu_cost + memory_cost

def calculate_aci_cost(config):
    # Assuming container runs continuously for comparison
    hours_per_month = 730
    vcpu = 1
    memory_gb = config['memory_mb'] / 1024
    
    cpu_cost = hours_per_month * 3600 * vcpu * 0.0012 / 3600  # per vCPU-second
    memory_cost = hours_per_month * 3600 * memory_gb * 0.00013 / 3600
    
    return cpu_cost + memory_cost

# SAM template for Lambda + API Gateway
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31

Resources:
  MyApi:
    Type: AWS::Serverless::Api
    Properties:
      StageName: prod
      Cors:
        AllowMethods: "'GET,POST,PUT,DELETE'"
        AllowHeaders: "'Content-Type,X-Amz-Date,Authorization'"
        AllowOrigin: "'*'"
      Auth:
        DefaultAuthorizer: MyCognitoAuthorizer
        Authorizers:
          MyCognitoAuthorizer:
            UserPoolArn: !GetAtt MyCognitoUserPool.Arn

  MyFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: src/
      Handler: app.lambda_handler
      Runtime: python3.9
      Environment:
        Variables:
          TABLE_NAME: !Ref MyTable
      Events:
        ApiEvent:
          Type: Api
          Properties:
            RestApiId: !Ref MyApi
            Path: /users/{id}
            Method: get

# Cloud Run service with custom domain
apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  name: myapp
  annotations:
    run.googleapis.com/ingress: all
    run.googleapis.com/cpu-throttling: "false"
spec:
  template:
    metadata:
      annotations:
        autoscaling.knative.dev/maxScale: "100"
        autoscaling.knative.dev/minScale: "0"
        run.googleapis.com/execution-environment: gen2
    spec:
      containerConcurrency: 80
      timeoutSeconds: 300
      containers:
      - image: gcr.io/project/myapp:latest
        ports:
        - containerPort: 8080
        env:
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: db-credentials
              key: url
        resources:
          limits:
            cpu: 2000m
            memory: 4Gi
          requests:
            cpu: 1000m
            memory: 2Gi

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "resources": [
    {
      "type": "Microsoft.ContainerInstance/containerGroups",
      "apiVersion": "2021-03-01",
      "name": "myapp-container-group",
      "location": "[resourceGroup().location]",
      "properties": {
        "containers": [
          {
            "name": "web-app",
            "properties": {
              "image": "myregistry.azurecr.io/myapp:latest",
              "resources": {
                "requests": {
                  "cpu": 1,
                  "memoryInGb": 2
                }
              },
              "ports": [
                {
                  "protocol": "TCP",
                  "port": 80
                }
              ],
              "environmentVariables": [
                {
                  "name": "ASPNETCORE_ENVIRONMENT",
                  "value": "Production"
                }
              ]
            }
          }
        ],
        "osType": "Linux",
        "ipAddress": {
          "type": "Private",
          "ports": [
            {
              "protocol": "TCP",
              "port": 80
            }
          ]
        },
        "restartPolicy": "Always"
      }
    }
  ]
}

# AWS Lambda with IAM
import boto3
import json
from botocore.exceptions import ClientError

def lambda_handler(event, context):
    """Lambda with fine-grained IAM permissions"""
    try:
        # Get caller identity
        sts = boto3.client('sts')
        identity = sts.get_caller_identity()
        
        # Access DynamoDB with IAM role
        dynamodb = boto3.resource('dynamodb')
        table = dynamodb.Table('UserData')
        
        # Query with IAM permissions
        response = table.get_item(
            Key={'user_id': event['user_id']}
        )
        
        return {
            'statusCode': 200,
            'body': json.dumps(response.get('Item', {}))
        }
        
    except ClientError as e:
        return {
            'statusCode': 403,
            'body': json.dumps({'error': 'Access denied'})
        }

# Cloud Run with service account
import os
from google.auth import default
from google.cloud import firestore
from flask import Flask, request, jsonify

app = Flask(__name__)

# Initialize with service account
credentials, project = default()
db = firestore.Client(credentials=credentials, project=project)

@app.route('/users/<user_id>')
def get_user(user_id):
    """Access Firestore with service account permissions"""
    try:
        doc_ref = db.collection('users').document(user_id)
        doc = doc_ref.get()
        
        if doc.exists:
            return jsonify(doc.to_dict())
        else:
            return jsonify({'error': 'User not found'}), 404
            
    except Exception as e:
        return jsonify({'error': 'Access denied'}), 403

# .github/workflows/lambda-deploy.yml
name: Deploy Lambda Function
on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    
    - name: Configure AWS credentials
      uses: aws-actions/configure-aws-credentials@v2
      with:
        aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
        aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
        aws-region: us-east-1
    
    - name: Build and deploy
      run: |
        pip install -r requirements.txt -t .
        zip -r function.zip .
        aws lambda update-function-code \
          --function-name MyFunction \
          --zip-file fileb://function.zip
    
    - name: Run tests
      run: |
        aws lambda invoke \
          --function-name MyFunction \
          --payload '{"test": true}' \
          response.json

# cloudbuild.yaml
steps:
# Build container image
- name: 'gcr.io/cloud-builders/docker'
  args: ['build', '-t', 'gcr.io/$PROJECT_ID/myapp:$COMMIT_SHA', '.']

# Push to Container Registry
- name: 'gcr.io/cloud-builders/docker'
  args: ['push', 'gcr.io/$PROJECT_ID/myapp:$COMMIT_SHA']

# Deploy to Cloud Run
- name: 'gcr.io/google.com/cloudsdktool/cloud-sdk'
  entrypoint: gcloud
  args:
  - 'run'
  - 'deploy'
  - 'myapp'
  - '--image=gcr.io/$PROJECT_ID/myapp:$COMMIT_SHA'
  - '--region=us-central1'
  - '--platform=managed'
  - '--allow-unauthenticated'

# Run integration tests
- name: 'gcr.io/cloud-builders/curl'
  args: ['https://myapp-xxxxx-uc.a.run.app/health']

# azure-pipelines.yml
trigger:
- main

pool:
  vmImage: 'ubuntu-latest'

variables:
  containerRegistry: 'myregistry.azurecr.io'
  imageName: 'myapp'
  resourceGroup: 'production-rg'

stages:
- stage: Build
  jobs:
  - job: BuildImage
    steps:
    - task: Docker@2
      inputs:
        containerRegistry: 'MyACR'
        repository: $(imageName)
        command: 'buildAndPush'
        Dockerfile: '**/Dockerfile'
        tags: |
          $(Build.BuildId)
          latest

- stage: Deploy
  jobs:
  - deployment: DeployACI
    environment: 'production'
    strategy:
      runOnce:
        deploy:
          steps:
          - task: AzureCLI@2
            inputs:
              azureSubscription: 'MySubscription'
              scriptType: 'bash'
              scriptLocation: 'inlineScript'
              inlineScript: |
                az container create \
                  --resource-group $(resourceGroup) \
                  --name myapp-$(Build.BuildId) \
                  --image $(containerRegistry)/$(imageName):$(Build.BuildId) \
                  --cpu 1 --memory 2 \
                  --restart-policy Always

# Order processing microservice
def process_order(event, context):
    """Process order events from SQS"""
    for record in event['Records']:
        order_data = json.loads(record['body'])
        
        # Validate order
        if validate_order(order_data):
            # Process payment
            payment_result = process_payment(order_data)
            
            # Update inventory
            update_inventory(order_data['items'])
            
            # Send confirmation
            send_confirmation(order_data['customer_email'])
    
    return {'statusCode': 200}

# User management microservice
@app.route('/users', methods=['POST'])
def create_user():
    """Create new user account"""
    data = request.get_json()
    
    # Validate input
    if not validate_user_data(data):
        return jsonify({'error': 'Invalid data'}), 400
    
    # Create user in database
    user_id = create_user_account(data)
    
    # Send welcome email
    send_welcome_email(data['email'])
    
    return jsonify({'user_id': user_id}), 201

# Data processing batch job
import time
import logging
from azure.storage.blob import BlobServiceClient

def process_data_batch():
    """Process large data files in batch"""
    blob_client = BlobServiceClient.from_connection_string(
        os.environ['STORAGE_CONNECTION_STRING']
    )
    
    # Download data files
    files = download_batch_files(blob_client)
    
    # Process each file
    for file_path in files:
        process_file(file_path)
        
    # Upload results
    upload_results(blob_client)
    
    logging.info("Batch processing completed")

if __name__ == '__main__':
    process_data_batch()