Introducción a los Data Lakes Parte 2

En el post anterior exploramos qué es un Data Lake y por qué son tan importantes en el ecosistema de datos actual. Ahora es momento de ensuciarnos las manos y ver exactamente qué servicios de AWS necesitamos para construir un Data Lake completamente serverless y cómo orquestarlos.

Los Servicios Fundamentales

Un Data Lake serverless en AWS se construye sobre cinco pilares fundamentales que trabajan en conjunto para crear una solución escalable y costo-eficiente:

• Storage
• Procesamiento
• Catalogo
• Seguridad
• Explotación

Amazon S3 - El Corazón del Storage

S3 no es solo nuestro sistema de archivos, es la piedra angular del Data Lake. Aquí almacenamos tanto los datos crudos como los procesados, y su organización es crucial para el rendimiento y los costos.

Estructura de carpetas de un data lake estandar:

data-lake-bucket/
├── raw/                    # Datos sin procesar
│   ├── year=2024/
│   ├── month=12/
│   └── day=15/
├── processed/              # Datos transformados
│   ├── bronze/             # Limpieza básica
│         ├── year=2024/
│         ├── month=12/
│         └── day=15/           
│   ├── silver/            # Transformaciones de negocio
│         ├── year=2024/
│         ├── month=12/
│         └── day=15/         
│   └── gold/              # Datos listos para consumo
│         ├── year=2024/
│         ├── month=12/
│         └── day=15/        
└── athena-results/        # Resultados de queries

Notarás que todo el data lake se encuentra en un mismo bucket, esto es lo más recomendable ya que S3 tiene un límite de 100 bucket que podemos crear por cuenta (no importa la región, ya que S3 es un servicio global)

Configuraciones clave en S3:

• Versionado habilitado para auditoría y rollback
• Lifecycle policies para optimizar costos (Standard → IA → Glacier)
• Server-side encryption con KMS para seguridad si es necesario.
• Cross-region replication para disaster recovery

AWS Glue - El Motor de Transformación

Glue es suite de servicios de data serverless que maneja tanto el descubrimiento de esquemas como las transformaciones de datos.

Componentes principales:

• Glue Jobs: Herramienta predilecta para ejecutar ETLs, nos permite procesar y transformar los datos de forma paralela, serverless y escalable usando Spark (en general Pyspark)
• Glue Catalog: Metastore centralizado que actúa como nuestro "diccionario o catálogo de datos"
• Glue Crawlers: Descubren automáticamente la estructura de los datos que dejamos en el storage que para este ejemplo es S3.

Un Glue Job típico se ve así:

import sys
from awsglue.transforms import *
from awsglue.utils import getResolvedOptions
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job

args = getResolvedOptions(sys.argv, ['JOB_NAME'])
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
job = Job(glueContext)
job.init(args['JOB_NAME'], args)

# Leer datos del catálogo
datasource = glueContext.create_dynamic_frame.from_catalog(
    database="mi_database",
    table_name="raw_data"
)

# Transformar datos
transformed = ApplyMapping.apply(
    frame=datasource,
    mappings=[
        ("old_column", "string", "new_column", "string"),
        ("timestamp", "string", "processed_date", "timestamp")
    ]
)

# Escribir a S3 en formato Parquet
glueContext.write_dynamic_frame.from_options(
    frame=transformed,
    connection_type="s3",
    connection_options={"path": "s3://mi-bucket/processed/"},
    format="parquet"
)

job.commit()

Amazon Athena - La Ventana de Consultas

Athena nos permite consultar nuestros datos directamente desde S3 usando SQL estándar (ANSI SQL), sin necesidad de provisionar servidores y como si estuvieramos utilizando PrestoDB como motór de consultas.

Ventajas clave:

• Pay-per-query: Solo pagas por los datos escaneados
• Integración nativa con Glue Catalog
• Soporte para múltiples formatos: Parquet, ORC, JSON, CSV
• Particionado automático para optimizar performance
• Limitación a usuarios: Se puede limitar la cantidad de querys, tiempo de consultas y volumen escaneado por usuario y grupo.
• Seguridad integrada: Se integra a otros servicios especialmente LakeFormation para la facil gobernanza de los datos.

Ejemplo de query optimizada:

SELECT 
    region,
    COUNT(*) as total_events,
    AVG(revenue) as avg_revenue
FROM processed_sales
WHERE year = '2024' 
    AND month = '12'
    AND event_type = 'purchase'
GROUP BY region
ORDER BY avg_revenue DESC;

Importante - Nunca hagas un Select * From porque va a ser la consulta más cara de tu vida.

AWS Lambda - La Automatización Inteligente

Lambda actúa como el pegamento que conecta todos los servicios, respondiendo a eventos y orquestando workflows complejos.

Casos de uso comunes:

• Triggers de S3: Procesar archivos automáticamente al llegar
• Validación de datos: Verificar calidad antes del procesamiento
• Notificaciones: Alertar sobre fallos o completitud de procesos
• Orquestación: Coordinar múltiples Glue Jobs

Ejemplo de función Lambda que se ejecuta cuando llega un archivo:

import boto3
import json

def lambda_handler(event, context):
    glue_client = boto3.client('glue')

    # Extraer información del evento S3
    bucket = event['Records'][0]['s3']['bucket']['name']
    key = event['Records'][0]['s3']['object']['key']

    # Iniciar Glue Job si es un archivo de datos
    if key.startswith('raw/') and key.endswith('.json'):
        response = glue_client.start_job_run(
            JobName='process-raw-data',
            Arguments={
                '--input_path': f's3://{bucket}/{key}',
                '--output_path': f's3://{bucket}/processed/'
            }
        )

        return {
            'statusCode': 200,
            'body': json.dumps(f'Job iniciado: {response["JobRunId"]}')
        }

AWS CDK - Infrastructure as Code

CDK nos permite definir toda nuestra infraestructura usando Python, manteniendo versionado y reproducibilidad.

from aws_cdk import (
    Stack,
    aws_s3 as s3,
    aws_glue as glue,
    aws_lambda as lambda_,
    aws_s3_notifications as s3n
)

class DataLakeStack(Stack):
    def __init__(self, scope, construct_id, **kwargs):
        super().__init__(scope, construct_id, **kwargs)

        # S3 Bucket para el Data Lake
        data_lake_bucket = s3.Bucket(
            self, "DataLakeBucket",
            versioned=True,
            lifecycle_rules=[
                s3.LifecycleRule(
                    id="move-to-ia",
                    transitions=[
                        s3.Transition(
                            storage_class=s3.StorageClass.INFREQUENT_ACCESS,
                            transition_after=Duration.days(30)
                        )
                    ]
                )
            ]
        )

        # Glue Database
        database = glue.CfnDatabase(
            self, "DataLakeDatabase",
            catalog_id=self.account,
            database_input=glue.CfnDatabase.DatabaseInputProperty(
                name="data_lake_db",
                description="Database for Data Lake"
            )
        )

Flujo de Datos Completo

El flujo típico en nuestro Data Lake serverless sigue este patrón:

1. Ingesta: Los datos llegan a S3/raw/ desde diversas fuentes
2. Detección: S3 Event Notification dispara una Lambda
3. Catalogación: Glue Crawler descubre el esquema
4. Procesamiento: Glue Job transforma los datos
5. Almacenamiento: Datos procesados van a S3/processed/
6. Consulta: Athena permite análisis ad-hoc
7. Visualización: Herramientas de BI consumen desde Athena

Optimización de Costos

Formatos de Archivo

• Parquet para análisis columnar (reduce costos de Athena hasta 90%)
• Compresión GZIP o Snappy para reducir storage
• Particionado inteligente por fecha/región/categoría

Estrategias de Storage

• S3 Intelligent Tiering para archivos con patrones de acceso variables
• Lifecycle policies para mover datos antiguos automáticamente
• Spot instances en Glue para workloads no críticas

Monitoreo y Alertas

# CloudWatch Custom Metrics en Lambda
import boto3

cloudwatch = boto3.client('cloudwatch')

def put_custom_metric(metric_name, value, unit='Count'):
    cloudwatch.put_metric_data(
        Namespace='DataLake/Processing',
        MetricData=[
            {
                'MetricName': metric_name,
                'Value': value,
                'Unit': unit
            }
        ]
    )

Seguridad y Governance

IAM Roles y Políticas

Cada servicio necesita permisos específicos y mínimos:

• Glue Role: Acceso a S3 y CloudWatch Logs
• Lambda Role: Triggers de S3 y inicio de Glue Jobs
• Athena Users: Solo lectura en tablas específicas

Encriptación End-to-End

• S3: Server-side encryption con KMS
• Glue: Encriptación en jobs y catálogo
• Athena: Encriptación de resultados

Próximos Pasos

En el siguiente post profundizaremos en AWS Glue en la práctica, incluyendo:

• Optimización de Glue Jobs para grandes volúmenes
• Testing y debugging de transformaciones
• Patrones avanzados de ETL
• Integración con herramientas de CI/CD

Un Data Lake serverless en AWS no es solo una colección de servicios, es un ecosistema integrado que, bien diseñado, puede escalar desde gigabytes hasta petabytes manteniendo costos controlados y performance óptimo.

¿Implementaste alguna de estas arquitecturas? ¿Qué desafíos te encontraste?

Contame en los comentarios tu experiencia con tus Data Lakes.