Costes de AWS: guía de optimización para principiantes

Descubre cómo entender y optimizar los costes de AWS.

1. Comprender la facturación de AWS

Servicios gratuitos

• AWS Free Tier: servicios gratuitos durante 12 meses
• Servicios siempre gratuitos:
  • Lambda: 1 millón de invocaciones al mes
  • CloudWatch: 10 métricas, 1 millón de solicitudes
  • S3: 5 GB de almacenamiento
  • DynamoDB: 25 GB de almacenamiento

Facturación por servicio

# 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. Servicios que hay que vigilar

Amazon Athena

• Facturación: por byte escaneado
• Optimización:

# 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

• Facturación: por hora de clúster
• Optimización:

# 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. Buenas prácticas de optimización

Apagar los recursos que no se usan

# 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']])

Utilizar las reservas

# 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. Puesta en marcha de las alertas

Configuración de los presupuestos

# 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']

Supervisión de los costes

# 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. Herramientas de optimización

AWS Cost Explorer

• Funcionalidades:
  • Visualización de los costes
  • Previsiones
  • Recomendaciones de optimización

AWS Trusted Advisor

• Comprobaciones:
  • Costes no optimizados
  • Rendimiento
  • Seguridad
  • Tolerancia a fallos

Conclusión

Puntos clave que hay que recordar:

• Utilizar el Free Tier
• Vigilar los costes por servicio
• Optimizar las consultas
• Apagar los recursos que no se usan
• Configurar alertas

Recomendaciones:

• Empezar poco a poco
• Utilizar las reservas
• Configurar presupuestos
• Supervisar los costes con regularidad
• Optimizar de forma continua