Amazon Athena: Guia de Custos e Otimização

Conheça o Amazon Athena e saiba como otimizar seus custos.

1. Entendendo os Custos do Athena

Cobrança

• Por byte escaneado: US$ 5 por TB
• Por consulta: Gratuito
• Exemplo de custo:

# Exemplo de cálculo de custos
def calculate_athena_cost():
    # Custo por TB escaneado
    cost_per_tb = 5  # USD
    
    # Exemplo de consulta
    query_size = {
        'taille_donnees': 100,  # GB
        'octets_scannes': 50,   # GB
        'coût': (50 / 1024) * cost_per_tb  # Conversion en TB
    }
    
    return query_size

Fatores de Custo

# 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. Otimização dos Dados

Particionamento

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

Compressão

# 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. Otimização das Consultas

Predicados de Partição

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

Limitação de Colunas

# 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. Formatos de Dados

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

Conversão de Formato

# 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. Monitoramento dos Custos

Métricas de Custo

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

Alertas de Custo

# 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. Boas Práticas

Pré-visualização dos Custos

# 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 dos Resultados

# 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
        }
    )

Conclusão

Pontos-chave a lembrar:

• Cobrança por byte escaneado
• Otimização por meio de particionamento
• Uso de formatos eficientes
• Monitoramento dos custos
• Cache dos resultados

Recomendações:

• Particionar os dados
• Usar Parquet/ORC
• Limitar as colunas escaneadas
• Configurar alertas
• Monitorar os custos regularmente