AWS Cost Optimization: A Complete Guide

Discover the strategies and tools to optimize your AWS costs effectively.

1. Cost Analysis

Using AWS Cost Explorer

# Example of cost analysis with boto3
import boto3
from datetime import datetime, timedelta

def analyze_costs():
    ce = boto3.client('ce')
    
    # Analysis period (last 30 days)
    end_date = datetime.now()
    start_date = end_date - timedelta(days=30)
    
    response = ce.get_cost_and_usage(
        TimePeriod={
            'Start': start_date.strftime('%Y-%m-%d'),
            'End': end_date.strftime('%Y-%m-%d')
        },
        Granularity='DAILY',
        Metrics=['UnblendedCost'],
        GroupBy=[
            {'Type': 'DIMENSION', 'Key': 'SERVICE'},
            {'Type': 'DIMENSION', 'Key': 'USAGE_TYPE'}
        ]
    )
    
    return response['ResultsByTime']

Detecting Unused Resources

# Example of unused resource detection
def find_unused_resources():
    unused_resources = {
        'ec2_instances': [],
        'ebs_volumes': [],
        's3_buckets': []
    }
    
    # Check EC2 instances
    ec2 = boto3.client('ec2')
    instances = ec2.describe_instances()
    
    for reservation in instances['Reservations']:
        for instance in reservation['Instances']:
            if instance['State']['Name'] == 'stopped':
                unused_resources['ec2_instances'].append({
                    'id': instance['InstanceId'],
                    'type': instance['InstanceType'],
                    'state': instance['State']['Name']
                })
    
    return unused_resources

2. Resource Optimization

Resizing EC2 Instances

# Example of EC2 instance resizing
def resize_ec2_instance(instance_id, new_instance_type):
    ec2 = boto3.client('ec2')
    
    try:
        # Stop the instance
        ec2.stop_instances(InstanceIds=[instance_id])
        
        # Wait for the instance to stop
        waiter = ec2.get_waiter('instance_stopped')
        waiter.wait(InstanceIds=[instance_id])
        
        # Change the instance type
        ec2.modify_instance_attribute(
            InstanceId=instance_id,
            InstanceType={'Value': new_instance_type}
        )
        
        # Restart the instance
        ec2.start_instances(InstanceIds=[instance_id])
        
        return True
    except Exception as e:
        print(f"Erreur lors du redimensionnement: {e}")
        return False

Optimizing S3 Storage

# Example of S3 storage optimization
def optimize_s3_storage():
    s3 = boto3.client('s3')
    
    # List buckets
    buckets = s3.list_buckets()
    
    for bucket in buckets['Buckets']:
        # Analyze objects
        objects = s3.list_objects_v2(Bucket=bucket['Name'])
        
        for obj in objects.get('Contents', []):
            # Check last modified date
            last_modified = obj['LastModified']
            age = (datetime.now() - last_modified).days
            
            # Move to a less expensive storage class
            if age > 90:  # Objects older than 90 days
                s3.copy_object(
                    Bucket=bucket['Name'],
                    CopySource={'Bucket': bucket['Name'], 'Key': obj['Key']},
                    Key=obj['Key'],
                    StorageClass='STANDARD_IA'
                )

3. Reservation Management

Purchasing EC2 Reservations

# Example of purchasing EC2 reservations
def purchase_ec2_reservation():
    ec2 = boto3.client('ec2')
    
    try:
        response = ec2.purchase_reserved_instances_offering(
            ReservedInstancesOfferingId='offering-id',
            InstanceCount=1,
            LimitPrice={
                'Amount': '1000',
                'CurrencyCode': 'USD'
            }
        )
        
        return response['ReservedInstancesId']
    except Exception as e:
        print(f"Erreur lors de l'achat: {e}")
        return None

Optimizing Reservations

# Example of reservation optimization
def optimize_reservations():
    ec2 = boto3.client('ec2')
    
    # Analyze utilization
    utilization = ec2.describe_reserved_instances()
    
    recommendations = []
    for ri in utilization['ReservedInstances']:
        if ri['State'] == 'active':
            # Calculate utilization
            utilization_rate = calculate_utilization_rate(ri)
            
            if utilization_rate < 0.7:  # Utilization below 70%
                recommendations.append({
                    'reservation_id': ri['ReservedInstancesId'],
                    'current_utilization': utilization_rate,
                    'recommendation': 'Considérer la modification ou l'annulation'
                })
    
    return recommendations

4. Setting Up Alerts

Configuring Budget Alerts

# Example of budget alert configuration
def setup_budget_alerts():
    budgets = boto3.client('budgets')
    
    try:
        response = budgets.create_budget(
            AccountId='123456789012',
            Budget={
                'BudgetName': 'Budget Mensuel',
                'BudgetLimit': {
                    'Amount': '1000',
                    'Unit': 'USD'
                },
                'TimeUnit': 'MONTHLY',
                'BudgetType': 'COST',
                'CostFilters': {
                    'Service': ['Amazon EC2', 'Amazon S3']
                }
            },
            NotificationsWithSubscribers=[
                {
                    'Notification': {
                        'NotificationType': 'ACTUAL',
                        'ComparisonOperator': 'GREATER_THAN',
                        'Threshold': 80,
                        'ThresholdType': 'PERCENTAGE'
                    },
                    'Subscribers': [
                        {
                            'SubscriptionType': 'EMAIL',
                            'Address': 'alerts@example.com'
                        }
                    ]
                }
            ]
        )
        
        return response['BudgetId']
    except Exception as e:
        print(f"Erreur lors de la configuration: {e}")
        return None

Cost Monitoring

# Example of cost monitoring
def monitor_costs():
    ce = boto3.client('ce')
    
    # Monitoring configuration
    monitoring_config = {
        'daily_threshold': 100,  # USD
        'weekly_threshold': 500,  # USD
        'monthly_threshold': 2000  # USD
    }
    
    # Daily monitoring
    daily_costs = get_daily_costs()
    if daily_costs > monitoring_config['daily_threshold']:
        send_alert('Dépassement du seuil quotidien')
    
    # Weekly monitoring
    weekly_costs = get_weekly_costs()
    if weekly_costs > monitoring_config['weekly_threshold']:
        send_alert('Dépassement du seuil hebdomadaire')

5. Best Practices

Automatic Optimization

# Example of automatic optimization
def auto_optimize_resources():
    # Cost analysis
    costs = analyze_costs()
    
    # Detect unused resources
    unused = find_unused_resources()
    
    # Optimize EC2 instances
    for instance in unused['ec2_instances']:
        if is_safe_to_stop(instance):
            stop_instance(instance['id'])
    
    # Optimize storage
    optimize_s3_storage()
    
    # Update reservations
    update_reservations()
    
    return {
        'optimizations_performed': True,
        'resources_optimized': len(unused['ec2_instances']),
        'cost_savings': calculate_savings()
    }

Optimization Reports

# Example of optimization report generation
def generate_optimization_report():
    report = {
        'date': datetime.now().strftime('%Y-%m-%d'),
        'cost_analysis': analyze_costs(),
        'unused_resources': find_unused_resources(),
        'reservation_optimization': optimize_reservations(),
        'recommendations': generate_recommendations()
    }
    
    # Save the report
    save_report(report)
    
    # Send the report
    send_report(report)
    
    return report

Conclusion

Key takeaways:

• Analyze costs regularly
• Identify unused resources
• Optimize reservations
• Set up alerts
• Automate optimization

Recommendations:

• Use AWS Cost Explorer
• Configure budgets
• Implement lifecycle policies
• Optimize reservations
• Monitor costs in real time