Coûts AWS : Guide d’Optimisation pour Débutants

Découvrez comment comprendre et optimiser les coûts AWS.

1. Comprendre la Facturation AWS

Services Gratuits

• AWS Free Tier : Services gratuits pendant 12 mois
• Services toujours gratuits :
  • Lambda : 1 million d’invocations/mois
  • CloudWatch : 10 métriques, 1 million de requêtes
  • S3 : 5 GB de stockage
  • DynamoDB : 25 GB de stockage

Facturation par Service

# Exemple de calcul des coûts
def calculate_costs():
    # EC2 : Facturation par heure
    ec2_cost = {
        't2.micro': 0.0116,  # par heure
        't2.small': 0.023,   # par heure
        't2.medium': 0.0464  # par heure
    }
    
    # S3 : Facturation par GB/mois
    s3_cost = {
        'standard': 0.023,    # par GB/mois
        'infrequent': 0.0125, # par GB/mois
        'glacier': 0.004      # par GB/mois
    }
    
    # Lambda : Facturation par requête
    lambda_cost = {
        'requests': 0.0000002,  # par requête
        'duration': 0.00001667  # par 100ms
    }
    
    return {
        'ec2': ec2_cost,
        's3': s3_cost,
        'lambda': lambda_cost
    }

2. Services à Surveiller

Amazon Athena

• Facturation : Par octet scanné
• Optimisation :

# Exemple d'optimisation Athena
def optimize_athena_query():
    # 1. Partitionner les données
    partition_query = """
    CREATE TABLE ma_table_partitionnee
    PARTITIONED BY (annee INT, mois INT)
    AS SELECT * FROM ma_table;
    """
    
    # 2. Compresser les données
    compression_query = """
    CREATE TABLE ma_table_compressee
    WITH (format = 'PARQUET', compression = 'SNAPPY')
    AS SELECT * FROM ma_table;
    """
    
    return {
        'partition_query': partition_query,
        'compression_query': compression_query
    }

Amazon Redshift

• Facturation : Par heure de cluster
• Optimisation :

# Exemple d'optimisation Redshift
def optimize_redshift():
    # 1. Choisir le bon type de nœud
    node_types = {
        'dc2.large': 0.25,    # par heure
        'dc2.8xlarge': 2.36,  # par heure
        'ra3.xlplus': 0.24    # par heure
    }
    
    # 2. Configurer le WLM (Workload Management)
    wlm_config = {
        'concurrency_scaling': True,
        'max_concurrency': 50,
        'query_timeout': 300
    }
    
    return {
        'node_types': node_types,
        'wlm_config': wlm_config
    }

3. Bonnes Pratiques d’Optimisation

Éteindre les Ressources Inutilisées

# Exemple d'arrêt automatique
def stop_unused_resources():
    ec2 = boto3.client('ec2')
    
    # Arrêter les instances EC2 inactives
    instances = ec2.describe_instances(
        Filters=[
            {
                'Name': 'instance-state-name',
                'Values': ['running']
            }
        ]
    )
    
    for instance in instances['Reservations']:
        # Vérifier l'utilisation CPU
        cloudwatch = boto3.client('cloudwatch')
        cpu_usage = cloudwatch.get_metric_statistics(
            Namespace='AWS/EC2',
            MetricName='CPUUtilization',
            Dimensions=[{'Name': 'InstanceId', 'Value': instance['InstanceId']}],
            StartTime=datetime.now() - timedelta(hours=24),
            EndTime=datetime.now(),
            Period=3600,
            Statistics=['Average']
        )
        
        # Arrêter si utilisation < 5%
        if cpu_usage['Datapoints'][-1]['Average'] < 5:
            ec2.stop_instances(InstanceIds=[instance['InstanceId']])

Utiliser les Réservations

# Exemple d'achat de réservation
def purchase_reservation():
    ec2 = boto3.client('ec2')
    
    # Acheter une réservation EC2
    reservation = ec2.purchase_reserved_instances_offering(
        ReservedInstancesOfferingId='offering-id',
        InstanceCount=1,
        LimitPrice={
            'Amount': '100',
            'CurrencyCode': 'USD'
        }
    )
    
    return reservation['ReservedInstancesId']

4. Mise en Place des Alertes

Configuration des Budgets

# Exemple de configuration de budget
def setup_budget():
    budgets = boto3.client('budgets')
    
    # Créer un budget mensuel
    budget = budgets.create_budget(
        AccountId='account-id',
        Budget={
            'BudgetName': 'MonBudget',
            'BudgetLimit': {
                'Amount': '100',
                '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': 'mon-email@example.com'
                    }
                ]
            }
        ]
    )
    
    return budget['BudgetId']

Surveillance des Coûts

# Exemple de surveillance des coûts
def monitor_costs():
    ce = boto3.client('ce')
    
    # Obtenir les coûts par service
    costs = ce.get_cost_and_usage(
        TimePeriod={
            'Start': '2024-01-01',
            'End': '2024-03-22'
        },
        Granularity='MONTHLY',
        Metrics=['UnblendedCost'],
        GroupBy=[
            {'Type': 'DIMENSION', 'Key': 'SERVICE'}
        ]
    )
    
    return costs['ResultsByTime']

5. Outils d’Optimisation

AWS Cost Explorer

• Fonctionnalités :
  • Visualisation des coûts
  • Prévisions
  • Recommandations d’optimisation

AWS Trusted Advisor

• Vérifications :
  • Coûts non optimisés
  • Performances
  • Sécurité
  • Tolérance aux pannes

Conclusion

Points clés à retenir :

• Utiliser le Free Tier
• Surveiller les coûts par service
• Optimiser les requêtes
• Éteindre les ressources inutilisées
• Mettre en place des alertes

Recommandations :

• Commencer petit
• Utiliser les réservations
• Mettre en place des budgets
• Surveiller régulièrement les coûts
• Optimiser continuellement