Bienvenida e introducción al curso

1

Iniciando con Big Data

2

Cloud Computing en proyectos de BigData

3

Introducción al manejo de datos en Cloud

4

Datos en Cloud

5

¿Qué nube debería utilizar en mi proyecto de Big Data?

Arquitecturas

6

Arquitecturas Lambda

7

Arquitectura Kappa

8

Arquitectura Batch

Extracción de información

9

Llevar tu información al cloud

10

Demo - Creando nuestro IDE en la nube con Python - Boto3

11

¿Cómo usar Boto3?

12

API Gateway

13

Storage Gateway

14

Kinesis Data Streams

15

Configuración de Kinesis Data Streams

16

Demo - Despegando Kinesis con Cloudformation

17

Kinesis Firehose

18

Demo - Configuración de Kinesis Firehose

19

Reto - Configurando Kinesis Firehose

20

AWS - MSK

21

Demo - Despliegue de un clúster con MSK

Transformación de Información

22

AWS - Glue

23

Demo - Instalando Apache Zeppelin

24

Creación del Developer Endpoint

25

Demo - Conectando nuestro developer Endpoint a nuestro Zeppelin Edpoint

26

Demo - Creando nuestro primer ETL - Crawling

27

Demo - Creando nuestro primer ETL - Ejecución

28

Demo - Creando nuestro primer ETL - Carga

29

AWS - EMR

30

Demo - Desplegando nuestro primer clúster con EMR

31

Demo - Conectándonos a Apache Zeppelin en EMR

32

Demo- Despliegue automático de EMR con cloudformation

33

AWS - Lambda

34

Ejemplos AWS- Lambda

35

Demo - Creando una lambda para BigData

Carga de Información

36

AWS - Athena

37

Demo - Consultando data con Athena

38

AWS - RedShift

39

Demo - Creando nuestro primer clúster de RedShift

40

AWS - Lake Formation

Consumo de información

41

AWS - ElasticSearch

42

Demo - Creando nuestro primer clúster de ElasticSearch

43

AWS - Kibana

44

AWS - QuickSight

45

Demo - Visualizando nuestra data con QuickSight

Seguridad, Orquestación y Automatización

46

Seguridad en los Datos

47

AWS Macie

48

Demo - Configurando AWS Macie

49

Apache Airflow

50

Demo - Creando nuestro primer clúster en Cloud Composer

51

Arquitectura de referencia

Clase pública

52

¿Qué es Big Data?

You don't have access to this class

Keep learning! Join and start boosting your career

Aprovecha el precio especial y haz tu profesión a prueba de IA

Antes: $249

Currency
$209
Suscríbete

Termina en:

1 Días
8 Hrs
15 Min
16 Seg
Curso de Big Data en AWS

Curso de Big Data en AWS

Carlos Andrés Zambrano Barrera

Carlos Andrés Zambrano Barrera

Demo - Creando nuestro primer ETL - Carga

28/52
Resources

How to create and manage a Job in AWS Glue?

When working with large volumes of data, data transformation is key. Amazon Web Services (AWS) Glue allows you to automate and scale these transformation tasks through its Jobs. Find out how to set up and run an ETL Job using Glue and follow step by step to optimize your data.

What is a Job in AWS Glue?

A Job in AWS Glue is a component in charge of transforming data. They are processes that consist of transformation code that manipulates data as required. Here are some key steps to set up and use an AWS Glue Job:

  1. Job Creation:

    • Log into the AWS Glue console and select "Jobs."
    • Click "Add Job" and assign a name, for example, "Platzi ETL".
    • Define the IAM role used, such as "AWS Glue Service Role Platzi".
    • Choose the execution type, either Spark or Python Shell. In this case, we select Spark.
  2. Script Configuration:

    • Provides a new Python script for ETL.
    • Take advantage of the advanced properties to adjust settings such as job flags or timeouts.
  3. ETL Transformations:

    • Edits the Python script to define the Glue Context and specify ETL details.
    • Rename the database and specify output directories in S3.

How to perform transformations with Glue?

To start the data transformation, it is important to define at least three basic operations:

  1. Dynamic Frames creation: these are structures that allow Glue to identify and manage data sources for dynamic transformations.

  2. Data operations:

    • Delete or rename columns that are not needed.
    • Joins between tables to consolidate information from different sources.
# Example of a Join in Glue Python scriptjoined_data = DynamicFrame.fromDF( memberships_df.join(persons_df, memberships_df.id == persons_df.personid), glueContext, " joined_data")
  1. Writing and Formatting:
    • Writes the processed data in Parquet format, which optimizes space and performance.
    • Defines the write destination in S3 and partitions files as needed.

How to automate and optimize Jobs execution?

Automating the execution of Jobs is essential to optimize time and resources in a professional environment:

  • Using Crawler: After transforming data, a Crawler updates the metadata in AWS Glue Data Catalog.
  • Automation with AWS SDK: Orchestrate executions automatically, handle errors and ensure retries in case of failures.

What happens after the Job is finished?

Once the Job is successfully executed, you can verify in S3 that the files are updated as scheduled.

  • Check the status of the job in the AWS Glue console. It should show 'succeeded' if it completed successfully.
  • Verify the structuring and quality of the transformed data using services such as AWS Atena.

Operations performed through AWS Glue are a powerful and automated way to handle large volumes of data. These steps provide a basic framework that can be expanded and customized according to the characteristics and needs of each Big Data project. Continue exploring and learning to maximize the potential of your projects with AWS Glue and more!

Contributions 6

Questions 1

Sort by:

Want to see more contributions, questions and answers from the community?

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

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

Les recomiendo el formato glueparquet

````js ### **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( 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`: 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: 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? 🚀
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?