Amazon Athena : Guide des Coûts et Optimisation

Découvrez Amazon Athena et comment optimiser ses coûts.

1. Comprendre les Coûts d’Athena

Facturation

• Par octet scanné : 5$ par TB
• Par requête : Gratuit
• Exemple de coût :

# Exemple de calcul des coûts
def calculate_athena_cost():
    # Coût par TB scanné
    cost_per_tb = 5  # USD
    
    # Exemple de requête
    query_size = {
        'taille_donnees': 100,  # GB
        'octets_scannes': 50,   # GB
        'coût': (50 / 1024) * cost_per_tb  # Conversion en TB
    }
    
    return query_size

Facteurs de Coût

# Exemple d'analyse des facteurs de coût
def analyze_cost_factors():
    factors = {
        'taille_donnees': {
            'impact': 'Élevé',
            'optimisation': 'Partitionnement'
        },
        'format_donnees': {
            'impact': 'Élevé',
            'optimisation': 'Parquet/ORC'
        },
        'requetes': {
            'impact': 'Faible',
            'optimisation': 'Cache'
        }
    }
    
    return factors

2. Optimisation des Données

Partitionnement

# Exemple de partitionnement
def partition_data():
    athena = boto3.client('athena')
    
    # Création d'une table partitionnée
    query = """
    CREATE TABLE ma_table_partitionnee
    WITH (
        format = 'PARQUET',
        partitioned_by = ARRAY['annee', 'mois']
    )
    AS
    SELECT 
        *,
        year(date_col) as annee,
        month(date_col) as mois
    FROM ma_table;
    """
    
    response = athena.start_query_execution(
        QueryString=query,
        QueryExecutionContext={
            'Database': 'ma_base'
        },
        ResultConfiguration={
            'OutputLocation': 's3://mon-bucket/athena-results/'
        }
    )
    
    return response['QueryExecutionId']

Compression

# Exemple de compression
def compress_data():
    athena = boto3.client('athena')
    
    # Création d'une table compressée
    query = """
    CREATE TABLE ma_table_compressee
    WITH (
        format = 'PARQUET',
        compression = 'SNAPPY'
    )
    AS
    SELECT * FROM ma_table;
    """
    
    response = athena.start_query_execution(
        QueryString=query,
        QueryExecutionContext={
            'Database': 'ma_base'
        },
        ResultConfiguration={
            'OutputLocation': 's3://mon-bucket/athena-results/'
        }
    )
    
    return response['QueryExecutionId']

3. Optimisation des Requêtes

Prédicats de Partition

# Exemple d'utilisation des prédicats de partition
def use_partition_predicates():
    athena = boto3.client('athena')
    
    # Requête optimisée avec prédicats de partition
    query = """
    SELECT *
    FROM ma_table_partitionnee
    WHERE annee = 2024
    AND mois = 3;
    """
    
    response = athena.start_query_execution(
        QueryString=query,
        QueryExecutionContext={
            'Database': 'ma_base'
        },
        ResultConfiguration={
            'OutputLocation': 's3://mon-bucket/athena-results/'
        }
    )
    
    return response['QueryExecutionId']

Limitation des Colonnes

# Exemple de sélection de colonnes
def limit_columns():
    athena = boto3.client('athena')
    
    # Requête optimisée avec sélection de colonnes
    query = """
    SELECT 
        date_col,
        categorie,
        montant
    FROM ma_table
    WHERE date_col >= '2024-01-01';
    """
    
    response = athena.start_query_execution(
        QueryString=query,
        QueryExecutionContext={
            'Database': 'ma_base'
        },
        ResultConfiguration={
            'OutputLocation': 's3://mon-bucket/athena-results/'
        }
    )
    
    return response['QueryExecutionId']

4. Formats de Données

Parquet vs CSV

# Exemple de comparaison des formats
def compare_formats():
    formats = {
        'parquet': {
            'compression': 'Excellente',
            'performance': 'Élevée',
            'taille': 'Petite',
            'coût': 'Faible'
        },
        'csv': {
            'compression': 'Faible',
            'performance': 'Basse',
            'taille': 'Grande',
            'coût': 'Élevé'
        }
    }
    
    return formats

Conversion de Format

# Exemple de conversion de format
def convert_format():
    athena = boto3.client('athena')
    
    # Conversion CSV vers Parquet
    query = """
    CREATE TABLE ma_table_parquet
    WITH (
        format = 'PARQUET',
        compression = 'SNAPPY'
    )
    AS
    SELECT * FROM ma_table_csv;
    """
    
    response = athena.start_query_execution(
        QueryString=query,
        QueryExecutionContext={
            'Database': 'ma_base'
        },
        ResultConfiguration={
            'OutputLocation': 's3://mon-bucket/athena-results/'
        }
    )
    
    return response['QueryExecutionId']

5. Surveillance des Coûts

Métriques de Coût

# Exemple de surveillance des coûts
def monitor_costs():
    cloudwatch = boto3.client('cloudwatch')
    
    # Métriques de coût
    metrics = cloudwatch.get_metric_statistics(
        Namespace='AWS/Athena',
        MetricName='BytesScanned',
        Dimensions=[
            {
                'Name': 'QueryType',
                'Value': 'DML'
            }
        ],
        StartTime=datetime.now() - timedelta(days=7),
        EndTime=datetime.now(),
        Period=3600,
        Statistics=['Sum']
    )
    
    return metrics['Datapoints']

Alertes de Coût

# Exemple de configuration d'alerte
def setup_cost_alert():
    cloudwatch = boto3.client('cloudwatch')
    
    # Création d'une alerte
    cloudwatch.put_metric_alarm(
        AlarmName='AthenaCostAlert',
        MetricName='BytesScanned',
        Namespace='AWS/Athena',
        Statistic='Sum',
        Period=3600,
        EvaluationPeriods=1,
        Threshold=1000000000000,  # 1 TB
        ComparisonOperator='GreaterThanThreshold',
        AlarmActions=['arn:aws:sns:region:account:mon-topic']
    )

6. Bonnes Pratiques

Prévisualisation des Coûts

# Exemple de prévisualisation des coûts
def preview_costs():
    athena = boto3.client('athena')
    
    # Exécution d'une requête EXPLAIN
    query = """
    EXPLAIN
    SELECT *
    FROM ma_table
    WHERE date_col >= '2024-01-01';
    """
    
    response = athena.start_query_execution(
        QueryString=query,
        QueryExecutionContext={
            'Database': 'ma_base'
        },
        ResultConfiguration={
            'OutputLocation': 's3://mon-bucket/athena-results/'
        }
    )
    
    return response['QueryExecutionId']

Cache des Résultats

# Exemple d'utilisation du cache
def use_result_cache():
    athena = boto3.client('athena')
    
    # Configuration du cache
    athena.update_work_group(
        WorkGroup='primary',
        ConfigurationUpdates={
            'ResultConfigurationUpdates': {
                'OutputLocation': 's3://mon-bucket/athena-results/',
                'EncryptionConfiguration': {
                    'EncryptionOption': 'SSE_S3'
                }
            },
            'RequesterPaysEnabled': False,
            'PublishCloudWatchMetricsEnabled': True,
            'BytesScannedCutoffPerQuery': 10000000000  # 10 GB
        }
    )

Conclusion

Points clés à retenir :

• Facturation par octet scanné
• Optimisation par partitionnement
• Utilisation de formats efficaces
• Surveillance des coûts
• Mise en cache des résultats

Recommandations :

• Partitionner les données
• Utiliser Parquet/ORC
• Limiter les colonnes scannées
• Mettre en place des alertes
• Surveiller régulièrement les coûts