Amazon Athena: guía de costes y optimización

Descubre Amazon Athena y cómo optimizar sus costes.

1. Comprender los costes de Athena

Facturación

• Por byte escaneado: 5 $ por TB
• Por consulta: gratis
• Ejemplo de coste:

# Ejemplo de cálculo de costes
def calculate_athena_cost():
    # Coste por TB escaneado
    cost_per_tb = 5  # USD
    
    # Ejemplo de consulta
    query_size = {
        'taille_donnees': 100,  # GB
        'octets_scannes': 50,   # GB
        'coût': (50 / 1024) * cost_per_tb  # Conversión a TB
    }
    
    return query_size

Factores de coste

# Ejemplo de análisis de los factores de coste
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. Optimización de los datos

Particionado

# Ejemplo de particionado
def partition_data():
    athena = boto3.client('athena')
    
    # Creación de una tabla particionada
    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']

Compresión

# Ejemplo de compresión
def compress_data():
    athena = boto3.client('athena')
    
    # Creación de una tabla comprimida
    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. Optimización de las consultas

Predicados de partición

# Ejemplo de uso de predicados de partición
def use_partition_predicates():
    athena = boto3.client('athena')
    
    # Consulta optimizada con predicados de partición
    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']

Limitación de columnas

# Ejemplo de selección de columnas
def limit_columns():
    athena = boto3.client('athena')
    
    # Consulta optimizada con selección de columnas
    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 datos

Parquet vs CSV

# Ejemplo de comparación de formatos
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

Conversión de formato

# Ejemplo de conversión de formato
def convert_format():
    athena = boto3.client('athena')
    
    # Conversión de CSV a 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. Monitorización de los costes

Métricas de coste

# Ejemplo de monitorización de costes
def monitor_costs():
    cloudwatch = boto3.client('cloudwatch')
    
    # Métricas de coste
    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 coste

# Ejemplo de configuración de alerta
def setup_cost_alert():
    cloudwatch = boto3.client('cloudwatch')
    
    # Creación de una alerta
    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. Buenas prácticas

Previsualización de costes

# Ejemplo de previsualización de costes
def preview_costs():
    athena = boto3.client('athena')
    
    # Ejecución de una consulta 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']

Caché de resultados

# Ejemplo de uso de la caché
def use_result_cache():
    athena = boto3.client('athena')
    
    # Configuración de la caché
    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
        }
    )

Conclusión

Puntos clave que conviene recordar:

• Facturación por byte escaneado
• Optimización mediante particionado
• Uso de formatos eficientes
• Monitorización de los costes
• Almacenamiento en caché de los resultados

Recomendaciones:

• Particionar los datos
• Utilizar Parquet/ORC
• Limitar las columnas escaneadas
• Configurar alertas
• Supervisar los costes con regularidad