Muchos clientes están interesados ​​en aumentar la productividad en su ciclo de vida de desarrollo de software mediante el uso de IA generativa. Recientemente, AWS anunció la disponibilidad general de Amazon CodeWhisperer, un complemento de codificación de IA que utiliza modelos fundamentales para mejorar la productividad de los desarrolladores de software. Con Código de Amazon Whisperer, puede aceptar rápidamente la sugerencia principal, ver más sugerencias o continuar escribiendo su propio código. Esta integración reduce el tiempo total dedicado a escribir la integración de datos y la lógica de extracción, transformación y carga (ETL). También ayuda a los programadores principiantes a escribir sus primeras líneas de código. Cuadernos de AWS Glue Studio le permite crear trabajos de integración de datos con una interfaz de portátil sin servidor basada en web.

En esta publicación, analizamos casos de uso del mundo real para CodeWhisperer con tecnología de portátiles AWS Glue Studio.

Resumen de la solución

Para esta publicación, utiliza el CSV. Conjunto de datos de ganancias de deportes electrónicos, disponible para descargar a través de Kaggle. Los datos son extraídos de eSportsEarnings.com, que proporciona información sobre las ganancias de los jugadores y equipos de eSports. El objetivo es realizar transformaciones utilizando un cuaderno de AWS Glue Studio con recomendaciones de CodeWhisperer y luego volver a escribir los datos en Servicio de almacenamiento simple de Amazon (Amazon S3) en formato de archivo Parquet, así como a Desplazamiento al rojo de Amazon.

Requisitos previos

Nuestra solución tiene los siguientes requisitos previos:

1. Configurar AWS Glue Studio.
2. Configurar un Gestión de identidades y accesos de AWS (IAM) para interactuar con CodeWhisperer. Adjunte la siguiente política a su función de IAM adjunta al cuaderno de AWS Glue Studio:

   { "Version": "2012-10-17", "Statement": [{ "Sid": "CodeWhispererPermissions", "Effect": "Allow", "Action": [ "codewhisperer:GenerateRecommendations" ], "Resource": "*" }]
   }

3. Descargar el CSV Conjunto de datos de ganancias de deportes electrónicos y sube el archivo CSV highest_earning_players.csv a la carpeta S3 que utilizará en este caso de uso.

Cree un cuaderno de AWS Glue Studio

Empecemos. Cree un nuevo trabajo de cuaderno de AWS Glue Studio completando los siguientes pasos:

1. En la consola de AWS Glue, elija Cuadernos bajo Empleos de ETL en el panel de navegación.
2. Seleccione Cuaderno Jupyter y elige Crear.
3. Nombre del trabajo, introduzca CodeWhisperer-s3toJDBC.

Se creará un nuevo cuaderno con las celdas de muestra como se muestra en la siguiente captura de pantalla.

Usamos la segunda celda por ahora, para que puedas eliminar todas las demás celdas.

1. En la segunda celda, actualice la configuración de la sesión interactiva configurando lo siguiente:
   1. Tipo de trabajador a G.1X
   2. Número de trabajadores a 3
   3. Versión de AWS Glue a 4.0
2. Además, importar el DynamicFrame módulo y current_timestamp funciona de la siguiente manera:

   from pyspark.sql.functions import current_timestamp
   from awsglue.dynamicframe import DynamicFrame

Después de realizar estos cambios, la computadora portátil debería verse como la siguiente captura de pantalla.

Ahora, asegurémonos de que CodeWhisperer esté funcionando según lo previsto. En la parte inferior derecha encontrarás el código susurrador opción al lado del Pegamento PySpark estado, como se muestra en la siguiente captura de pantalla.

Tu puedes elegir código susurrador para ver las opciones a utilizar Sugerencias automáticas.

Desarrolle su código utilizando CodeWhisperer en un cuaderno de AWS Glue Studio

En esta sección, mostramos cómo desarrollar un trabajo de cuaderno de AWS Glue para Amazon S3 como fuente de datos y fuentes de datos JDBC como destino. Para nuestro caso de uso, debemos asegurarnos de que las sugerencias automáticas estén habilitadas. Escriba su recomendación usando CodeWhisperer siguiendo los siguientes pasos:

1. Escribe un comentario en lenguaje natural (en inglés) para leer archivos Parquet desde tu depósito S3:

   # Read CSV files from S3

Después de ingresar el comentario anterior y presionar Participar, el botón CodeWhisperer al final de la página mostrará que se está ejecutando para escribir la recomendación. El resultado de la recomendación de CodeWhisperer aparecerá en la siguiente línea y el código se elige después de presionar Tab audio. Puedes aprender más en Acciones del usuario.

Después de ingresar el comentario anterior, CodeWhisperer generará un fragmento de código similar al siguiente:

df = (spark.read.format("csv") .option("header", "true") .option("inferSchema", "true") .load("s3://<bucket>/<path>/highest_earning_players.csv"))

Tenga en cuenta que debe actualizar las rutas para que coincidan con el depósito de S3 que está utilizando en lugar del depósito generado por CodeWhisperer.

Del fragmento de código anterior, CodeWhisperer usó Spark DataFrames para leer los archivos CSV.

2. Ahora puedes intentar reformular algunas palabras para obtener una sugerencia con las funciones de DynamicFrame:

# Read CSV file from S3 with the header format option using DynamicFrame"

Ahora CodeWhisperer generará un fragmento de código similar al siguiente:

dyF = glueContext.create_dynamic_frame.from_options( connection_type="s3", connection_options={ "paths": ["s3://<bucket>/<path>/highest_earning_players.csv"], "recurse": True, }, format="csv", format_options={ "withHeader": True, }, transformation_ctx="dyF")

Reformular las oraciones escritas ahora ha demostrado que después de algunas modificaciones en los comentarios que escribimos, obtuvimos la recomendación correcta de CodeWhisperer.

3. A continuación, utilice CodeWhisperer para imprimir el esquema del marco dinámico de AWS Glue anterior mediante el siguiente comentario:

   # Print the schema of the above DynamicFrame

CodeWhisperer generará un fragmento de código similar al siguiente:

dyF.printSchema()

Obtenemos el siguiente resultado.

Ahora usamos CodeWhisperer para crear algunas funciones de transformación que pueden manipular el marco dinámico de AWS Glue leído anteriormente. Comenzamos ingresando código en una nueva celda.

4. Primero, pruebe si CodeWhisperer puede utilizar las funciones de contexto correctas de AWS Glue como ResolverElección:

   # Convert the "PlayerId" type from string to integer

CodeWhisperer ha recomendado un fragmento de código similar al siguiente:

dyF = dyF.resolveChoice(specs=[('PlayerId', 'cast:long')])
dyF.printSchema()

El fragmento de código anterior no representa con precisión el comentario que ingresamos.

5. Puede aplicar la paráfrasis y simplificación de oraciones proporcionando los siguientes tres comentarios. Cada uno tiene una petición diferente y nosotros usamos el con columna Método Spark Frame, que se utiliza en tipos de columnas de fundición:

   # Convert the DynamicFrame to spark data frame
   # Cast the 'PlayerId' column from string to Integer using WithColumn function # Convert the spark frame back to DynamicFrame and print the schema

CodeWhisperer seleccionará los comandos anteriores y recomendará el siguiente fragmento de código en secuencia:

df = dyF.toDF()
df = df.withColumn("PlayerId", df["PlayerId"].cast("integer"))
dyF = DynamicFrame.fromDF(df, glueContext, "dyF")
dyF.printSchema()

El siguiente resultado confirma la PlayerId La columna se cambia de cadena a número entero.

6. Aplique el mismo proceso al AWS Glue DynamicFrame resultante para el TotalUSDPrize columna convirtiéndola de cadena a larga usando el withColumn Spark Frame funciona ingresando los siguientes comentarios:

   # Convert the dynamicFrame to Spark Frame
   # Cast the "TotalUSDPrize" column from String to long
   # Convert the spark frame back to dynamic frame and print the schema

El fragmento de código recomendado es similar al siguiente:

df = dyF.toDF()
df = df.withColumn("TotalUSDPrize", df["TotalUSDPrize"].cast("long"))
dyF = DynamicFrame.fromDF(df, glueContext, "dyF")
dyF.printSchema()

El esquema de salida del fragmento de código anterior es el siguiente.

Ahora intentaremos recomendar un fragmento de código que refleje el premio promedio de cada jugador según su código de país.

7. Para hacerlo, comience por obtener el recuento de jugadores por cada país:

   # Get the count of each country code

El fragmento de código recomendado es similar al siguiente:

country_code_count = df.groupBy("CountryCode").count()
country_code_count.show()

Obtenemos el siguiente resultado.

8. Únase al DataFrame principal con el DataFrame de recuento de códigos de país y luego agregue una nueva columna calculando el premio promedio más alto para cada jugador según su código de país:

   # Convert the DynamicFrame (dyF) to dataframe (df)
   # Join the dataframe (df) with country_code_count dataframe with respect to CountryCode column
   # Convert the spark frame back to DynamicFrame and print the schema

El fragmento de código recomendado es similar al siguiente:

df = dyF.toDF()
df = df.join(country_code_count, "CountryCode")
dyF = DynamicFrame.fromDF(df, glueContext, "dyF")
dyF.printSchema()

La salida del esquema ahora confirma que ambos DataFrames se unieron correctamente y que Count La columna se agrega al DataFrame principal.

9. Obtenga la recomendación de código en el fragmento de código para calcular el promedio TotalUSDPrize para cada código de país y agréguelo a una nueva columna:

   # Get the sum of all the TotalUSDPrize column per countrycode
   # Rename the sum column to be "SumPrizePerCountry" in the newly generated dataframe

El fragmento de código recomendado es similar al siguiente:

country_code_sum = df.groupBy("CountryCode").sum("TotalUSDPrize")
country_code_sum = country_code_sum.withColumnRenamed("sum(TotalUSDPrize)", "SumPrizePerCountry")
country_code_sum.show()

El resultado del código anterior debería verse similar al siguiente.

10. ÚNASE AL country_code_sum DataFrame con el DataFrame principal de antes y obtén el promedio de premios por jugador por país:

    # Join the above dataframe with the main dataframe with respect to CountryCode
    # Get the average Total prize in USD per player per country and add it to a new column called "AveragePrizePerPlayerPerCountry"

El fragmento de código recomendado es similar al siguiente:

df = df.join(country_code_sum, "CountryCode")
df = df.withColumn("AveragePrizePerPlayerPerCountry", df["SumPrizePerCountry"] / df["count"])

11. La última parte de la fase de transformación consiste en ordenar los datos por el premio medio más alto por jugador por país:

    # sort the above dataframe descendingly according to the highest Average Prize per player country
    # Show the top 5 rows

El fragmento de código recomendado es similar al siguiente:

df = df.sort(df["AveragePrizePerPlayerPerCountry"].desc())
df.show(5)

Las primeras cinco filas serán similares a las siguientes.

Para el último paso, escribimos DynamicFrame en Amazon S3 y en Amazon Redshift.

12. Escriba el DynamicFrame en Amazon S3 con el siguiente código:

    # Convert the data frame to DynamicFrame
    # Write the DynamicFrame to S3 in glueparquet format

La recomendación de CodeWhisperer es similar al siguiente fragmento de código:

dyF = DynamicFrame.fromDF(df, glueContext, "dyF") glueContext.write_dynamic_frame.from_options(
frame=dyF,
connection_type="s3",
connection_options={ "path": "s3://<enter your own>/", "partitionKeys": [],
},
format = "glueparquet",
)

Necesitamos corregir el fragmento de código generado después de la recomendación porque no contiene claves de partición. Como señalamos, partitionkeys está vacío, por lo que podemos tener otra sugerencia de bloque de código para configurar partitionkey y luego escríbalo en la ubicación de destino de Amazon S3. Además, de acuerdo con las actualizaciones más recientes relacionadas con la escritura de DynamicFrames en Amazon S3 usando glueparquet, format = "glueparquet" ya no se usa. En su lugar, deberá utilizar el tipo de parquet con useGlueParquetWriter habilitado

Después de las actualizaciones, nuestro código es similar al siguiente:

dyF = DynamicFrame.fromDF(df, glueContext, "dyF") glueContext.write_dynamic_frame.from_options(
frame=dyF,
connection_type="s3",
connection_options={ "path": "s3://<enter your own>/",
},
format = "parquet", format_options={ "useGlueParquetWriter": True, },
)

Otra opción aquí sería escribir los archivos en Amazon Redshift mediante una conexión JDBC.

13. Primero, ingrese el siguiente comando para verificar si CodeWhisperer entenderá el comentario en una oración y usará las funciones correctas o no:

    # Write the DynamicFrame to Redshift
    # Select only the following 3 columns in the DynamicFrame to write to redshift: CountryCode, TotalUSDPrize, NameFirst, NameLast, AveragePrizePerPlayerPerCountr

El resultado del comentario es similar al siguiente fragmento de código:

dyF = dyF.select_fields(["CountryCode", "TotalUSDPrize", "NameFirst","NameLast","AveragePrizePerPlayerPerCountry"])
glueContext.write_dynamic_frame.from_options( frame=dyF, connection_type="redshift", connection_options={ "url": "jdbc:redshift://omarglueblog.cjzxbkzmhwqm.us-east-1.redshift.amazonaws.com:5439/omarglueblog", "user": "omarglueblog", "password": "omarglueblog", "dbtable": "highest_earning_players_redshift", "driver": "com.amazon.redshift.jdbc42.Driver", "preactions": "truncate table highest_earning_players_redshift", "redshiftTmpDir": "s3://awsgluetest/tmp/", "aws_iam_role": "0000000000000000000000000:role/glue-role", }, format = "redshift", transformation_ctx="dyF" )

Como podemos ver, CodeWhisperer interpretó correctamente el comentario seleccionando solo las columnas especificadas para escribir en Amazon Redshift.

14. Ahora, utilice CodeWhisperer para escribir DynamicFrame en Amazon Redshift. Usamos el Pre-acción parámetro para ejecutar una consulta SQL para seleccionar solo ciertas columnas que se escribirán en Amazon Redshift:

    # Write the resultant DynamicFrame to Redshift # using preaction that selects only the following columns: CountryCode, TotalUSDPrize, NameFirst, NameLast, AveragePrizePerPlayerPerCountry

La recomendación de CodeWhisperer es similar al siguiente fragmento de código:

glueContext.write_dynamic_frame.from_options( frame = dyf, connection_type = "redshift", connection_options = { "url": "jdbc:redshift://awsgluetest.cjw8y5zdqmhz.us-east-1.redshift.amazonaws.com:5439/dev", "user": "awsuser", "password": "awsuser", "dbtable": "players", "preactions": "SELECT CountryCode, TotalUSDPrize, NameFirst, NameLast, AveragePrizePerPlayerPerCountry FROM highest_earning_player", "redshiftTmpDir": "s3://awsgluetest/tmp/" }, format = "glueparquet", transformation_ctx = "write_dynamic_frame")

Después de verificar el fragmento de código anterior, puede observar que hay un fragmento de código fuera de lugar format, que puedes eliminar. También puedes agregar el iam_role como entrada en connection_options. También puede notar que CodeWhisperer ha asumido automáticamente que la URL de Redshift tiene el mismo nombre que la carpeta S3 que usamos. Por lo tanto, debe cambiar la URL y el depósito del directorio temporal de S3 para reflejar sus propios parámetros y eliminar el parámetro de contraseña. El fragmento de código final debería ser similar al siguiente:

glueContext.write_dynamic_frame.from_options(
frame=dyF,
connection_type="redshift",
connection_options={ "url": "jdbc:redshift://<enter your own>.cjwjn5pzxbhx.us-east-1.redshift.amazonaws.com:5439/<enter your own>", "user": "<enter your own>", "dbtable": "<enter your own>", "driver": "com.amazon.redshift.jdbc42.Driver", "preactions": "SELECT CountryCode, TotalUSDPrize, NameFirst, NameLast, AveragePrizePerPlayerPerCountry FROM <enter your table>", "redshiftTmpDir": "<enter your own>", "aws_iam_role": "<enter your own>",
}
)

El siguiente es el código completo y los fragmentos de comentarios:

%idle_timeout 2880
%glue_version 4.0
%worker_type G.1X
%number_of_workers 3 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
from pyspark.sql.functions import current_timestamp
from awsglue.DynamicFrame import DynamicFrame sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
job = Job(glueContext) # Read CSV files from S3
dyF = glueContext.create_dynamic_frame.from_options( connection_type="s3", connection_options={ "paths": ["s3://<bucket>/<path>/highest_earning_players.csv"], "recurse": True, }, format="csv", format_options={ "withHeader": True, }, transformation_ctx="dyF") # Print the schema of the above DynamicFrame
dyF.printSchema() # Convert the DynamicFrame to spark data frame
# Cast the 'PlayerId' column from string to Integer using WithColumn function
# Convert the spark frame back to DynamicFrame and print the schema
df = dyF.toDF()
df = df.withColumn("PlayerId", df["PlayerId"].cast("integer"))
dyF = DynamicFrame.fromDF(df, glueContext, "dyF")
dyF.printSchema() # Convert the dynamicFrame to Spark Frame
# Cast the "TotalUSDPrize" column from String to long
# Convert the spark frame back to dynamic frame and print the schema
df = dyF.toDF()
df = df.withColumn("TotalUSDPrize", df["TotalUSDPrize"].cast("long"))
dyF = DynamicFrame.fromDF(df, glueContext, "dyF")
dyF.printSchema() # Get the count of each country code
country_code_count = df.groupBy("CountryCode").count()
country_code_count.show() # Convert the DynamicFrame (dyF) to dataframe (df)
# Join the dataframe (df) with country_code_count dataframe with respect to CountryCode column
# Convert the spark frame back to DynamicFrame and print the schema
df = dyF.toDF()
df = df.join(country_code_count, "CountryCode")
df.printSchema() # Get the sum of all the TotalUSDPrize column per countrycode
# Rename the sum column to be "SumPrizePerCountry"
country_code_sum = df.groupBy("CountryCode").sum("TotalUSDPrize")
country_code_sum = country_code_sum.withColumnRenamed("sum(TotalUSDPrize)", "SumPrizePerCountry")
country_code_sum.show() # Join the above dataframe with the main dataframe with respect to CountryCode
# Get the average Total prize in USD per player per country and add it to a new column called "AveragePrizePerPlayerPerCountry"
df.join(country_code_sum, "CountryCode")
df = df.withColumn("AveragePrizePerPlayerPerCountry", df["SumPrizePerCountry"] / df["count"]) # sort the above dataframe descendingly according to the highest Average Prize per player country
# Show the top 5 rows
df = df.sort(df["AveragePrizePerPlayerPerCountry"].desc())
df.show(5) # Convert the data frame to DynamicFrame
# Write the DynamicFrame to S3 in glueparquet format
dyF = DynamicFrame.fromDF(df, glueContext, "dyF") glueContext.write_dynamic_frame.from_options(
frame=dyF,
connection_type="s3",
connection_options={ "path": "s3://<enter your own>/",
},
format = "parquet", format_options={ "useGlueParquetWriter": True, },
) # Write the resultant DynamicFrame to Redshift # using preaction that selects only the following columns: CountryCode, TotalUSDPrize, NameFirst, NameLast, AveragePrizePerPlayerPerCountry
glueContext.write_dynamic_frame.from_options(
frame=dyF,
connection_type="redshift",
connection_options={ "url": "jdbc:redshift://<enter your own>.cjwjn5pzxbhx.us-east-1.redshift.amazonaws.com:5439/<enter your own>", "user": "<enter your own>", "dbtable": "<enter your own>", "driver": "com.amazon.redshift.jdbc42.Driver", "preactions": "SELECT CountryCode, TotalUSDPrize, NameFirst, NameLast, AveragePrizePerPlayerPerCountry FROM <enter your table>", "redshiftTmpDir": "<enter your own>", "aws_iam_role": "<enter your own>",
}
)

Conclusión

En esta publicación, demostramos un caso de uso del mundo real sobre cómo la integración de portátiles de AWS Glue Studio con CodeWhisperer le ayuda a crear trabajos de integración de datos más rápidamente. Puede comenzar a utilizar el cuaderno de AWS Glue Studio con CodeWhisperer para acelerar la creación de sus trabajos de integración de datos.

Para obtener más información sobre el uso de cuadernos de AWS Glue Studio y CodeWhisperer, consulte lo siguiente video.

Sobre los autores

ishan gaur Trabaja como Sr. Big Data Cloud Engineer (ETL) especializado en AWS Glue. Le apasiona ayudar a los clientes a crear flujos de análisis y cargas de trabajo ETL distribuidas y escalables en AWS.

Omar Elkharbotly es una PYME de Glue que trabaja como Big Data Cloud Support Engineer 2 (DIST). Se dedica a ayudar a los clientes a resolver problemas relacionados con sus cargas de trabajo ETL y a crear canales de análisis y procesamiento de datos escalables en AWS.

• Distribución de relaciones públicas y contenido potenciado por SEO. Consiga amplificado hoy.
• PlatoData.Network Vertical Generativo Ai. Empodérate. Accede Aquí.
• PlatoAiStream. Inteligencia Web3. Conocimiento amplificado. Accede Aquí.
• PlatoESG. Carbón, tecnología limpia, Energía, Ambiente, Solar, Gestión de residuos. Accede Aquí.
• PlatoSalud. Inteligencia en Biotecnología y Ensayos Clínicos. Accede Aquí.
• Desplazamientos de bloque. Modernización de la propiedad de compensaciones ambientales. Accede Aquí.
• Fuente: https://aws.amazon.com/blogs/big-data/explore-real-world-use-cases-for-amazon-codewhisperer-powered-by-aws-glue-studio-notebooks/