Creación y Ejecución de ETL con AWS Glue y S3

Clase 28 de 52 • Curso de Big Data en AWS

Resumen

¿Cómo crear y gestionar un Job en AWS Glue?

Al trabajar con grandes volúmenes de datos, la transformación de los mismos es clave. Amazon Web Services (AWS) Glue permite automatizar y escalar estas tareas de transformación mediante sus Jobs. Descubre cómo configurar y ejecutar un Job de ETL usando Glue y sigue paso a paso para optimizar tus datos.

¿Qué es un Job en AWS Glue?

Un Job en AWS Glue es un componente encargado de transformar datos. Son procesos que consisten en código de transformación que manipula los datos según se requiera. Estos son algunos pasos clave para configurar y utilizar un Job de AWS Glue:

Creación del Job:
- Accede a la consola de AWS Glue y selecciona "Jobs".
- Haz clic en "Agregar Job" y asigna un nombre, por ejemplo, "Platzi ETL".
- Define el rol de IAM utilizado, como "AWS Glue Service Role Platzi".
- Elige el tipo de ejecución, ya sea Spark o Python Shell. En este caso, seleccionamos Spark.
Configuración de Script:
- Proporciona un nuevo script Python para el ETL.
- Aprovecha las propiedades avanzadas para ajustar configuraciones como marcas de trabajo o tiempos de espera.
Transformaciones ETL:
- Edita el script Python para definir el Glue Context y especificar detalles del ETL.
- Cambia el nombre de la base de datos y especifica directorios de salida en S3.

¿Cómo realizar transformaciones con Glue?

Para comenzar la transformación de datos, es importante definir al menos tres operaciones básicas:

Creación de Dynamic Frames: Son estructuras que permiten a Glue identificar y gestionar orígenes de datos para transformaciones dinámicas.
Operaciones de datos:
- Eliminar o renombrar columnas que no son necesarias.
- Uniones (Joins) entre tablas para consolidar información de distintas fuentes.

# Ejemplo de un Join en el script Python de Glue
joined_data = DynamicFrame.fromDF(
    memberships_df.join(persons_df, memberships_df.id == persons_df.personid),
    glueContext,
    "joined_data"
)

Escritura y Formato:
- Escribe los datos procesados en formato Parquet, que optimiza espacio y rendimiento.
- Define el destino de escritura en S3 y particiona archivos según sea necesario.

¿Cómo automatizar y optimizar la ejecución de Jobs?

Automatizar la ejecución de Jobs es fundamental para optimizar el tiempo y recursos en un entorno profesional:

Uso de Crawler: Después de transformar los datos, un Crawler actualiza la metadata en AWS Glue Data Catalog.
Automatización con SDK de AWS: Orquesta ejecuciones automáticamente, maneja errores y asegura reintentos en caso de fallas.

¿Qué sucederá una vez finalizado el Job?

Una vez ejecutado el Job exitosamente, puedas verificar en S3 que los archivos se actualicen según lo previsto.

Comprueba el estado del job en la consola de AWS Glue. Debe mostrar 'succeeded' si se completó con éxito.
Verifica la estructuración y calidad de los datos transformados usando servicios como AWS Atena.

Las operaciones realizadas a través de AWS Glue son una vía poderosa y automatizada para manejar grandes volúmenes de datos. Estos pasos proporcionan un marco básico que se puede expandir y personalizar según las características y necesidades de cada proyecto de Big Data. ¡Continúa explorando y aprendiendo para maximizar el potencial de tus proyectos con AWS Glue y más!

Milton Andrés Sanabria

student•

Hola todos ! Hice el ejercicio de montar un ETL en Glue, aproveche la experiencia para escribir un articulo en Medium. Los invito a echarle un vistazo, puede complementar lo que Carlos explica. Articulo AWS Glue

Luis Val

student•

Gracias por la info

Manuel Gonzalez

student•

Se necesita bastante conocimiento Java y Python para poder configurar dichas tareas de transformación podrias recomendarme algunos links para revisar

José Mauricio Eddui Abzum Méndez

student•

Les recomiendo el formato glueparquet

john ct

student•

interesante y claro.https://docs.aws.amazon.com/es_es/glue/latest/dg/what-is-glue.html

john ct

student•

1-libraries 2-catalog db and sys names 3-directories of output s3 4-creation of dynamics frames from the source tables 5- clean and maintain some fields and others are renamed. 6- using joins sql- in the frames para crear la historia 7 write the output of the history. 8-write a simple file in the directory "xxxxlegislator_simple" 9-convert a dataframe , writing in the directory "xxxlegistlator_part" copy and paste in the ETL Glue Job

john ct

student•

una vez creado>] clic en Actions> run job

Emmanuel Corral Marco

student•

Alguien sabe como escoger el numero de archivos que salen en el particionado al hacer la escritura de los datos del dynamicframe en S3?

en mi bucket salen varios archivos parquet y solo quiero que salga 1, sucede lo mismo en tipo csv y otros tipos.

Mario Alexander Vargas Celis

student•

### **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? 🚀

Diego Armando Daza Quiroga

student•

Yo trabajo con etls en ssis de Microsoft y es mucho más fácil, tanto la instalación como la configuración del ambiente. También para desarrollar es más intuitivo. Hay una manera gráfica de trabajar con glue?

José Mauricio Eddui Abzum Méndez

student•

Hay una forma "más amigable" usando un módulo de glue llamado AWSGlue Studio

Daniel Eduardo Portugal Revilla

student•

puedes usar Glue Studio. pero ya sabe que por código es más dinámico el desarrollo. por otro lago Glue es Serverless, no se hace instalación. lo que se realizó en local es un paso extra si deseas codear desde tu entorno

Usuario anónimo

user•

Difícil