Cloud Cost Optimization: Strategies for Reducing Cloud Spend in 2025

# Cloud pricing models comparison
pricing_models:
  on_demand:
    description: "Pay per hour/second, no commitment"
    use_case: "Variable workloads, testing"
    price: "1x baseline"
    
  reserved:
    description: "1-3 year commitment"
    savings: "40-72% off on-demand"
    use_case: "Predictable baseline workloads"
    
  spot_preemptible:
    description: "Bid for unused capacity"
    savings: "60-90% off on-demand"
    use_case: "Batch jobs, fault-tolerant workloads"
    
  savings_plans:
    description: "Flexible commitment (compute or savings)"
    savings: "17-72% off on-demand"
    use_case: "Variable but predictable usage"

# Example: Right-sizing analysis
class CloudRightsizer:
    def __init__(self, provider):
        self.provider = provider
        self.metrics = self.get_metrics()
    
    def analyze_instance(self, instance_id):
        """Analyze if instance is properly sized"""
        cpu_util = self.metrics[instance_id]['cpu_util']
        mem_util = self.metrics[instance_id]['mem_util']
        
        # Recommendations based on utilization
        if cpu_util < 20 and mem_util < 20:
            return {
                'action': 'downsize',
                'current': 't3.large',
                'recommended': 't3.small',
                'savings_monthly': '$45'
            }
        elif cpu_util > 80:
            return {
                'action': 'upsize',
                'current': 't3.small',
                'recommended': 't3.medium',
                'risk': 'performance_degradation'
            }
        return {'action': 'keep', 'current_size': 'optimal'}

# AWS Compute Optimizer recommendations
aws compute-optimizer get-recommendations \
  --resource-type EC2_INSTANCE \
  --resource-arns arn:aws:ec2:us-east-1:123456789:instance/i-1234567890

// Output example
{
  "recommendations": [
    {
      "resourceArn": "arn:aws:ec2:us-east-1:123456789:instance/i-1234567890",
      "accountId": "123456789",
      "instanceName": "web-server-prod",
      "currentInstanceType": "t3.large",
      "currentVCpus": 2,
      "currentMemory": 8,
      "recommendation": {
        "instanceType": "t3.medium",
        "vcpus": 2,
        "memory": 4,
        "monthlySavings": 45.00
      }
    }
  ]
}

# Azure Advisor recommendations
Get-AzAdvisorRecommendation -Category Cost | 
  Where-Object { $_.Action -eq "Resize" }

# GCP recommender API
gcloud recommender recommendations list \
  --recommender=google.compute.instance.RightSizingRecommender \
  --project=my-project \
  --location=us-central1

# Reserved Instance comparison
aws_reserved_instances:
  standard:
    commitment: "1 or 3 years"
    upfront: "Partial or All"
    savings: "40-60%"
    flexibility: "AZ-specific"
    
  convertible:
    commitment: "1 or 3 years"
    upfront: "Partial or All"
    savings: "30-45%"
    flexibility: "Can exchange for other types"
    
  scheduled:
    commitment: "1 year"
    savings: "5-10%"
    flexibility: "Specific time windows only"

# Reservation analysis
def should_reserve(instance_type, usage_hours_per_month, on_demand_price):
    """Calculate if reservation makes sense"""
    
    annual_od_cost = on_demand_price * usage_hours_per_month * 12
    
    # 1-year reserved (assume 50% savings)
    reserved_cost = annual_od_cost * 0.50
    
    # Break-even point
    if usage_hours_per_month >= 200:  # ~67% utilization
        return {
            'reserve': True,
            'savings': annual_od_cost - reserved_cost,
            'payback_months': 3
        }
    
    return {'reserve': False, 'reason': 'low_utilization'}

# Terraform: Reserved Instance
resource "aws_ec2_reserved_instance" "example" {
  instance_type    = "t3.large"
  availability_zone = "us-east-1a"
  instance_count   = 3
  duration_unit    = "years"
  duration         = 1
  offering_type    = "Partial Upfront"
  product_description = "Linux/UNIX"

  tags = {
    Name = "prod-web-servers-ri"
  }
}

# Ideal workloads for spot
spot_workloads:
  - name: "Batch processing jobs"
    tolerance: "Can restart if interrupted"
    examples: ["ETL jobs", "data pipeline", "analytics"]
    
  - name: "CI/CD runners"
    tolerance: "Retries available"
    examples: ["GitHub Actions", "Jenkins", "GitLab CI"]
    
  - name: "Stateless applications"
    tolerance: "No persistent state"
    examples: ["Web servers", "API gateways"]
    
  - name: "Machine learning training"
    tolerance: "Checkpoint-based"
    examples: ["Model training", "hyperparameter tuning"]

# Example: Spot instance handler
class SpotInstanceHandler:
    def __init__(self):
        self.interruption_count = 0
    
    def handle_interruption(self, instance_id):
        """Handle spot instance interruption"""
        self.interruption_count += 1
        
        # Graceful shutdown
        self.save_checkpoint(instance_id)
        self.drain_connections(instance_id)
        
        # Notify orchestration
        self.kubernetes.deploy_pod_to_new_node()
        
        return {
            'action': 'graceful_shutdown',
            'checkpoint_saved': True,
            'new_instance_requested': True
        }

# Spot Fleet Request
SpotFleetRequestConfig:
  IamFleetRole: arn:aws:iam::123456789:role/fleet-role
  TargetCapacity: 10
  SpotPrice: "0.05"
  
  LaunchSpecifications:
    - InstanceType: t3.large
      ImageId: ami-0c55b159cbfafe1f0
      SubnetId: subnet-12345678
      WeightedCapacity: 1
      
    - InstanceType: t3.xlarge
      ImageId: ami-0c55b159cbfafe1f0
      SubnetId: subnet-12345678
      WeightedCapacity: 2

# Cloud storage tiers
aws_s3_tiers:
  - tier: "S3 Standard"
    access: "Frequent"
    price_per_gb: "$0.023"
    retrieval: "Free"
    
  - tier: "S3 Intelligent-Tiering"
    access: "Unknown/variable"
    price_per_gb: "$0.023"
    monitoring: "$0.0025 per 1K objects"
    
  - tier: "S3 Standard-IA"
    access: "Infrequent"
    price_per_gb: "$0.0125"
    retrieval: "$0.01 per GB"
    
  - tier: "S3 Glacier"
    access: "Rare (archival)"
    price_per_gb: "$0.004"
    retrieval: "Minutes to hours"

azure_blob_tiers:
  - tier: "Hot"
    price_per_gb: "$0.018"
  - tier: "Cool"
    price_per_gb: "$0.01"
  - tier: "Cold"
    price_per_gb: "$0.005"
  - tier: "Archive"
    price_per_gb: "$0.00099"

# S3 Lifecycle Configuration
Rule:
  ID: "ArchiveOldData"
  Status: Enabled
  
  Transition:
    - Days: 30
      StorageClass: STANDARD_IA
      
    - Days: 90
      StorageClass: GLACIER
      
    - Days: 365
      StorageClass: DEEP_ARCHIVE
      
  Expiration:
    Days: 1095  # Delete after 3 years

# Terraform: S3 Lifecycle
resource "aws_s3_bucket" "data" {
  bucket = "my-data-lifecycle-bucket"
}

resource "aws_s3_bucket_lifecycle_configuration" "data" {
  bucket = aws_s3_bucket.data.id
  
  rule {
    id     = "archive-delete"
    status = "Enabled"
    
    transition {
      days          = 30
      storage_class = "STANDARD_IA"
    }
    
    transition {
      days          = 90
      storage_class = "GLACIER"
    }
    
    expiration {
      days = 1095
    }
  }
}

-- Example: RDS Reserved Instance for production DB
-- 3-year reserved, all upfront
-- Savings: ~60% vs on-demand

-- For dev/test environments: use spot or stop when idle
CREATE INSTANCE dev-db
  USING db.t3.micro
  WHEN idle THEN auto_stop()
  schedule: "0 18 * * 1-5"  # Business hours only

# Network cost optimization
network_optimization:
  - strategy: "Cloud CDN"
    savings: "60-80% on egress"
    implementation:
      aws: "CloudFront"
      azure: "Azure CDN"
      gcp: "Cloud CDN"
      
  - strategy: "Compression"
    savings: "30-50% data transfer"
    implementation: "Enable gzip/brotli"
    
  - strategy: "Direct Connect/ExpressRoute"
    savings: "50%+ vs internet"
    use_case: "High-volume data transfer"
    
  - strategy: "Private Link"
    savings: "Avoid public egress"
    use_case: "Service-to-service traffic"

// CloudFront Function: Compress and Cache
function handler(event) {
  var request = event.request;
  var response = event.response;
  
  // Enable compression
  request.headers['accept-encoding'] = { value: 'gzip, deflate, br' };
  
  // Set caching policy
  response.headers['cache-control'] = {
    value: 'public, max-age=31536000, immutable'
  };
  
  return request;
}

# Kubernetes HPA with schedule
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: web-app-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: web-app
  minReplicas: 2
  maxReplicas: 10
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 70
---
# Cron-based scheduled scaling
apiVersion: v1
kind: ConfigMap
metadata:
  name: cron-scaler-config
data:
  schedule: |
    0 8 * * 1-5: scale(min=5)   # Weekdays 8AM
    0 18 * * 1-5: scale(min=2)  # Weekdays 6PM

# CloudFormation: Auto Scaling Group
AutoScalingGroup:
  Type: AWS::AutoScaling::AutoScalingGroup
  Properties:
    MinSize: 2
    MaxSize: 10
    DesiredCapacity: 3
    
    # Scheduled actions
    ScheduledActions:
      - ScheduledActionName: scale-up-morning
        MinSize: 5
        MaxSize: 15
        DesiredCapacity: 8
        Recurrence: "0 8 * * 1-5"
        
      - ScheduledActionName: scale-down-evening
        MinSize: 2
        MaxSize: 10
        DesiredCapacity: 2
        Recurrence: "0 18 * * 1-5"

# Cost alert configuration
import boto3

class CostAlerts:
    def __init__(self):
        self.budgets = boto3.client('budgets')
    
    def create_budget_alert(self, threshold_dollars):
        """Create budget alert at 80% threshold"""
        response = self.budgets.create_budget(
            AccountId='123456789',
            Budget={
                'BudgetName': 'monthly-spend',
                'BudgetLimit': {
                    'Amount': threshold_dollars,
                    'Unit': 'USD'
                },
                'TimeUnit': 'MONTHLY',
                'BudgetType': 'COST'
            },
            NotificationsWithSubscribers=[
                {
                    'Notification': {
                        'NotificationType': 'ACTUAL',
                        'ComparisonOperator': 'GREATER_THAN',
                        'Threshold': 80,
                        'ThresholdType': 'PERCENTAGE'
                    },
                    'Subscribers': [
                        {
                            'SubscriptionType': 'EMAIL',
                            'Address': '[email protected]'
                        }
                    ]
                }
            ]
        )

# Tagging policy example
required_tags:
  - name: "Environment"
    values: ["prod", "staging", "dev", "test"]
    required: true
    
  - name: "Application"
    values: ["web-api", "worker", "batch"]
    required: true
    
  - name: "Owner"
    values: "team-email"
    required: true
    
  - name: "CostCenter"
    values: "valid-cost-center"
    required: true
    
  - name: "Project"
    values: "project-id"
    required: false

# AWS Tag Policy (SCP)
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "RequireTags",
      "Effect": "Deny",
      "Action": "ec2:RunInstances",
      "Resource": "arn:aws:ec2:*:*:instance",
      "Condition": {
        "StringNotEquals": {
          "aws:RequestTag/Environment": ["prod", "dev", "test"]
        }
      }
    }
  ]
}

# Forgetting to stop dev environments
# Cost: $100+/month per idle instance
dev_server_running = True  # Weekend, no one using it

# Auto-stop dev environments off-hours
def schedule_dev_servers():
    if is_weekend() or is_night_hours():
        stop_non_production_instances()
        # Savings: $50+/instance/month

# Paying full price for batch jobs
batch_processing:
  instance_type: on_demand
  cost_per_hour: $0.50
  hours_per_month: 200
  monthly_cost: $100

# Using spot for batch jobs
batch_processing:
  instance_type: spot
  cost_per_hour: $0.10
  hours_per_month: 200
  monthly_cost: $20
  # With checkpointing for fault tolerance
  # Savings: 80%

# Reserving more than needed
reserved_instances: 10
actual_usage: 3
wasted_commitment: 7

# Matching reservation to actual usage
reserved_instances: 3
on_demand_for_spike: 2
total_capacity: 5
# Flexible: use savings plans instead

# All data flows through NAT gateway
# No caching, no CDN
egress_monthly: 1000 GB
cost: $90/month

# Using CDN, compression, caching
egress_monthly: 100 GB
cost: $9/month
# Savings: 90%

# AWS Budget Configuration
budgets:
  monthly_compute:
    limit: $5000
    alert_thresholds: [80, 90, 100]
    notification: [email protected]
    
  quarterly_infrastructure:
    limit: $15000
    alert_thresholds: [80, 90, 100]
    owners: [cto, vp-infrastructure]