AWS Cost Optimization: Enterprise Infrastructure Cost Reduction Strategies

# AWS CLI Script for Cost Analysis
#!/bin/bash

# Get top 10 most expensive services
echo "Top 10 AWS Services by Cost (Last 30 days):"
aws ce get-cost-and-usage \
  --time-period Start=2024-11-01,End=2024-12-01 \
  --granularity MONTHLY \
  --metrics "BlendedCost" \
  --group-by Type=DIMENSION,Key=SERVICE \
  --query 'ResultsByTime[0].Groups[?Amount.Amount>`10`]|sort_by(@, &Amount.Amount)|reverse(@)|[:10]'

# Get untagged resources (cost allocation)
echo "Untagged EC2 Instances:"
aws ec2 describe-instances \
  --query 'Reservations[].Instances[?!Tags].[InstanceId,InstanceType,State.Name]' \
  --output table

# Python script to identify right-sizing opportunities
import boto3
import json
from datetime import datetime, timedelta

cloudwatch = boto3.client('cloudwatch')
ec2 = boto3.client('ec2')

def get_instance_utilization(instance_id, days=14):
    """Get average CPU utilization for an instance"""
    end_time = datetime.utcnow()
    start_time = end_time - timedelta(days=days)
    
    response = cloudwatch.get_metric_statistics(
        Namespace='AWS/EC2',
        MetricName='CPUUtilization',
        Dimensions=[
            {'Name': 'InstanceId', 'Value': instance_id}
        ],
        StartTime=start_time,
        EndTime=end_time,
        Period=3600,  # 1 hour periods
        Statistics=['Average']
    )
    
    if response['Datapoints']:
        avg_cpu = sum(d['Average'] for d in response['Datapoints']) / len(response['Datapoints'])
        return round(avg_cpu, 2)
    return 0

# Analyze all running instances
instances = ec2.describe_instances(
    Filters=[{'Name': 'instance-state-name', 'Values': ['running']}]
)

rightsizing_candidates = []

for reservation in instances['Reservations']:
    for instance in reservation['Instances']:
        instance_id = instance['InstanceId']
        instance_type = instance['InstanceType']
        
        avg_cpu = get_instance_utilization(instance_id)
        
        if avg_cpu < 30:  # Under-utilized threshold
            rightsizing_candidates.append({
                'InstanceId': instance_id,
                'InstanceType': instance_type,
                'AvgCPU': avg_cpu,
                'Recommendation': 'Consider downsizing'
            })

print(f"Found {len(rightsizing_candidates)} right-sizing candidates:")
for candidate in rightsizing_candidates:
    print(f"Instance: {candidate['InstanceId']} ({candidate['InstanceType']}) - Avg CPU: {candidate['AvgCPU']}%")

{
  "reserved_instance_strategy": {
    "production": {
      "instance_types": ["m5.large", "m5.xlarge", "c5.large"],
      "commitment": "3_year_all_upfront",
      "expected_savings": "50-60%",
      "monthly_savings": "$4500"
    },
    "staging": {
      "instance_types": ["t3.medium", "t3.large"],
      "commitment": "1_year_partial_upfront",
      "expected_savings": "30-40%",
      "monthly_savings": "$1200"
    },
    "development": {
      "strategy": "spot_instances",
      "fallback": "on_demand",
      "expected_savings": "60-70%",
      "monthly_savings": "$800"
    }
  }
}

# Auto Scaling Group Configuration
Resources:
  WebServerAutoScalingGroup:
    Type: AWS::AutoScaling::AutoScalingGroup
    Properties:
      VPCZoneIdentifier: 
        - !Ref PrivateSubnet1
        - !Ref PrivateSubnet2
      LaunchTemplate:
        LaunchTemplateId: !Ref WebServerLaunchTemplate
        Version: !GetAtt WebServerLaunchTemplate.LatestVersionNumber
      MinSize: 2
      MaxSize: 10
      DesiredCapacity: 3
      TargetGroupARNs:
        - !Ref ApplicationLoadBalancerTargetGroup
      HealthCheckType: ELB
      HealthCheckGracePeriod: 300
      
  WebServerScaleUpPolicy:
    Type: AWS::AutoScaling::ScalingPolicy
    Properties:
      AdjustmentType: ChangeInCapacity
      AutoScalingGroupName: !Ref WebServerAutoScalingGroup
      Cooldown: 300
      ScalingAdjustment: 2
      
  WebServerScaleDownPolicy:
    Type: AWS::AutoScaling::ScalingPolicy
    Properties:
      AdjustmentType: ChangeInCapacity
      AutoScalingGroupName: !Ref WebServerAutoScalingGroup
      Cooldown: 300
      ScalingAdjustment: -1

{
  "Rules": [
    {
      "ID": "LogsLifecycle",
      "Status": "Enabled",
      "Filter": {
        "Prefix": "logs/"
      },
      "Transitions": [
        {
          "Days": 30,
          "StorageClass": "STANDARD_IA"
        },
        {
          "Days": 90,
          "StorageClass": "GLACIER"
        },
        {
          "Days": 365,
          "StorageClass": "DEEP_ARCHIVE"
        }
      ]
    },
    {
      "ID": "BackupsLifecycle",
      "Status": "Enabled",
      "Filter": {
        "Prefix": "backups/"
      },
      "Transitions": [
        {
          "Days": 7,
          "StorageClass": "STANDARD_IA"
        },
        {
          "Days": 30,
          "StorageClass": "GLACIER"
        }
      ],
      "Expiration": {
        "Days": 2555  // 7 years retention
      }
    }
  ]
}

# CloudWatch Billing Alarm
BillingAlarm:
  Type: AWS::CloudWatch::Alarm
  Properties:
    AlarmDescription: 'AWS Bill Alert - Monthly spend exceeds $20,000'
    AlarmActions:
      - !Ref BillingAlarmTopic
    MetricName: EstimatedCharges
    Namespace: AWS/Billing
    Statistic: Maximum
    Period: 86400  # 24 hours
    EvaluationPeriods: 1
    Threshold: 20000
    ComparisonOperator: GreaterThanThreshold
    Dimensions:
      - Name: Currency
        Value: USD

# Daily Cost Report Lambda
DailyCostReportFunction:
  Type: AWS::Lambda::Function
  Properties:
    Runtime: python3.9
    Handler: index.lambda_handler
    Code:
      ZipFile: |
        import boto3
        import json
        from datetime import datetime, timedelta
        
        def lambda_handler(event, context):
            ce = boto3.client('ce')
            sns = boto3.client('sns')
            
            # Get yesterday's costs
            yesterday = datetime.now() - timedelta(days=1)
            start_date = yesterday.strftime('%Y-%m-%d')
            end_date = datetime.now().strftime('%Y-%m-%d')
            
            response = ce.get_cost_and_usage(
                TimePeriod={
                    'Start': start_date,
                    'End': end_date
                },
                Granularity='DAILY',
                Metrics=['BlendedCost'],
                GroupBy=[
                    {'Type': 'DIMENSION', 'Key': 'SERVICE'}
                ]
            )
            
            # Format and send report
            costs = response['ResultsByTime'][0]['Groups']
            total_cost = sum(float(cost['Metrics']['BlendedCost']['Amount']) for cost in costs)
            
            message = f"Daily AWS Cost Report for {start_date}:\n"
            message += f"Total Cost: ${total_cost:.2f}\n\n"
            
            for cost in sorted(costs, key=lambda x: float(x['Metrics']['BlendedCost']['Amount']), reverse=True)[:10]:
                service = cost['Keys'][0]
                amount = float(cost['Metrics']['BlendedCost']['Amount'])
                message += f"{service}: ${amount:.2f}\n"
            
            sns.publish(
                TopicArn=os.environ['SNS_TOPIC_ARN'],
                Subject='Daily AWS Cost Report',
                Message=message
            )
            
            return {'statusCode': 200}