AWS Fargate vs. Google Cloud Run: Container Cost for Bursty Workloads

#!/usr/bin/env python3
"""
Bursty Workload Cost Benchmark: AWS Fargate vs Google Cloud Run
Version: 1.0.0
Author: Senior Engineer (15y exp)
Dependencies: boto3==1.34.12, google-cloud-run==0.9.0, requests==2.31.0, python-dotenv==1.0.0
Environment Variables Required:
  - AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_REGION (us-east-1)
  - GCP_PROJECT_ID, GCP_SERVICE_ACCOUNT_KEY (path to JSON key)
  - FARGATE_CLUSTER_ARN, CLOUD_RUN_SERVICE_NAME
"""
import os
import time
import json
import logging
from typing import Dict, List, Tuple
from dataclasses import dataclass
import requests
from dotenv import load_dotenv

# Configure logging
logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
logger = logging.getLogger(__name__)

# Load environment variables
load_dotenv()

@dataclass
class BenchmarkConfig:
    """Configuration for bursty workload benchmark"""
    baseline_rps: int = 50  # Baseline requests per second
    burst_multiplier: int = 10  # 10x burst spike
    burst_duration_sec: int = 300  # 5 minute burst
    cooldown_sec: int = 300  # 5 minute cooldown between bursts
    total_bursts: int = 6  # 6 bursts over 1 hour
    fargate_task_count: int = 2  # Initial Fargate task count
    cloud_run_min_instances: int = 0  # Cloud Run scale-to-zero

@dataclass
class RequestMetrics:
    """Metrics collected per request"""
    latency_ms: float
    status_code: int
    timestamp: float
    service: str

def send_burst_traffic(target_url: str, config: BenchmarkConfig) -> List[RequestMetrics]:
    """
    Send bursty traffic to target service using threaded requests.
    Args:
        target_url: HTTP endpoint of Fargate/Cloud Run service
        config: Benchmark configuration
    Returns:
        List of RequestMetrics for all requests
    """
    metrics: List[RequestMetrics] = []
    total_requests = (config.baseline_rps * (config.cooldown_sec * config.total_bursts)) + \
                    (config.baseline_rps * config.burst_multiplier * (config.burst_duration_sec * config.total_bursts))
    logger.info(f"Sending {total_requests} total requests to {target_url}")

    # Use requests session for connection pooling
    with requests.Session() as session:
        for burst_idx in range(config.total_bursts):
            # Cooldown period (baseline traffic)
            logger.info(f"Starting cooldown period {burst_idx + 1}/{config.total_bursts}")
            for _ in range(config.baseline_rps * config.cooldown_sec):
                start = time.time()
                try:
                    resp = session.get(target_url, timeout=10)
                    latency = (time.time() - start) * 1000
                    metrics.append(RequestMetrics(latency, resp.status_code, start, target_url))
                except Exception as e:
                    logger.error(f"Request failed: {e}")
                    metrics.append(RequestMetrics(-1, 0, start, target_url))
                time.sleep(1 / config.baseline_rps)  # Maintain RPS

            # Burst period
            logger.info(f"Starting burst period {burst_idx + 1}/{config.total_bursts}")
            burst_rps = config.baseline_rps * config.burst_multiplier
            for _ in range(burst_rps * config.burst_duration_sec):
                start = time.time()
                try:
                    resp = session.get(target_url, timeout=10)
                    latency = (time.time() - start) * 1000
                    metrics.append(RequestMetrics(latency, resp.status_code, start, target_url))
                except Exception as e:
                    logger.error(f"Burst request failed: {e}")
                    metrics.append(RequestMetrics(-1, 0, start, target_url))
                time.sleep(1 / burst_rps)  # Maintain burst RPS

    return metrics

def calculate_cost_fargate(config: BenchmarkConfig, task_vcpu: float = 1.0, task_memory_gb: float = 0.5) -> float:
    """
    Calculate total Fargate cost for benchmark duration.
    Fargate bills per second with 60-second minimum per task.
    Args:
        config: Benchmark config
        task_vcpu: vCPU allocated per Fargate task
        task_memory_gb: Memory allocated per Fargate task
    Returns:
        Total cost in USD
    """
    total_duration_sec = config.total_bursts * (config.cooldown_sec + config.burst_duration_sec)
    vcpu_cost_per_hour = 0.04048  # us-east-1 x86
    memory_cost_per_hour = 0.00449  # us-east-1 x86
    # Fargate minimum billing: 60 seconds per task, even if task runs less
    billable_seconds = max(total_duration_sec, 60) * config.fargate_task_count
    billable_hours = billable_seconds / 3600
    vcpu_cost = billable_hours * task_vcpu * vcpu_cost_per_hour * config.fargate_task_count
    memory_cost = billable_hours * task_memory_gb * memory_cost_per_hour * config.fargate_task_count
    return vcpu_cost + memory_cost

def calculate_cost_cloud_run(config: BenchmarkConfig, instance_vcpu: float = 1.0, instance_memory_gb: float = 0.5) -> float:
    """
    Calculate total Cloud Run cost for benchmark duration.
    Cloud Run bills per 100ms for active instances, scale-to-zero when idle.
    Args:
        config: Benchmark config
        instance_vcpu: vCPU per Cloud Run instance
        instance_memory_gb: Memory per Cloud Run instance
    Returns:
        Total cost in USD
    """
    vcpu_cost_per_hour = 0.036  # us-central1 x86
    memory_cost_per_gb_sec = 0.0000025  # us-central1 x86
    # Calculate billable instance seconds: only when instances are active (handling requests)
    # Assume 1 instance handles 50 RPS, so burst needs 10 instances, baseline 1
    baseline_instance_sec = config.total_bursts * config.cooldown_sec * 1  # 1 instance baseline
    burst_instance_sec = config.total_bursts * config.burst_duration_sec * 10  # 10 instances burst
    total_instance_sec = baseline_instance_sec + burst_instance_sec
    # Cloud Run bills per 100ms, so round up to nearest 100ms
    billable_sec = ((total_instance_sec * 10) + 1) // 10  # Round up to 100ms increments
    vcpu_cost = (billable_sec / 3600) * instance_vcpu * vcpu_cost_per_hour
    memory_cost = billable_sec * instance_memory_gb * memory_cost_per_gb_sec
    return vcpu_cost + memory_cost

if __name__ == "__main__":
    # Load config
    config = BenchmarkConfig()
    logger.info(f"Starting benchmark with config: {config}")

    # TODO: Replace with actual deployed service URLs
    fargate_url = os.getenv("FARGATE_SERVICE_URL", "http://fargate-service.example.com")
    cloud_run_url = os.getenv("CLOUD_RUN_SERVICE_URL", "https://cloud-run-service.example.com")

    # Run benchmarks
    logger.info("Benchmarking AWS Fargate...")
    fargate_metrics = send_burst_traffic(fargate_url, config)
    logger.info("Benchmarking Google Cloud Run...")
    cloud_run_metrics = send_burst_traffic(cloud_run_url, config)

    # Calculate costs
    fargate_cost = calculate_cost_fargate(config)
    cloud_run_cost = calculate_cost_cloud_run(config)

    # Output results
    logger.info(f"AWS Fargate Total Cost: ${fargate_cost:.2f}")
    logger.info(f"Google Cloud Run Total Cost: ${cloud_run_cost:.2f}")
    logger.info(f"Cost Savings with Cloud Run: {((fargate_cost - cloud_run_cost)/fargate_cost)*100:.1f}%")

# Terraform Configuration: Deploy Identical Container Workloads to Fargate and Cloud Run
# Version: 1.0.0
# Providers: AWS ~> 5.0, Google ~> 5.0, Random ~> 3.0
# Prerequisites: AWS CLI configured, GCP CLI configured, Terraform 1.7.0+

terraform {
  required_version = ">= 1.7.0"
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version ~> "5.0"
    }
    google = {
      source  = "hashicorp/google"
      version ~> "5.0"
    }
    random = {
      source  = "hashicorp/random"
      version ~> "3.0"
    }
  }
}

# Configure AWS Provider (us-east-1 for Fargate)
provider "aws" {
  region = "us-east-1"
}

# Configure Google Provider (us-central1 for Cloud Run)
provider "google" {
  project = var.gcp_project_id
  region  = "us-central1"
}

# Variables
variable "gcp_project_id" {
  type        = string
  description = "GCP Project ID"
  default     = "burst-benchmark-2024"
}

variable "container_image" {
  type        = string
  description = "Container image to deploy (same for both services)"
  default     = "nginx:1.25.3-alpine"  # Lightweight web server for benchmarking
}

variable "task_vcpu" {
  type        = number
  description = "vCPU per task/instance"
  default     = 1.0
}

variable "task_memory_gb" {
  type        = number
  description = "Memory per task/instance in GB"
  default     = 0.5
}

# Generate random suffix for resource names to avoid conflicts
resource "random_string" "suffix" {
  length  = 6
  special = false
  upper   = false
}

# --- AWS Fargate (ECS) Deployment ---
# Create ECS Cluster
resource "aws_ecs_cluster" "fargate_cluster" {
  name = "fargate-benchmark-cluster-${random_string.suffix.result}"
  setting {
    name  = "containerInsights"
    value = "enabled"
  }
}

# Create ECS Task Definition
resource "aws_ecs_task_definition" "fargate_task" {
  family                   = "fargate-benchmark-task-${random_string.suffix.result}"
  network_mode             = "awsvpc"
  requires_compatibilities = ["FARGATE"]
  cpu                      = var.task_vcpu * 1024  # Fargate CPU is in units of 1024 per vCPU
  memory                   = var.task_memory_gb * 1024  # Fargate memory is in MB

  container_definitions = jsonencode([{
    name      = "benchmark-container"
    image     = var.container_image
    essential = true
    portMappings = [{
      containerPort = 80
      hostPort      = 80
      protocol      = "tcp"
    }]
    logConfiguration = {
      logDriver = "awslogs"
      options = {
        "awslogs-group"         = aws_cloudwatch_log_group.fargate_logs.name
        "awslogs-region"        = "us-east-1"
        "awslogs-stream-prefix" = "ecs"
      }
    }
  }])
}

# CloudWatch Log Group for Fargate
resource "aws_cloudwatch_log_group" "fargate_logs" {
  name              = "/ecs/fargate-benchmark-${random_string.suffix.result}"
  retention_in_days = 7
}

# Security Group for Fargate Tasks
resource "aws_security_group" "fargate_sg" {
  name        = "fargate-benchmark-sg-${random_string.suffix.result}"
  description = "Allow HTTP inbound traffic for Fargate tasks"
  vpc_id      = aws_vpc.benchmark_vpc.id

  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

# VPC for Fargate (Simplified: Single public subnet)
resource "aws_vpc" "benchmark_vpc" {
  cidr_block = "10.0.0.0/16"
  tags = {
    Name = "fargate-benchmark-vpc-${random_string.suffix.result}"
  }
}

resource "aws_subnet" "public_subnet" {
  vpc_id                  = aws_vpc.benchmark_vpc.id
  cidr_block              = "10.0.1.0/24"
  map_public_ip_on_launch = true
  availability_zone       = "us-east-1a"
  tags = {
    Name = "fargate-public-subnet-${random_string.suffix.result}"
  }
}

resource "aws_internet_gateway" "igw" {
  vpc_id = aws_vpc.benchmark_vpc.id
  tags = {
    Name = "fargate-igw-${random_string.suffix.result}"
  }
}

resource "aws_route_table" "public_rt" {
  vpc_id = aws_vpc.benchmark_vpc.id
  route {
    cidr_block = "0.0.0.0/0"
    gateway_id = aws_internet_gateway.igw.id
  }
}

resource "aws_route_table_association" "public_rta" {
  subnet_id      = aws_subnet.public_subnet.id
  route_table_id = aws_route_table.public_rt.id
}

# ECS Fargate Service (Minimum 1 task, no auto-scaling for baseline benchmark)
resource "aws_ecs_service" "fargate_service" {
  name            = "fargate-benchmark-service-${random_string.suffix.result}"
  cluster         = aws_ecs_cluster.fargate_cluster.id
  task_definition = aws_ecs_task_definition.fargate_task.arn
  desired_count   = 1  # Minimum 1 task for Fargate baseline
  launch_type     = "FARGATE"

  network_configuration {
    subnets          = [aws_subnet.public_subnet.id]
    security_groups  = [aws_security_group.fargate_sg.id]
    assign_public_ip = true
  }

  lifecycle {
    ignore_changes = [desired_count]  # Allow manual scaling during benchmark
  }
}

# --- Google Cloud Run Deployment ---
# Cloud Run Service (Scale to zero, min-instances=0)
resource "google_cloud_run_service" "cloud_run_service" {
  name     = "cloud-run-benchmark-${random_string.suffix.result}"
  location = "us-central1"

  template {
    spec {
      containers {
        image = var.container_image
        ports {
          container_port = 80
        }
        resources {
          limits = {
            cpu    = "${var.task_vcpu}"  # Cloud Run uses vCPU directly
            memory = "${var.task_memory_gb}Gi"
          }
        }
      }
      min_instances = 0  # Scale to zero when idle
      max_instances = 10  # Match burst capacity of Fargate
    }
  }

  traffic {
    percent         = 100
    latest_revision = true
  }
}

# Make Cloud Run service publicly accessible (no auth for benchmark)
resource "google_cloud_run_service_iam_member" "public_access" {
  service  = google_cloud_run_service.cloud_run_service.name
  location = google_cloud_run_service.cloud_run_service.location
  role     = "roles/run.invoker"
  member   = "allUsers"
}

# Outputs
output "fargate_service_public_ip" {
  value = aws_ecs_service.fargate_service.network_configuration[0].assign_public_ip ? "Check ECS task ENI for public IP" : ""
}

output "cloud_run_service_url" {
  value = google_cloud_run_service.cloud_run_service.status[0].url
}

// Cost Analyzer: Process Benchmark Metrics and Generate Detailed Cost Reports
// Version: 1.0.0
// Go Version: 1.22+
// Dependencies: github.com/aws/aws-sdk-go-v2 v1.25.0, cloud.google.com/go/monitoring v1.17.0, gopkg.in/yaml.v3 v3.0.1
package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"
    "os"
    "time"

    "github.com/aws/aws-sdk-go-v2/aws"
    "github.com/aws/aws-sdk-go-v2/config"
    "github.com/aws/aws-sdk-go-v2/service/cloudwatch"
    "github.com/aws/aws-sdk-go-v2/service/cloudwatch/types"
    monitoring "cloud.google.com/go/monitoring/apiv3/v2"
    "cloud.google.com/go/monitoring/apiv3/v2/monitoringpb"
    "google.golang.org/api/iterator"
    "gopkg.in/yaml.v3"
)

// Config holds cost analyzer configuration
type Config struct {
    AWSService   string `yaml:"aws_service"`   // "fargate" or "ecs"
    GCPService   string `yaml:"gcp_service"`   // "cloud_run"
    AWSRegion    string `yaml:"aws_region"`    // us-east-1
    GCPRegion    string `yaml:"gcp_region"`    // us-central1
    GCPProjectID string `yaml:"gcp_project_id"`
    TimeRange    struct {
        Start time.Time `yaml:"start"`
        End   time.Time `yaml:"end"`
    } `yaml:"time_range"`
}

// CostBreakdown holds per-service cost details
type CostBreakdown struct {
    ServiceName     string  `json:"service_name"`
    TotalCostUSD    float64 `json:"total_cost_usd"`
    VCpuCostUSD     float64 `json:"vcpu_cost_usd"`
    MemoryCostUSD   float64 `json:"memory_cost_usd"`
    RequestCount    int     `json:"request_count"`
    AvgLatencyMs    float64 `json:"avg_latency_ms"`
    P99LatencyMs    float64 `json:"p99_latency_ms"`
}

func main() {
    // Load configuration from config.yaml
    cfg, err := loadConfig("config.yaml")
    if err != nil {
        log.Fatalf("Failed to load config: %v", err)
    }

    // Initialize AWS CloudWatch client
    awsCfg, err := config.LoadDefaultConfig(context.TODO(), config.WithRegion(cfg.AWSRegion))
    if err != nil {
        log.Fatalf("Failed to load AWS config: %v", err)
    }
    cwClient := cloudwatch.NewFromConfig(awsCfg)

    // Initialize GCP Monitoring client
    ctx := context.Background()
    gcpClient, err := monitoring.NewMetricClient(ctx)
    if err != nil {
        log.Fatalf("Failed to create GCP monitoring client: %v", err)
    }
    defer gcpClient.Close()

    // Analyze Fargate costs
    fargateBreakdown, err := analyzeFargate(ctx, cwClient, cfg)
    if err != nil {
        log.Printf("Warning: Failed to analyze Fargate costs: %v", err)
        fargateBreakdown = CostBreakdown{ServiceName: "AWS Fargate"}
    }

    // Analyze Cloud Run costs
    cloudRunBreakdown, err := analyzeCloudRun(ctx, gcpClient, cfg)
    if err != nil {
        log.Printf("Warning: Failed to analyze Cloud Run costs: %v", err)
        cloudRunBreakdown = CostBreakdown{ServiceName: "Google Cloud Run"}
    }

    // Output report as JSON
    report := []CostBreakdown{fargateBreakdown, cloudRunBreakdown}
    reportJSON, err := json.MarshalIndent(report, "", "  ")
    if err != nil {
        log.Fatalf("Failed to marshal report: %v", err)
    }
    fmt.Println(string(reportJSON))
}

// loadConfig reads and parses config.yaml
func loadConfig(path string) (Config, error) {
    var cfg Config
    data, err := os.ReadFile(path)
    if err != nil {
        return cfg, fmt.Errorf("read config file: %w", err)
    }
    if err := yaml.Unmarshal(data, &cfg); err != nil {
        return cfg, fmt.Errorf("parse config YAML: %w", err)
    }
    return cfg, nil
}

// analyzeFargate retrieves Fargate metrics from CloudWatch and calculates cost
func analyzeFargate(ctx context.Context, client *cloudwatch.Client, cfg Config) (CostBreakdown, error) {
    var breakdown CostBreakdown
    breakdown.ServiceName = "AWS Fargate"

    // Fetch CPU utilization metrics from CloudWatch
    cpuInput := &cloudwatch.GetMetricDataInput{
        MetricDataQueries: []types.MetricDataQuery{
            {
                Id: aws.String("cpu_util"),
                MetricStat: &types.MetricStat{
                    Metric: &types.Metric{
                        Namespace:  aws.String("AWS/ECS"),
                        MetricName: aws.String("CPUUtilization"),
                        Dimensions: []types.Dimension{
                            {Name: aws.String("ClusterName"), Value: aws.String("fargate-benchmark-cluster")},
                            {Name: aws.String("ServiceName"), Value: aws.String("fargate-benchmark-service")},
                        },
                    },
                    Period: aws.Int32(300), // 5-minute periods
                    Stat:   aws.String("Average"),
                },
                ReturnData: aws.Bool(true),
            },
        },
        StartTime: &cfg.TimeRange.Start,
        EndTime:   &cfg.TimeRange.End,
    }

    cpuOutput, err := client.GetMetricData(ctx, cpuInput)
    if err != nil {
        return breakdown, fmt.Errorf("get CPU metrics: %w", err)
    }

    // Calculate CPU cost: average vCPU used * $0.04048 per hour * duration in hours
    var totalCpuSeconds float64
    for _, result := range cpuOutput.MetricDataResults {
        for _, dp := range result.Values {
            totalCpuSeconds += dp * 300 // Average CPU % * 300 seconds per period
        }
    }
    avgVcpu := (totalCpuSeconds / 100) / cfg.TimeRange.End.Sub(cfg.TimeRange.Start).Seconds() // Convert % to vCPU
    breakdown.VCpuCostUSD = avgVcpu * 0.04048 * cfg.TimeRange.End.Sub(cfg.TimeRange.Start).Hours()

    // Memory cost: similar logic, using MemoryUtilization metric
    memInput := &cloudwatch.GetMetricDataInput{
        MetricDataQueries: []types.MetricDataQuery{
            {
                Id: aws.String("mem_util"),
                MetricStat: &types.MetricStat{
                    Metric: &types.Metric{
                        Namespace:  aws.String("AWS/ECS"),
                        MetricName: aws.String("MemoryUtilization"),
                        Dimensions: []types.Dimension{
                            {Name: aws.String("ClusterName"), Value: aws.String("fargate-benchmark-cluster")},
                            {Name: aws.String("ServiceName"), Value: aws.String("fargate-benchmark-service")},
                        },
                    },
                    Period: aws.Int32(300),
                    Stat:   aws.String("Average"),
                },
            },
        },
        StartTime: &cfg.TimeRange.Start,
        EndTime:   &cfg.TimeRange.End,
    }

    memOutput, err := client.GetMetricData(ctx, memInput)
    if err != nil {
        return breakdown, fmt.Errorf("get memory metrics: %w", err)
    }

    var totalMemSeconds float64
    for _, result := range memOutput.MetricDataResults {
        for _, dp := range result.Values {
            totalMemSeconds += dp * 300
        }
    }
    avgMemGb := (totalMemSeconds / 100) * 0.5 / cfg.TimeRange.End.Sub(cfg.TimeRange.Start).Seconds() // 0.5GB per task
    breakdown.MemoryCostUSD = avgMemGb * 0.00449 * cfg.TimeRange.End.Sub(cfg.TimeRange.Start).Hours()
    breakdown.TotalCostUSD = breakdown.VCpuCostUSD + breakdown.MemoryCostUSD

    return breakdown, nil
}

// analyzeCloudRun retrieves Cloud Run metrics from GCP Monitoring and calculates cost
func analyzeCloudRun(ctx context.Context, client *monitoring.MetricClient, cfg Config) (CostBreakdown, error) {
    var breakdown CostBreakdown
    breakdown.ServiceName = "Google Cloud Run"

    // Fetch request count metrics
    reqCountReq := &monitoringpb.ListTimeSeriesRequest{
        Name:   fmt.Sprintf("projects/%s", cfg.GCPProjectID),
        Filter: `metric.type="run.googleapis.com/request_count" AND resource.type="cloud_run_revision"`,
        Interval: &monitoringpb.TimeInterval{
            StartTime: &monitoringpb.TimeInterval_StartTime{&monitoringpb.TimeInterval_StartTime{Seconds: cfg.TimeRange.Start.Unix()}},
            EndTime:   &monitoringpb.TimeInterval_EndTime{&monitoringpb.TimeInterval_EndTime{Seconds: cfg.TimeRange.End.Unix()}},
        },
    }

    reqCountIter := client.ListTimeSeries(ctx, reqCountReq)
    for {
        resp, err := reqCountIter.Next()
        if err == iterator.Done {
            break
        }
        if err != nil {
            return breakdown, fmt.Errorf("get request count: %w", err)
        }
        for _, dp := range resp.Points {
            breakdown.RequestCount += int(dp.Value.GetInt64Value())
        }
    }

    // Calculate cost: vCPU and memory billed per 100ms
    // Assume 1 vCPU per instance, 0.5GB memory, $0.036/vCPU-hour, $0.0000025/GB-sec
    totalInstanceSeconds := float64(breakdown.RequestCount) / 50 // Assume 50 RPS per instance
    billable100ms := (totalInstanceSeconds * 10) + 1            // Round up to nearest 100ms
    breakdown.VCpuCostUSD = (billable100ms / 36000) * 1 * 0.036 // 36000 100ms increments per hour
    breakdown.MemoryCostUSD = billable100ms * 0.5 * 0.0000025
    breakdown.TotalCostUSD = breakdown.VCpuCostUSD + breakdown.MemoryCostUSD

    return breakdown, nil
}

aws ecs list-tasks --cluster fargate-benchmark-cluster --service-name fargate-benchmark-service --query "taskArns[*]" --output text | xargs -I {} aws ecs describe-tasks --cluster fargate-benchmark-cluster --tasks {} --query "tasks[?startedAt < '2024-07-01'][taskArn, startedAt, stoppedAt]" --output table

gcloud run services update cloud-run-benchmark --min-instances=2 --max-instances=20 --region=us-central1

git clone https://github.com/cloud-benchmarks/burst-benchmarks.git
cd burst-benchmarks
cp config.example.yaml config.yaml
# Edit config.yaml with your AWS/GCP credentials
terraform init && terraform apply
python benchmark.py