Optimisation des Coûts AWS : Guide Complet

Découvrez les stratégies et outils pour optimiser vos coûts AWS efficacement.

1. Analyse des Coûts

Utilisation de AWS Cost Explorer

# Exemple d'analyse des coûts avec boto3
import boto3
from datetime import datetime, timedelta

def analyze_costs():
    ce = boto3.client('ce')
    
    # Période d'analyse (30 derniers jours)
    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']

Détection des Ressources Inutilisées

# Exemple de détection des ressources inutilisées
def find_unused_resources():
    unused_resources = {
        'ec2_instances': [],
        'ebs_volumes': [],
        's3_buckets': []
    }
    
    # Vérification des instances EC2
    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. Optimisation des Ressources

Redimensionnement des Instances EC2

# Exemple de redimensionnement d'instance EC2
def resize_ec2_instance(instance_id, new_instance_type):
    ec2 = boto3.client('ec2')
    
    try:
        # Arrêt de l'instance
        ec2.stop_instances(InstanceIds=[instance_id])
        
        # Attente de l'arrêt
        waiter = ec2.get_waiter('instance_stopped')
        waiter.wait(InstanceIds=[instance_id])
        
        # Modification du type d'instance
        ec2.modify_instance_attribute(
            InstanceId=instance_id,
            InstanceType={'Value': new_instance_type}
        )
        
        # Redémarrage de l'instance
        ec2.start_instances(InstanceIds=[instance_id])
        
        return True
    except Exception as e:
        print(f"Erreur lors du redimensionnement: {e}")
        return False

Optimisation du Stockage S3

# Exemple d'optimisation du stockage S3
def optimize_s3_storage():
    s3 = boto3.client('s3')
    
    # Liste des buckets
    buckets = s3.list_buckets()
    
    for bucket in buckets['Buckets']:
        # Analyse des objets
        objects = s3.list_objects_v2(Bucket=bucket['Name'])
        
        for obj in objects.get('Contents', []):
            # Vérification de la dernière modification
            last_modified = obj['LastModified']
            age = (datetime.now() - last_modified).days
            
            # Migration vers une classe de stockage moins coûteuse
            if age > 90:  # Objets de plus de 90 jours
                s3.copy_object(
                    Bucket=bucket['Name'],
                    CopySource={'Bucket': bucket['Name'], 'Key': obj['Key']},
                    Key=obj['Key'],
                    StorageClass='STANDARD_IA'
                )

3. Gestion des Réservations

Achat de Réservations EC2

# Exemple d'achat de réservations EC2
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

Optimisation des Réservations

# Exemple d'optimisation des réservations
def optimize_reservations():
    ec2 = boto3.client('ec2')
    
    # Analyse de l'utilisation
    utilization = ec2.describe_reserved_instances()
    
    recommendations = []
    for ri in utilization['ReservedInstances']:
        if ri['State'] == 'active':
            # Calcul de l'utilisation
            utilization_rate = calculate_utilization_rate(ri)
            
            if utilization_rate < 0.7:  # Utilisation inférieure à 70%
                recommendations.append({
                    'reservation_id': ri['ReservedInstancesId'],
                    'current_utilization': utilization_rate,
                    'recommendation': 'Considérer la modification ou l'annulation'
                })
    
    return recommendations

4. Mise en Place des Alertes

Configuration des Alertes de Budget

# Exemple de configuration des alertes de budget
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

Surveillance des Coûts

# Exemple de surveillance des coûts
def monitor_costs():
    ce = boto3.client('ce')
    
    # Configuration de la surveillance
    monitoring_config = {
        'daily_threshold': 100,  # USD
        'weekly_threshold': 500,  # USD
        'monthly_threshold': 2000  # USD
    }
    
    # Surveillance quotidienne
    daily_costs = get_daily_costs()
    if daily_costs > monitoring_config['daily_threshold']:
        send_alert('Dépassement du seuil quotidien')
    
    # Surveillance hebdomadaire
    weekly_costs = get_weekly_costs()
    if weekly_costs > monitoring_config['weekly_threshold']:
        send_alert('Dépassement du seuil hebdomadaire')

5. Bonnes Pratiques

Optimisation Automatique

# Exemple d'optimisation automatique
def auto_optimize_resources():
    # Analyse des coûts
    costs = analyze_costs()
    
    # Détection des ressources inutilisées
    unused = find_unused_resources()
    
    # Optimisation des instances EC2
    for instance in unused['ec2_instances']:
        if is_safe_to_stop(instance):
            stop_instance(instance['id'])
    
    # Optimisation du stockage
    optimize_s3_storage()
    
    # Mise à jour des réservations
    update_reservations()
    
    return {
        'optimizations_performed': True,
        'resources_optimized': len(unused['ec2_instances']),
        'cost_savings': calculate_savings()
    }

Rapports d’Optimisation

# Exemple de génération de rapport d'optimisation
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()
    }
    
    # Enregistrement du rapport
    save_report(report)
    
    # Envoi du rapport
    send_report(report)
    
    return report

Conclusion

Points clés à retenir :

• Analyser régulièrement les coûts
• Identifier les ressources inutilisées
• Optimiser les réservations
• Mettre en place des alertes
• Automatiser l’optimisation

Recommandations :

• Utiliser AWS Cost Explorer
• Configurer des budgets
• Mettre en place des politiques de cycle de vie
• Optimiser les réservations
• Surveiller les coûts en temps réel