Cómo configurar AWS Glue ETL desde S3 a Parquet

Contenido del curso

Bienvenida e introducción al curso

Arquitecturas

Extracción de información

Transformación de Información

Carga de Información

Consumo de información

Seguridad, Orquestación y Automatización

Clase pública

52
Las cinco B de big data explicadas
01:44 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0010:23

Cómo configurar AWS Glue ETL desde S3 a Parquet

Curso de Big Data en AWS

Clase 28 de 52

Clase 28 / 52

Recursos

Aprende a crear un ETL en AWS Glue con confianza: desde configurar el job, transformar datos con dynamic frame y escribir en S3 en formato Parquet, hasta catalogar con Crawler y consultar en Athena. Verás cómo pasar de datos crudos a información organizada y consultable con pasos claros y replicables.

¿Cómo crear y configurar un job de AWS Glue para ETL?

Configurar el job define la base de la transformación. Se elige motor, permisos y dónde vivirá el script. Todo empieza en Glue, sección Jobs, agregando el job “Platzi ETL” y seleccionando el rol de servicio.

¿Qué parámetros clave definen el job?

Tipo de ejecución: Spark (también existe Python Shell, pero aquí usamos Spark).
Script: nuevo script proveído por nosotros en Python.
Almacenamiento: bucket de S3 por defecto para el script.
Propiedades avanzadas: marcas de trabajo y seguridad deshabilitadas por ahora.
Librerías externas: opción para cargarlas desde S3.
Capacidad y ejecución: timeout, número de retries y etiquetas para el job.
Triggers y conexiones: no se agregan en esta configuración inicial.

¿Cómo preparar el script y el contexto de Glue?

Abrir “Guardar job y Editar”.
Pegar el script del ETL y ajustar parámetros clave.
Inicializar el Glue Context: ya validado previamente en ejecución local.
Base de datos fuente: cambiar a “platzi-db”.
Directorio de salida en S3: usar “target-platzi” en todas las rutas de escritura.

¿Cómo transformar datos con DynamicFrame y escribir en S3 en Parquet?

La transformación combina limpieza, normalización y uniones. Con dynamic frames, Glue infiere esquemas y facilita operaciones sobre datos semiestructurados antes de escribir resultados optimizados en Parquet.

¿Qué operaciones de limpieza y join aplicar?

Creación de dynamic frames para las tres tablas origen.
Limpieza: eliminar columnas que no aportan valor.
Estandarización: rename de campos para consistencia.
Enriquecimiento: join entre personas y membresías usando “membership ID” y “person ID”.
Resultado: una tabla agregada más útil para análisis.

Habilidades puestas en práctica:

Modelado con dynamic frame: gestión flexible de esquemas.
Transformaciones: limpiar, renombrar y unir datos.
Diseño de salidas: definir tablas resultantes y estructura deseada.

¿Cómo escribir en S3 y optimizar con Parquet?

Conexión de escritura: tipo S3 indicando el path del bucket de salida.
Formato: Parquet por su menor tamaño y mejor rendimiento que JSON.
Estrategia de salida: un archivo simple en un subdirectorio y otro particionado por “org name”.
Ejecución: “Action” → Run Job; se monitoriza el estado hasta “succeeded”.
Observabilidad: revisar logs y error logs ante fallas; opción de depurar paso a paso en Zeppelin local.

Conceptos y keywords importantes:

Glue Job: unidad de ejecución para ETL en Glue.
Spark: motor distribuido usado por el job.
Parquet: formato columna optimizado para análisis.
Particionamiento: mejora consultas filtrando por “org name”.

¿Cómo catalogar con Crawler y consultar en Athena la data transformada?

Tras escribir en “target-platzi”, es clave actualizar el catálogo para habilitar consultas SQL. Se logra con un Crawler que detecta esquemas y crea tablas en el Glue Catalog.

¿Cómo actualizar el Glue Catalog con un Crawler?

Crear o editar el Crawler para apuntar al directorio “target-platzi”.
Base de datos: crear “Platzi DB Transformed” para separar lo transformado.
Ejecutar el Crawler: detecta la nueva estructura y agrega tres tablas al catálogo.
Buenas prácticas en producción: orquestar ejecución, retries y crawlers con la SDK de AWS para automatizar.

Datos y habilidades destacadas:

Glue Catalog: metadatos centralizados para lectura por servicios analíticos.
Crawler: descubrimiento automático del esquema en S3.
Automatización: robustez y repetibilidad en flujos de big data.

¿Cómo validar y consultar en Athena?

Abrir Athena y seleccionar “Platzi DB Transformed”.
Usar “preview” para verificar estructura y muestra de datos.
Ejecutar consultas sobre tablas transformadas: ver campos organizados como rol, asientos, tipo, área, fecha de nacimiento y género.
Caso ilustrativo: miembros del Senado de Estados Unidos, ahora estructurados y listos para análisis.

¿Listo para llevarlo a tu contexto? Comparte en comentarios qué fuentes en S3 quieres transformar y cómo planeas particionar tus salidas en Parquet.

Mario Alexander Vargas Celis

Hace 2 años

### **Creando nuestro primer ETL - Carga (Load) en AWS Glue**

La fase de **carga** en un proceso ETL consiste en almacenar los datos transformados en un destino adecuado, como Amazon S3, Amazon Redshift, DynamoDB, o una base de datos relacional en RDS. 

A continuación, te muestro cómo realizar la **carga de datos en S3** y otras opciones:

---

### **1️⃣ Cargar los datos transformados en S3 (Parquet, CSV, JSON)**  
Si en la fase de transformación trabajaste con un **DynamicFrame** en AWS Glue, puedes cargarlo a S3 usando:

```python
glueContext.write_dynamic_frame.from_options(
    frame=output_dyf,  # DynamicFrame transformado
    connection_type="s3",
    connection_options={"path": "s3://mi-bucket/output/"},
    format="parquet"  # También puedes usar "csv" o "json"
)
```
📌 **Opciones de formato:**
- `"parquet"` (Recomendado para analítica)
- `"json"`
- `"csv"` (Puede requerir opciones adicionales como delimitador)

---

### **2️⃣ Cargar los datos en Amazon Redshift**
Si deseas cargar los datos en **Amazon Redshift**, usa **JDBC** con `connection_options`:

```python
glueContext.write_dynamic_frame.from_jdbc_conf(
    frame=output_dyf,
    catalog_connection="redshift-connection",
    connection_options={
        "database": "mi_base",
        "dbtable": "mi_tabla",
        "redshiftTmpDir": "s3://mi-bucket/temp-dir/"
    },
    redshift_tmp_dir="s3://mi-bucket/temp-dir/",
    transformation_ctx="datasink4"
)
```
✅ **Requisitos para Redshift:**
- Un **Cluster Redshift** con una tabla creada.
- Conexión JDBC en **AWS Glue Connections**.
- Permisos en el **IAM Role** para escribir en Redshift.

---

### **3️⃣ Cargar los datos en Amazon DynamoDB**
Para almacenar datos en una **tabla de DynamoDB**, usa:

```python
glueContext.write_dynamic_frame.from_options(
    frame=output_dyf,
    connection_type="dynamodb",
    connection_options={"dynamodb.output.tableName": "mi_tabla_dynamodb"}
)
```
📌 **Consideraciones:**
- Asegurar que la tabla en DynamoDB ya exista.
- Configurar permisos de escritura en DynamoDB.

---

### **4️⃣ Ejecutar y Monitorear la Carga**
Después de agregar la carga en el **script de AWS Glue**, sigue estos pasos:
1. **Guarda el script** en la consola de AWS Glue o en S3.
2. **Ejecuta el Job** desde la consola de Glue.
3. **Monitorea la ejecución** en **AWS Glue > Jobs > Runs**.
4. **Revisa logs en CloudWatch** en caso de errores.

---

### **🚀 Conclusión**
- **S3:** Ideal para almacenamiento escalable en formatos Parquet, JSON o CSV.
- **Redshift:** Para cargas analíticas y BI.
- **DynamoDB:** Para almacenamiento en NoSQL con alta disponibilidad.

Si necesitas optimizar la carga, considera **particionar los datos en S3** o **usar COPY en Redshift**.

¿En qué destino específico deseas cargar los datos? 🚀
````**Creando nuestro primer ETL - Carga (Load) en AWS Glue**

La fase de **carga** en un proceso ETL consiste en almacenar los datos transformados en un destino adecuado, como Amazon S3, Amazon Redshift, DynamoDB, o una base de datos relacional en RDS.

A continuación, te muestro cómo realizar la **carga de datos en S3** y otras opciones:

### **1️⃣ Cargar los datos transformados en S3 (Parquet, CSV, JSON)**

Si en la fase de transformación trabajaste con un **DynamicFrame** en AWS Glue, puedes cargarlo a S3 usando:

glueContext.write\_dynamic\_frame.from\_options(
&#x20;   frame=output\_dyf,  # DynamicFrame transformado
&#x20;   connection\_type="s3",
&#x20;   connection\_options={"path": "s3://mi-bucket/output/"},
&#x20;   format="parquet"  # También puedes usar "csv" o "json"
)


📌 **Opciones de formato:**

* `"parquet"` (Recomendado para analítica)
* `"json"`
* `"csv"` (Puede requerir opciones adicionales como delimitador)

### **2️⃣ Cargar los datos en Amazon Redshift**

Si deseas cargar los datos en **Amazon Redshift**, usa **JDBC** con `connection_options`:

glueContext.write\_dynamic\_frame.from\_jdbc\_conf(
&#x20;   frame=output\_dyf,
&#x20;   catalog\_connection="redshift-connection",
&#x20;   connection\_options={
&#x20;       "database": "mi\_base",
&#x20;       "dbtable": "mi\_tabla",
&#x20;       "redshiftTmpDir": "s3://mi-bucket/temp-dir/"
&#x20;   },
&#x20;   redshift\_tmp\_dir="s3://mi-bucket/temp-dir/",
&#x20;   transformation\_ctx="datasink4"
)


✅ **Requisitos para Redshift:**

* Un **Cluster Redshift** con una tabla creada.
* Conexión JDBC en **AWS Glue Connections**.
* Permisos en el **IAM Role** para escribir en Redshift.

### **3️⃣ Cargar los datos en Amazon DynamoDB**

Para almacenar datos en una **tabla de DynamoDB**, usa:

glueContext.write\_dynamic\_frame.from\_options(
&#x20;   frame=output\_dyf,
&#x20;   connection\_type="dynamodb",
&#x20;   connection\_options={"dynamodb.output.tableName": "mi\_tabla\_dynamodb"}
)


📌 **Consideraciones:**

* Asegurar que la tabla en DynamoDB ya exista.
* Configurar permisos de escritura en DynamoDB.

### **4️⃣ Ejecutar y Monitorear la Carga**

Después de agregar la carga en el **script de AWS Glue**, sigue estos pasos:

1. **Guarda el script** en la consola de AWS Glue o en S3.
2. **Ejecuta el Job** desde la consola de Glue.
3. **Monitorea la ejecución** en **AWS Glue > Jobs > Runs**.
4. **Revisa logs en CloudWatch** en caso de errores.

### **🚀 Conclusión**

* **S3:** Ideal para almacenamiento escalable en formatos Parquet, JSON o CSV.
* **Redshift:** Para cargas analíticas y BI.
* **DynamoDB:** Para almacenamiento en NoSQL con alta disponibilidad.

Si necesitas optimizar la carga, considera **particionar los datos en S3** o **usar COPY en Redshift**.

¿En qué destino específico deseas cargar los datos? 🚀

Bienvenida e introducción al curso

Big Data en la Nube: Análisis, Transformación y Seguridad

Big Data en Cloud desde origen a visualización

Por qué big data en cloud es más eficiente

Extracción vs ingesta en proyectos big data

Comparativa de AWS y GCP para proyectos BigData

Arquitecturas

Arquitectura Lambda: 3 capas para datos en tiempo real

Arquitectura capa: el tiempo real como ventaja

Cómo funciona la arquitectura batch

Extracción de información

Cómo mover datos a cloud con SDK y CLI

Python y boto3 para listar buckets S3

Boto3: inicializar clients de AWS en Python

API Gateway como puerta de big data

Storage Gateway: puerta entre on-premise y S3

AWS Kinesis: streaming masivo de datos

Cómo crear Kinesis Data Stream en AWS

Despliegue automatizado de Kinesis con CloudFormation

Cómo Kinesis Firehose entrega datos en tiempo real

Configuración de Kinesis Firehose en AWS

Configuración Básica de Amazon Kinesis Firehose en AWS

MSK vs Kinesis: cuál elegir en AWS

Creación de clúster AWS MSK desde la consola

Transformación de Información

Cómo AWS Glue transforma datos en la nube

Instalación de Apache Zeppelin paso a paso

Configurar developer endpoint de AWS Glue con Zeppelin

Conexión de Apache Zeppelin con AWS

Configurar AWS Glue Crawler para poblar catálogo

Configuración de Developer Endpoint en AWS Glue

Cómo configurar AWS Glue ETL desde S3 a Parquet

Qué es EMR y cuándo usarlo

Crear tu primer cluster de AWS EMR

Conectar Apache Zeppelin a EMR

EMR automatizado con CloudFormation

AWS Lambda para proyectos de big data

Lambdas en big data: real time y batch

Configuración de AWS Lambda para Big Data

Carga de Información

Cómo Athena consulta datos en S3 con SQL

Cómo funciona AWS Athena con S3

Redshift vs Athena: cuándo usar cada uno

Configuración de cluster Redshift en AWS

AWS Lake Formation automatiza tu data lake

Consumo de información

Cómo dimensionar shards de Elasticsearch en AWS

Cómo crear un clúster Elasticsearch en AWS

Cómo funciona Kibana con Elasticsearch

QuickSight: el BI en cloud de AWS

Configuración completa de QuickSight en AWS

Seguridad, Orquestación y Automatización

5 reglas de seguridad para Big Data en AWS

Cómo AWS Macie protege datos en S3

Configuración de AWS Macie en 5 pasos

Apache Airflow vs Step Functions para ETL

Despliegue de Apache Airflow en GCP

Arquitecturas batch y streaming en AWS

Clase pública

Las cinco B de big data explicadas

Cómo configurar AWS Glue ETL desde S3 a Parquet