Cost Optimization Strategies in the Cloud

Example: AWS CloudWatch Metrics for Right-Sizing

// Using AWS CLI to get CPU utilization for an EC2 instance over 30 days
aws cloudwatch get-metric-statistics \
  --namespace AWS/EC2 \
  --metric-name CPUUtilization \
  --dimensions Name=InstanceId,Value=i-1234567890abcdef0 \
  --statistics Maximum Average \
  --start-time 2025-04-05T00:00:00Z \
  --end-time 2025-05-05T00:00:00Z \
  --period 86400

// Using AWS CLI to get memory utilization (requires CloudWatch agent)
aws cloudwatch get-metric-statistics \
  --namespace CWAgent \
  --metric-name mem_used_percent \
  --dimensions Name=InstanceId,Value=i-1234567890abcdef0 \
  --statistics Maximum Average \
  --start-time 2025-04-05T00:00:00Z \
  --end-time 2025-05-05T00:00:00Z \
  --period 86400
                

Right-sizing decision logic:

// Simple JavaScript right-sizing logic example
function recommendInstanceSize(metrics) {
  const avgCpuUtilization = metrics.cpu.average;
  const maxCpuUtilization = metrics.cpu.maximum;
  const avgMemUtilization = metrics.memory.average;
  const maxMemUtilization = metrics.memory.maximum;
  
  // If consistently underutilized
  if (avgCpuUtilization < 20 && maxCpuUtilization < 50 && 
      avgMemUtilization < 40 && maxMemUtilization < 60) {
    return "DOWNSIZE";
  }
  
  // If consistently overutilized
  if (avgCpuUtilization > 70 || maxCpuUtilization > 90 || 
      avgMemUtilization > 80 || maxMemUtilization > 90) {
    return "UPSIZE";
  }
  
  return "MAINTAIN";
}
                

Example: Setting Up AWS Spot Instances with Fallback

// AWS CloudFormation template excerpt for mixed instance policy
{
  "Resources": {
    "MyAutoScalingGroup": {
      "Type": "AWS::AutoScaling::AutoScalingGroup",
      "Properties": {
        "MixedInstancesPolicy": {
          "InstancesDistribution": {
            "OnDemandBaseCapacity": 2,
            "OnDemandPercentageAboveBaseCapacity": 20,
            "SpotAllocationStrategy": "capacity-optimized"
          },
          "LaunchTemplate": {
            "LaunchTemplateId": { "Ref": "MyLaunchTemplate" },
            "Version": { "Fn::GetAtt": ["MyLaunchTemplate", "LatestVersionNumber"] }
          }
        },
        "MinSize": "4",
        "MaxSize": "20",
        "DesiredCapacity": "4",
        "VPCZoneIdentifier": [
          { "Ref": "Subnet1" },
          { "Ref": "Subnet2" }
        ]
      }
    }
  }
}
                

This configuration ensures:

• At least 2 On-Demand instances provide baseline stability
• Above that, 80% of instances use cost-effective Spot pricing
• Capacity-optimized allocation reduces the chance of Spot interruptions
• Multi-AZ deployment for high availability

Example: AWS Auto Scaling with Multiple Metrics

// CloudFormation template for scaling policies based on multiple metrics
"ScalingPolicies": {
  "CPUBasedScaling": {
    "Type": "AWS::AutoScaling::ScalingPolicy",
    "Properties": {
      "AutoScalingGroupName": { "Ref": "WebServerGroup" },
      "PolicyType": "TargetTrackingScaling",
      "TargetTrackingConfiguration": {
        "PredefinedMetricSpecification": {
          "PredefinedMetricType": "ASGAverageCPUUtilization"
        },
        "TargetValue": 70.0
      }
    }
  },
  "RequestBasedScaling": {
    "Type": "AWS::AutoScaling::ScalingPolicy",
    "Properties": {
      "AutoScalingGroupName": { "Ref": "WebServerGroup" },
      "PolicyType": "TargetTrackingScaling",
      "TargetTrackingConfiguration": {
        "PredefinedMetricSpecification": {
          "PredefinedMetricType": "ALBRequestCountPerTarget",
          "ResourceLabel": { "Fn::Join": ["/", 
            [
              { "Fn::GetAtt": ["LoadBalancer", "LoadBalancerFullName"] },
              { "Fn::GetAtt": ["TargetGroup", "TargetGroupFullName"] }
            ]
          ]}
        },
        "TargetValue": 1000.0
      }
    }
  }
}
                

Scheduled Scaling for Predictable Patterns:

// AWS CLI command to create scheduled scaling action
aws autoscaling put-scheduled-update-group-action \
  --auto-scaling-group-name WebServerGroup \
  --scheduled-action-name ScaleDownAtNight \
  --recurrence "0 0 * * *" \
  --desired-capacity 2 \
  --min-size 2 \
  --max-size 4

aws autoscaling put-scheduled-update-group-action \
  --auto-scaling-group-name WebServerGroup \
  --scheduled-action-name ScaleUpForBusiness \
  --recurrence "0 8 * * MON-FRI" \
  --desired-capacity 8 \
  --min-size 4 \
  --max-size 16
                

Serverless Cost Comparison Calculator (JavaScript)

// Simple serverless vs. container cost calculator
function calculateMonthlyCosts(params) {
  // Serverless costs
  const functionExecutions = params.requestsPerDay * 30;
  const avgDurationSeconds = params.avgExecutionTimeMs / 1000;
  const memoryGb = params.memoryMb / 1024;
  
  // AWS Lambda pricing: $0.0000166667 per GB-second + $0.20 per 1M requests
  const computeCost = functionExecutions * avgDurationSeconds * memoryGb * 0.0000166667;
  const requestCost = functionExecutions * 0.20 / 1000000;
  const serverlessCost = computeCost + requestCost;
  
  // Container costs (AWS Fargate example)
  const containerVcpu = Math.ceil(params.memoryMb / 1024 / 2); // 2GB per vCPU ratio
  const containerMemoryGb = Math.ceil(params.memoryMb / 1024);
  const containersNeeded = Math.ceil(params.requestsPerDay * params.avgExecutionTimeMs / 
                                     (1000 * 60 * 60 * 24)); // Simplified capacity calc
  
  // AWS Fargate pricing: $0.04048 per vCPU hour + $0.004445 per GB hour
  const containerHours = containersNeeded * 24 * 30; // assume running 24/7
  const containerCost = containerHours * 
                       (containerVcpu * 0.04048 + containerMemoryGb * 0.004445);
  
  return {
    serverlessCost: serverlessCost.toFixed(2),
    containerCost: containerCost.toFixed(2),
    recommendation: serverlessCost < containerCost ? "SERVERLESS" : "CONTAINER"
  };
}

// Example usage:
const params = {
  requestsPerDay: 100000,
  avgExecutionTimeMs: 200,
  memoryMb: 512
};

console.log(calculateMonthlyCosts(params));