# Opciones de formato de datos para las entradas y las salidas en AWS Glue para Spark Estas páginas ofrecen información sobre la compatibilidad de características y los parámetros de configuración para los formatos de datos compatibles con Glue AWS de Spark.. Consulte a continuación una descripción del uso y la aplicabilidad de esta información. ## Compatibilidad de características en todos los formatos de datos en AWS Glue Cada formato de datos puede admitir diferentes características de AWS Glue. Las siguientes características comunes pueden o no ser compatibles en función del tipo de formato. Consulte la documentación del formato de datos para comprender cómo aprovechar nuestras características para cumplir sus requisitos. | | | | --- |--- | | Lectura | AWS Glue puede reconocer e interpretar este formato de datos sin recursos adicionales, como conectores. | | Escritura | AWS Glue puede escribir datos en este formato sin recursos adicionales. Puede incluir bibliotecas de terceros en su trabajo y utilizar funciones estándares de Apache Spark para escribir datos, como lo haría en otros entornos de Spark. Para obtener más información sobre estas bibliotecas, consulte [Uso de bibliotecas de Python con AWS Glue](aws-glue-programming-python-libraries.md). | | Lectura de streaming | AWS Glue puede reconocer e interpretar este formato de datos a partir de una transmisión de mensajes de Apache Kafka, Amazon Managed Streaming para Apache Kafka o Amazon Kinesis. Esperamos que las transmisiones presenten los datos en un formato coherente, de manera que se lean en DataFrames. | | Grupo de archivos pequeños | AWS Glue puede agrupar archivos para enviar trabajos en lotes a cada nodo cuando se realizan transformaciones de AWS Glue. Esto puede mejorar de forma significativa el rendimiento de las cargas de trabajo que implican grandes cantidades de archivos pequeños. Para obtener más información, consulte [Lectura de archivos de entrada en grupos más grandes](grouping-input-files.md). | | Marcadores de trabajo | AWS Glue puede realizar un seguimiento del progreso de las transformaciones que realizan el mismo trabajo en el mismo conjunto de datos en las ejecuciones de trabajos con marcadores de trabajo. Esto puede mejorar el rendimiento de las cargas de trabajo que involucran conjuntos de datos en los que solo es necesario trabajar en los datos nuevos desde la última ejecución del trabajo. Para obtener más información, consulte [Seguimiento de los datos procesados mediante marcadores de trabajo](monitor-continuations.md). | ## Parámetros utilizados para interactuar con formatos de datos en AWS Glue Ciertos tipos de conexión de AWS Glue admiten varios tipos de `format`, por lo que se requiere que especifique información sobre el formato de datos con un objeto `format_options` cuando utiliza métodos como `GlueContext.write_dynamic_frame.from_options`. + `s3`: para obtener más información, consulte Tipos y opciones de conexión para ETL en AWS Glue: [Parámetros de conexión S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). También puede ver la documentación de los métodos que facilitan este tipo de conexión: [create\$1dynamic\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options) y [write\$1dynamic\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options) en Python y los métodos de Scala [def getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat) y [def getSinkWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSinkWithFormat) correspondientes. + `kinesis`: para obtener más información, consulte Tipos y opciones de conexión para ETL en AWS Glue: [Parámetros de conexión de Kinesis](aws-glue-programming-etl-connect-kinesis-home.md#aws-glue-programming-etl-connect-kinesis). También puede ver la documentación del método que facilita este tipo de conexión: [create\$1data\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create-dataframe-from-options) y el método de Scala [def createDataFrameFromOptions](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-createDataFrameFromOptions) correspondiente. + `kafka`: para obtener más información, consulte Tipos y opciones de conexión para ETL en AWS Glue: [Parámetros de conexión de Kafka](aws-glue-programming-etl-connect-kafka-home.md#aws-glue-programming-etl-connect-kafka). También puede ver la documentación del método que facilita este tipo de conexión: [create\$1data\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create-dataframe-from-options) y el método de Scala [def createDataFrameFromOptions](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-createDataFrameFromOptions) correspondiente. Algunos tipos de conexión no requieren `format_options`. Por ejemplo, en uso normal, una conexión de JDBC a una base de datos relacional recupera datos en un formato de datos tabular y consistente. Por lo tanto, la lectura desde una conexión de JDBC no requeriría `format_options`. Algunos métodos para leer y escribir datos en Glue no requieren `format_options`. Por ejemplo, el uso de `GlueContext.create_dynamic_frame.from_catalog` con rastreadores de AWS Glue. Los rastreadores determinan la forma de los datos. Cuando se utilicen rastreadores, el clasificador de AWS Glue examinará los datos para tomar decisiones inteligentes sobre cómo representar el formato de datos. Luego, almacenará una representación de los datos en Data Catalog de AWS Glue, que se puede utilizar dentro de un script de ETL de AWS Glue para recuperar los datos con el método `GlueContext.create_dynamic_frame.from_catalog`. Los rastreadores eliminan la necesidad de especificar de forma manual la información sobre el formato de los datos. Para trabajos que acceden a tablas que se rigen por AWS Lake Formation, AWS Glue admite la lectura y escritura de todos los formatos admitidos por las tablas que rige Lake Formation. Para obtener la lista actualizada de los formatos admitidos para tablas que se rigen por AWS Lake Formation, consulte [Notas y restricciones para las tablas regidas](https://docs.aws.amazon.com/lake-formation/latest/dg/governed-table-restrictions.html) en la *Guía para desarrolladores de AWS Lake Formation*. **nota** Para escribir Apache Parquet, ETL de AWS Glue solo admite la escritura en una tabla regida al especificar una opción para un tipo de escritor de Parquet personalizado optimizado para marcos dinámicos. Al escribir en una tabla regida con el formato de `parquet`, debe agregar la clave `useGlueParquetWriter` con un valor de `true` en los parámetros de la tabla. **Topics** + [Compatibilidad de características en todos los formatos de datos en AWS Glue](#aws-glue-programming-etl-format-features) + [Parámetros utilizados para interactuar con formatos de datos en AWS Glue](#aws-glue-programming-etl-format-parameters) + [Uso del formato CSV en AWS Glue](aws-glue-programming-etl-format-csv-home.md) + [Uso del formato Parquet en AWS Glue](aws-glue-programming-etl-format-parquet-home.md) + [Uso del formato XML en AWS Glue](aws-glue-programming-etl-format-xml-home.md) + [Uso del formato Avro en AWS Glue](aws-glue-programming-etl-format-avro-home.md) + [Uso del formato grokLog en AWS Glue](aws-glue-programming-etl-format-grokLog-home.md) + [Uso del formato Ion en AWS Glue](aws-glue-programming-etl-format-ion-home.md) + [Uso del formato JSON en AWS Glue](aws-glue-programming-etl-format-json-home.md) + [Uso del formato ORC en AWS Glue](aws-glue-programming-etl-format-orc-home.md) + [Uso de marcos de lagos de datos con trabajos de ETL de AWS Glue](aws-glue-programming-etl-datalake-native-frameworks.md) + [Referencia de configuración compartida](#aws-glue-programming-etl-format-shared-reference) # Uso del formato CSV en AWS Glue AWS Glue recupera datos de fuentes y escribe datos en destinos almacenados y transportados en varios formatos de datos. Si sus datos se almacenan o transportan en formato de datos CSV, este documento presenta las funciones disponibles para usar sus datos en AWS Glue. AWS Glue admite el formato de archivo de valores separados por comas (CSV). Este formato es un formato de datos mínimo basado en filas. Los CSV a menudo no se ajustan estrictamente a un estándar, pero puede consultar [RFC 4180](https://tools.ietf.org/html/rfc4180) y [RFC 7111](https://tools.ietf.org/html/rfc7111) para obtener más información. Puede usar AWS Glue para leer los CSV de Amazon S3 y de orígenes de streaming, o para escribir los CSV en Amazon S3. Puede leer y escribir archivos `bzip` y `gzip` que contengan archivos CSV de S3. Debe configurar el comportamiento de compresión en el [Parámetros de conexión S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) en lugar de en la configuración que se describe en esta página. En la siguiente tabla se muestran las características comunes de AWS Glue que admiten la opción de formato CSV. | Lectura | Escritura | Lectura de streaming | Grupo de archivos pequeños | Marcadores de trabajo | | --- | --- | --- | --- | --- | | Compatible | Soportado | Soportado | Soportado | Compatible | ## Ejemplo: leer archivos o carpetas CSV de S3 **Requisitos previos:** necesitará las rutas de S3 (`s3path`) en las carpetas o archivos CSV que desee leer. **Configuración:** en las opciones de la función, especifique `format="csv"`. En sus `connection_options`, utilice la clave `paths` para especificar `s3path`. Puede configurar la forma en que el lector interactúa con S3 en `connection_options`. Para obtener más información, consulte Tipos y opciones de conexión para ETL en AWS Glue: [Parámetros de conexión S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Puede configurar el modo en que el lector interpreta los archivos CSV en su `format_options`. Para obtener más información, consulte [Referencia de configuración de CSV](#aws-glue-programming-etl-format-csv-reference). El siguiente script de ETL de AWS Glue muestra el proceso de lectura de archivos o carpetas CSV desde S3. Proporcionamos un lector de CSV personalizado con optimizaciones de rendimiento para flujos de trabajo comunes a través de la clave de configuración `optimizePerformance`. Para determinar si este lector es adecuado para su carga de trabajo, consulte [Optimice el rendimiento de lectura con el lector CSV SIMD vectorizado](#aws-glue-programming-etl-format-simd-csv-reader). ------ #### [ Python ] Para este ejemplo, use el método [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options). ``` # Example: Read CSV from S3 # For show, we handle a CSV with a header row. Set the withHeader option. # Consider whether optimizePerformance is right for your workflow. from pyspark.context import SparkContext from awsglue.context import GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) spark = glueContext.spark_session dynamicFrame = glueContext.create_dynamic_frame.from_options( connection_type="s3", connection_options={"paths": ["s3://s3path"]}, format="csv", format_options={ "withHeader": True, # "optimizePerformance": True, }, ) ``` También puede usar DataFrames en un script (`pyspark.sql.DataFrame`). ``` dataFrame = spark.read\ .format("csv")\ .option("header", "true")\ .load("s3://s3path") ``` ------ #### [ Scala ] Para este ejemplo, use la operación [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat). ``` // Example: Read CSV from S3 // For show, we handle a CSV with a header row. Set the withHeader option. // Consider whether optimizePerformance is right for your workflow. import com.amazonaws.services.glue.util.JsonOptions import com.amazonaws.services.glue.{DynamicFrame, GlueContext} import org.apache.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) val dynamicFrame = glueContext.getSourceWithFormat( formatOptions=JsonOptions("""{"withHeader": true}"""), connectionType="s3", format="csv", options=JsonOptions("""{"paths": ["s3://s3path"], "recurse": true}""") ).getDynamicFrame() } } ``` También puede usar DataFrames en un script (`org.apache.spark.sql.DataFrame`). ``` val dataFrame = spark.read .option("header","true") .format("csv") .load("s3://s3path“) ``` ------ ## Ejemplo: escribir archivos y carpetas CSV en S3 **Requisitos previos:** necesitará un DataFrame inicializado (`dataFrame`) o un DynamicFrame (`dynamicFrame`). También necesitará la ruta de salida S3 prevista, `s3path`. **Configuración:** en las opciones de la función, especifique `format="csv"`. En sus `connection_options`, utilice la clave `paths` para especificar `s3path`. Puede configurar la forma en que el escritor interactúa con S3 en `connection_options`. Para obtener más información, consulte Tipos y opciones de conexión para ETL en AWS Glue: [Parámetros de conexión S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Puede configurar la forma en que la operación escribe el contenido de los archivos en `format_options`. Para obtener más información, consulte [Referencia de configuración de CSV](#aws-glue-programming-etl-format-csv-reference). El siguiente script de ETL de AWS Glue muestra el proceso de escritura de archivos y carpetas CSV en S3. ------ #### [ Python ] Para este ejemplo, use el método [write\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options). ``` # Example: Write CSV to S3 # For show, customize how we write string type values. Set quoteChar to -1 so our values are not quoted. from pyspark.context import SparkContext from awsglue.context import GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) glueContext.write_dynamic_frame.from_options( frame=dynamicFrame, connection_type="s3", connection_options={"path": "s3://s3path"}, format="csv", format_options={ "quoteChar": -1, }, ) ``` También puede usar DataFrames en un script (`pyspark.sql.DataFrame`). ``` dataFrame.write\ .format("csv")\ .option("quote", None)\ .mode("append")\ .save("s3://s3path") ``` ------ #### [ Scala ] Para este ejemplo, use el método [getSinkWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSinkWithFormat). ``` // Example: Write CSV to S3 // For show, customize how we write string type values. Set quoteChar to -1 so our values are not quoted. import com.amazonaws.services.glue.util.JsonOptions import com.amazonaws.services.glue.{DynamicFrame, GlueContext} import org.apache.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) glueContext.getSinkWithFormat( connectionType="s3", options=JsonOptions("""{"path": "s3://s3path"}"""), format="csv" ).writeDynamicFrame(dynamicFrame) } } ``` También puede usar DataFrames en un script (`org.apache.spark.sql.DataFrame`). ``` dataFrame.write .format("csv") .option("quote", null) .mode("Append") .save("s3://s3path") ``` ------ ## Referencia de la configuración de CVS Puede utilizar las siguientes `format_options` donde las bibliotecas de AWS Glue especifiquen `format="csv"`: + `separator`: especifica el carácter delimitador. El valor predeterminado es una coma, pero puede especificarse cualquier otro carácter. + **Tipo:** Texto, **Valor predeterminado:** `","` + `escaper`: especifica un carácter que se usa para aplicar escape. Esta opción solo se usa cuando se leen archivos CSV, no cuando se escriben. Si se habilita, el carácter que va inmediatamente después se usa tal cual, excepto un pequeño conjunto de escapes conocidos (`\n`, `\r`, `\t` y `\0`). + **Tipo:** Texto, **Valor predeterminado:** ninguno + `quoteChar`: especifica el carácter que se usa para aplicar comillas. El carácter predeterminado es una comilla doble. Establezca esta opción en `-1` para desactivar las comillas por completo. + **Tipo:** Texto, **Valor predeterminado:** `'"'` + `multiLine`: especifica si un solo registro puede abarcar varias líneas. Esto puede suceder cuando un campo contiene un carácter de nueva línea entre comillas. Debe configurar esta opción en `True` si un registro abarca varias líneas. Habilitar `multiLine` podría disminuir el rendimiento ya que requiere una división de archivos más cuidadosa durante el análisis. + **Tipo:** Booleano, **Valor predeterminado:** `false` + `withHeader`: especifica si la primera línea se debe tratar como un encabezado. Esta opción se puede utilizar en la clase `DynamicFrameReader`. + **Tipo:** Booleano, **Valor predeterminado:** `false` + `writeHeader`: especifica si se debe escribir el encabezado en la salida. Esta opción se puede utilizar en la clase `DynamicFrameWriter`. + **Tipo:** Booleano, **Valor predeterminado:** `true` + `skipFirst`: especifica si se debe omitir la primera línea de datos. + **Tipo:** Booleano, **Valor predeterminado:** `false` + `optimizePerformance`: especifica si se debe utilizar el lector CSV SIMD avanzado junto con los formatos de memoria columnar basados en Apache Arrow. Solo se encuentra disponible en 3.0\$1 AWS Glue. + **Tipo:** Booleano, **Valor predeterminado:** `false` + `strictCheckForQuoting`: al escribir archivos CSV, Glue puede agregar comillas a los valores que interpreta como cadenas. Esto se hace para evitar la ambigüedad en lo que está escrito. Para ahorrar tiempo a la hora de decidir qué escribir, Glue puede citar en determinadas situaciones en las que las citas no son necesarias. Si se habilita una verificación estricta, el cálculo será más intensivo y solo cotizará cuando sea estrictamente necesario. Solo se encuentra disponible en 3.0\$1 AWS Glue. + **Tipo:** Booleano, **Valor predeterminado:** `false` ## Optimice el rendimiento de lectura con el lector CSV SIMD vectorizado AWS Glue versión 3.0 agrega un lector de CSV optimizado que puede acelerar significativamente el rendimiento general del trabajo en comparación con los lectores de CSV basados en filas. El lector optimizado: + Usa las instrucciones de la CPU SIMD para leer desde el disco + Escribe inmediatamente los registros en la memoria en un formato de columnas (Apache Arrow) + Divide los registros en lotes Esto ahorra tiempo de procesamiento cuando los registros se agrupan en lotes o se convierten a un formato de columnas más adelante. Algunos ejemplos son cuando se cambian esquemas o se recuperan datos por columna. Para usar el lector optimizado, configure `"optimizePerformance"` como `true` en `format_options` o propiedad de tabla. ``` glueContext.create_dynamic_frame.from_options( frame = datasource1, connection_type = "s3", connection_options = {"paths": ["s3://s3path"]}, format = "csv", format_options={ "optimizePerformance": True, "separator": "," }, transformation_ctx = "datasink2") ``` **Limitaciones para el lector CSV vectorizado** Tenga en cuenta las siguientes limitaciones del lector de CSV vectorizado: + No soporta opciones de formato `multiLine` y `escaper`. Utiliza el `escaper` predeterminado del carácter de comillas dobles `'"'`. Cuando se establecen estas opciones, AWS Glue automáticamente vuelve a utilizar el lector CSV basado en filas. + No soporta la creación de un DynamicFrame con [ChoiceType](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-pyspark-extensions-types.html#aws-glue-api-crawler-pyspark-extensions-types-awsglue-choicetype). + No soporta la creación de un DynamicFrame con [registros de error](https://docs.aws.amazon.com/glue/latest/dg/glue-etl-scala-apis-glue-dynamicframe-class.html#glue-etl-scala-apis-glue-dynamicframe-class-defs-errorsAsDynamicFrame). + No soporta la lectura de archivos CSV con caracteres multibyte, como caracteres japoneses o chinos. # Uso del formato Parquet en AWS Glue AWS Glue recupera datos de fuentes y escribe datos en destinos almacenados y transportados en varios formatos de datos. Si sus datos se almacenan o transportan en el formato de datos Parquet, este documento presenta las funciones disponibles para usar sus datos en AWS Glue AWS Glue admite el uso del formato Parquet. Este formato es un formato de datos basado en columnas y orientado al rendimiento. Para obtener una introducción al formato por parte de la autoridad de normalización, consulte [Información general de la documentación de Apache Parquet](https://parquet.apache.org/docs/overview/). Puede usar AWS Glue para leer archivos Parquet de Amazon S3 y de orígenes de streaming, como también escribir archivos Parquet en Amazon S3. Puede leer y escribir archivos `bzip` y `gzip` que contengan archivos Parquet de S3. Debe configurar el comportamiento de compresión en el [Parámetros de conexión S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) en lugar de en la configuración que se describe en esta página. En la siguiente tabla se muestran las características comunes de AWS Glue que admiten la opción de formato Parquet. | Lectura | Escritura | Lectura de streaming | Grupo de archivos pequeños | Marcadores de trabajo | | --- | --- | --- | --- | --- | | Compatible | Soportado | Compatible | No se admite | Compatible\$1 | \$1 Compatible con AWS Glue versión 1.0 y posterior ## Ejemplo: leer archivos o carpetas de Parquet desde S3 **Requisitos previos:** necesitará las rutas de S3 (`s3path`) en las carpetas o archivos Parquet que desee leer. **Configuración:** en las opciones de la función, especifique `format="parquet"`. En sus `connection_options`, utilice la clave `paths` para especificar su `s3path`. Puede configurar la forma en que el lector interactúa con S3 en la `connection_options`. Para obtener más información, consulte Tipos y opciones de conexión para ETL en AWS Glue: [Parámetros de conexión S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Puede configurar la forma en que el lector interpreta los archivos Parquet en sus `format_options`. Para obtener más información, consulte [Referencia de configuración de Parquet](#aws-glue-programming-etl-format-parquet-reference). El siguiente script de ETL de AWS Glue muestra el proceso de lectura de archivos o carpetas Parquet desde S3: ------ #### [ Python ] Para este ejemplo, use el método [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options). ``` # Example: Read Parquet from S3 from pyspark.context import SparkContext from awsglue.context import GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) spark = glueContext.spark_session dynamicFrame = glueContext.create_dynamic_frame.from_options( connection_type = "s3", connection_options = {"paths": ["s3://s3path/"]}, format = "parquet" ) ``` También puede usar DataFrames en un script (`pyspark.sql.DataFrame`). ``` dataFrame = spark.read.parquet("s3://s3path/") ``` ------ #### [ Scala ] Para este ejemplo, use el método [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat). ``` // Example: Read Parquet from S3 import com.amazonaws.services.glue.util.JsonOptions import com.amazonaws.services.glue.{DynamicFrame, GlueContext} import org.apache.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) val dynamicFrame = glueContext.getSourceWithFormat( connectionType="s3", format="parquet", options=JsonOptions("""{"paths": ["s3://s3path"]}""") ).getDynamicFrame() } } ``` También puede usar DataFrames en un script (`org.apache.spark.sql.DataFrame`). ``` spark.read.parquet("s3://s3path/") ``` ------ ## Ejemplo: escribir archivos y carpetas de Parquet en S3 **Requisitos previos:** necesitará un DataFrame inicializado (`dataFrame`) o DynamicFrame (`dynamicFrame`). También necesitará la ruta de salida S3 prevista, `s3path`. **Configuración:** en las opciones de la función, especifique `format="parquet"`. En sus `connection_options`, utilice la clave `paths` para especificar `s3path`. Puede modificar aún más la forma en que el escritor interactúa con S3 en las `connection_options`. Para obtener más información, consulte Tipos y opciones de conexión para ETL en AWS Glue: [Parámetros de conexión S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Puede configurar la forma en que la operación escribe el contenido de los archivos en `format_options`. Para obtener más información, consulte [Referencia de configuración de Parquet](#aws-glue-programming-etl-format-parquet-reference). El siguiente script de ETL de AWS Glue muestra el proceso de escritura de archivos y carpetas Parquet en S3. Proporcionamos un escritor de Parquet personalizado con optimizaciones de rendimiento para DynamicFrames, a través de la clave de la configuración `useGlueParquetWriter`. Para determinar si este escritor es adecuado para su carga de trabajo, consulte [Escritor de Glue Parquet](#aws-glue-programming-etl-format-glue-parquet-writer). ------ #### [ Python ] Para este ejemplo, use el método [write\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options). ``` # Example: Write Parquet to S3 # Consider whether useGlueParquetWriter is right for your workflow. from pyspark.context import SparkContext from awsglue.context import GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) glueContext.write_dynamic_frame.from_options( frame=dynamicFrame, connection_type="s3", format="parquet", connection_options={ "path": "s3://s3path", }, format_options={ # "useGlueParquetWriter": True, }, ) ``` También puede usar DataFrames en un script (`pyspark.sql.DataFrame`). ``` df.write.parquet("s3://s3path/") ``` ------ #### [ Scala ] Para este ejemplo, use el método [getSinkWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSinkWithFormat). ``` // Example: Write Parquet to S3 // Consider whether useGlueParquetWriter is right for your workflow. import com.amazonaws.services.glue.util.JsonOptions import com.amazonaws.services.glue.{DynamicFrame, GlueContext} import org.apache.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) glueContext.getSinkWithFormat( connectionType="s3", options=JsonOptions("""{"path": "s3://s3path"}"""), format="parquet" ).writeDynamicFrame(dynamicFrame) } } ``` También puede usar DataFrames en un script (`org.apache.spark.sql.DataFrame`). ``` df.write.parquet("s3://s3path/") ``` ------ ## Referencia de configuración de Parquet Puede utilizar las siguientes `format_options` donde las bibliotecas de AWS Glue especifiquen `format="parquet"`: + `useGlueParquetWriter`: especifica el uso de un escritor Parquet personalizado que tiene optimizaciones de rendimiento para flujos de trabajo de DynamicFrame. Para obtener más información sobre el uso, consulte [Escritor de Glue Parquet](#aws-glue-programming-etl-format-glue-parquet-writer). + **Tipo:** Booleano, **Valor predeterminado:**`false` + `compression`: especifica el códec de compresión utilizado. Los valores son totalmente compatibles con `org.apache.parquet.hadoop.metadata.CompressionCodecName`. + **Tipo:** Texto enumerado, **Valor predeterminado:** `"snappy"` + Valores: `"uncompressed"`, `"snappy"`, `"gzip"` y `"lzo"` + `blockSize`: especifica el tamaño en bytes de un grupo de filas que se están almacenando en el búfer. Se usa para ajustar el rendimiento. El tamaño debe dividirse exactamente en un número de megabytes. + **Tipo:** Numérico, **Valor predeterminado:**`134217728` + El valor predeterminado es igual a 128 MB. + `pageSize`: especifica el tamaño en bytes de una página. Se usa para ajustar el rendimiento. Una página es la unidad más pequeña que debe leerse por completo para obtener acceso a un único registro. + **Tipo:** Numérico, **Valor predeterminado:**`1048576` + El valor predeterminado es igual a 1 MB. **nota** Además, se pueden transferir a este formato las opciones que acepte el código SparkSQL subyacente mediante el parámetro de mapa `connection_options`. Por ejemplo, se puede establecer una configuración de Spark como [mergeSchema](https://spark.apache.org/docs/latest/sql-data-sources-parquet.html#schema-merging) para que el lector de Spark de AWS Glue fusione el esquema para todos los archivos. ## Optimice el rendimiento de escritura con el escritor de AWS Glue Parquet **nota** Históricamente, se ha accedido al escritor de AWS Glue Parquet mediante el tipo de formato `glueparquet`. Ya no se aboga por este patrón de acceso. En su lugar, utilice el tipo `parquet` con `useGlueParquetWriter` habilitado. El escritor AWS Glue Parquet tiene mejoras de rendimiento que permiten escribir archivos Parquet más rápidamente. El escritor tradicional calcula un esquema antes de escribir. El formato Parquet no almacena el esquema de forma que se pueda recuperar rápidamente, por lo que puede llevar algún tiempo. Con el escritor de AWS Glue Parquet, no se requiere un esquema precalculado. A medida que llegan los datos, el escritor calcula y modifica el esquema e forma dinámica. Cuando especifique `useGlueParquetWriter`, tenga en cuenta las siguientes limitaciones: + El escritor solo admite la evolución de los esquemas (como agregar o eliminar columnas) pero no permite cambiar los tipos de columnas, como sucede con `ResolveChoice`. + El escritor no puede almacenar un DataFrame vacío, por ejemplo, para escribir un archivo solo de esquema. Al realizar la integración con el Catálogo de datos de AWS Glue mediante la configuración de `enableUpdateCatalog=True`, si se intenta escribir un DataFrame vacío, no se actualizará el Catálogo de datos. Esto creará una tabla sin esquema en el Catálogo de datos. Si su transformación no requiere estas limitaciones, activar el escritor AWS Glue Parquet debería aumentar el rendimiento. # Uso del formato XML en AWS Glue AWS Glue recupera datos de fuentes y escribe datos en destinos almacenados y transportados en varios formatos de datos. Si sus datos se almacenan o transportan en formato de datos XML, este documento presenta las funciones disponibles para usar sus datos en AWS Glue. AWS Glue admite el uso del formato XML. Este formato representa estructuras de datos altamente configurables y rígidamente definidas que no están basadas en filas o columnas. XML es altamente estandarizado. Para obtener una introducción al formato de la autoridad de normalización, consulte [Elementos esenciales de XML](https://www.w3.org/standards/xml/core). Puede usar AWS Glue para leer archivos XML desde Amazon S3, así como archivos `bzip` y `gzip` que contengan archivos XML. Debe configurar el comportamiento de compresión en el [Parámetros de conexión S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) en lugar de en la configuración que se describe en esta página. En la siguiente tabla se muestran las características comunes de AWS Glue que admiten la opción de formato XML. | Lectura | Escritura | Lectura de streaming | Grupo de archivos pequeños | Marcadores de trabajo | | --- | --- | --- | --- | --- | | Compatible | No se admite | No se admite | Soportado | Compatible | ## Ejemplo: leer XML desde S3 El lector de XML toma un nombre de etiqueta XML. Examina los elementos con esa etiqueta dentro de su entrada para inferir un esquema y rellena un DynamicFrame con los valores correspondientes. La funcionalidad XML de AWS Glue se comporta de forma similar al [Origen de datos XML para Apache Spark](https://github.com/databricks/spark-xml). Es posible que pueda obtener información sobre el comportamiento básico comparando este lector con la documentación de ese proyecto. **Requisitos previos:** necesitará las rutas de S3 (`s3path`) en las carpetas o archivos XML que desee leer, y cierta información sobre su archivo XML. También necesitará la etiqueta del elemento XML que desea leer, `xmlTag`. **Configuración:** en las opciones de la función, especifique `format="xml"`. En sus `connection_options`, utilice la clave `paths` para especificar `s3path`. Puede configurar aún más la forma en que el lector interactúa con S3 en la `connection_options`. Para obtener más información, consulte Tipos y opciones de conexión para ETL en AWS Glue: [Parámetros de conexión S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). En sus `format_options`, utilice la clave `rowTag` para especificar `xmlTag`. Puede configurar aún más la forma en que el lector interpreta los archivos XML en sus `format_options`. Para obtener más información, consulte [Referencia de configuración de XML](#aws-glue-programming-etl-format-xml-reference). El siguiente script de ETL de AWS Glue muestra el proceso de lectura de archivos o carpetas XML desde S3. ------ #### [ Python ] Para este ejemplo, use el método [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options). ``` # Example: Read XML from S3 # Set the rowTag option to configure the reader. from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) dynamicFrame = glueContext.create_dynamic_frame.from_options( connection_type="s3", connection_options={"paths": ["s3://s3path"]}, format="xml", format_options={"rowTag": "xmlTag"}, ) ``` También puede usar DataFrames en un script (`pyspark.sql.DataFrame`). ``` dataFrame = spark.read\ .format("xml")\ .option("rowTag", "xmlTag")\ .load("s3://s3path") ``` ------ #### [ Scala ] Para este ejemplo, use la operación [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat). ``` // Example: Read XML from S3 // Set the rowTag option to configure the reader. import com.amazonaws.services.glue.util.JsonOptions import com.amazonaws.services.glue.GlueContext import org.apache.spark.sql.SparkSession val glueContext = new GlueContext(SparkContext.getOrCreate()) val sparkSession: SparkSession = glueContext.getSparkSession object GlueApp { def main(sysArgs: Array[String]): Unit = { val dynamicFrame = glueContext.getSourceWithFormat( formatOptions=JsonOptions("""{"rowTag": "xmlTag"}"""), connectionType="s3", format="xml", options=JsonOptions("""{"paths": ["s3://s3path"], "recurse": true}""") ).getDynamicFrame() } ``` También puede usar DataFrames en un script (`org.apache.spark.sql.DataFrame`). ``` val dataFrame = spark.read .option("rowTag", "xmlTag") .format("xml") .load("s3://s3path“) ``` ------ ## Referencia de configuración de XML Puede utilizar las siguientes `format_options` donde las bibliotecas de AWS Glue especifiquen `format="xml"`: + `rowTag`: especifica la etiqueta XML en el archivo que se tratará como una fila. Las etiquetas de fila no pueden autocerrarse. + **Tipo:** Texto, **Obligatorio** + `encoding`: especifica la codificación de caracteres. Puede ser el nombre o alias de un [Charset](https://docs.oracle.com/javase/8/docs/api/java/nio/charset/Charset.html) compatible con nuestro entorno de tiempo de ejecución. No ofrecemos garantías específicas en cuanto a la compatibilidad con la codificación, pero las codificaciones principales deberían funcionar. + **Tipo:** Texto, **Valor predeterminado:** `"UTF-8"` + `excludeAttribute`: especifica si desea excluir o no atributos en elementos. + **Tipo:** Booleano, **Valor predeterminado:** `false` + `treatEmptyValuesAsNulls`: especifica si los espacios en blanco se tratan como un valor nulo. + **Tipo:** Booleano, **Valor predeterminado:** `false` + `attributePrefix`: un prefijo de atributos para diferenciarlos del texto de elementos secundarios. Este prefijo se utiliza para los nombres de campo. + **Tipo:** Texto, **Valor predeterminado:** `"_"` + `valueTag`: la etiqueta que se utiliza para un valor cuando hay atributos en el elemento que no tienen elementos secundarios. + **Tipo:** Texto, **Valor predeterminado:** `"_VALUE"` + `ignoreSurroundingSpaces`: especifica si se deben ignorar los espacios en blanco alrededor de los valores. + **Tipo:** Booleano, **Valor predeterminado:** `false` + `withSchema`: contiene el esquema esperado, en situaciones en las que se desea anular el esquema inferido. Si no utiliza esta opción, AWS Glue infiere el esquema a partir de los datos XML. + **Tipo:** Texto, **Valor predeterminado:** no aplicable + El valor debe ser un objeto JSON que represente un `StructType`. ## Especifique manualmente el esquema XML **Ejemplo del esquema XML manual** Este es un ejemplo de uso de la opción del formato `withSchema` para especificar el esquema para los datos XML. ``` from awsglue.gluetypes import * schema = StructType([ Field("id", IntegerType()), Field("name", StringType()), Field("nested", StructType([ Field("x", IntegerType()), Field("y", StringType()), Field("z", ChoiceType([IntegerType(), StringType()])) ])) ]) datasource0 = create_dynamic_frame_from_options( connection_type, connection_options={"paths": ["s3://xml_bucket/someprefix"]}, format="xml", format_options={"withSchema": json.dumps(schema.jsonValue())}, transformation_ctx = "" ) ``` # Uso del formato Avro en AWS Glue AWS Glue recupera datos de fuentes y escribe datos en destinos almacenados y transportados en varios formatos de datos. Si los datos se almacenan o se transportan en formato de datos Avro, este documento presenta las características disponibles para utilizar los datos en AWS Glue. AWS Glue admite el uso del formato Avro. Este es un formato de datos basado en filas y orientado al rendimiento. Para obtener una introducción al formato por parte de la autoridad de normalización, consulte [Documentación de Apache Avro 1.8.2](https://avro.apache.org/docs/1.8.2/). Puede utilizar AWS Glue para leer archivos Avro de Amazon S3 y de orígenes de streaming, como también para escribir archivos Avro en Amazon S3. Puede leer y escribir archivos `bzip2` y `gzip` que contengan archivos Avro de S3. Además, puede escribir `deflate`, `snappy` y `xz` archivos que contengan archivos Avro. Debe configurar el comportamiento de compresión en el [Parámetros de conexión S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) en lugar de en la configuración que se describe en esta página. En la siguiente tabla se muestran las operaciones comunes de AWS Glue que admiten la opción de formato Avro. | Lectura | Escritura | Lectura de streaming | Grupo de archivos pequeños | Marcadores de trabajo | | --- | --- | --- | --- | --- | | Compatible | Compatible | Compatible\$1 | No se admite | Compatible | \$1Compatible con restricciones. Para obtener más información, consulte [Notas y restricciones para orígenes de streaming de Avro](add-job-streaming.md#streaming-avro-notes). ## Ejemplo: leer archivos o carpetas Avro de S3 **Requisitos previos:** necesitará las rutas de S3 (`s3path`) de las carpetas o los archivos Avro que desee leer. **Configuración:** en las opciones de la función, especifique `format="avro"`. En sus `connection_options`, utilice la clave `paths` para especificar `s3path`. Puede configurar la forma en que el lector interactúa con S3 en la `connection_options`. Para obtener más información, consulte Opciones de formato de datos para entradas y salidas de ETL en AWS Glue: [Referencia de opción de conexión de Amazon S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Puede configurar la manera en que el lector interpreta los archivos Avro en sus `format_options`. Para obtener más información, consulte [Referencia de configuración de Avro](#aws-glue-programming-etl-format-avro-reference). El siguiente script de ETL de AWS Glue muestra el proceso de lectura de archivos o carpetas Avro de S3: ------ #### [ Python ] Para este ejemplo, use el método [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options). ``` from pyspark.context import SparkContext from awsglue.context import GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) dynamicFrame = glueContext.create_dynamic_frame.from_options( connection_type="s3", connection_options={"paths": ["s3://s3path"]}, format="avro" ) ``` ------ #### [ Scala ] Para este ejemplo, use la operación [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat). ``` import com.amazonaws.services.glue.util.JsonOptions import com.amazonaws.services.glue.GlueContext import org.apache.spark.sql.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) val dynamicFrame = glueContext.getSourceWithFormat( connectionType="s3", format="avro", options=JsonOptions("""{"paths": ["s3://s3path"]}""") ).getDynamicFrame() } ``` ------ ## Ejemplo: escribir archivos y carpetas Avro en S3 **Requisitos previos:** necesitará un DataFrame inicializado (`dataFrame`) o DynamicFrame (`dynamicFrame`). También necesitará la ruta de salida S3 prevista, `s3path`. **Configuración:** en las opciones de la función, especifique `format="avro"`. En sus `connection_options`, utilice la clave `paths` para especificar su `s3path`. Puede modificar aún más la forma en que el escritor interactúa con S3 en las `connection_options`. Para obtener más información, consulte Opciones de formato de datos para entradas y salidas de ETL en AWS Glue: [Referencia de opción de conexión de Amazon S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Puede alterar la manera en que el escritor interpreta los archivos Avro en sus `format_options`. Para obtener más información, consulte [Referencia de configuración de Avro](#aws-glue-programming-etl-format-avro-reference). El siguiente script de ETL de AWS Glue muestra el proceso de escritura de archivos o carpetas Avro en S3. ------ #### [ Python ] Para este ejemplo, use el método [write\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options). ``` from pyspark.context import SparkContext from awsglue.context import GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) glueContext.write_dynamic_frame.from_options( frame=dynamicFrame, connection_type="s3", format="avro", connection_options={ "path": "s3://s3path" } ) ``` ------ #### [ Scala ] Para este ejemplo, use el método [getSinkWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSinkWithFormat). ``` import com.amazonaws.services.glue.util.JsonOptions import com.amazonaws.services.glue.{DynamicFrame, GlueContext} import org.apache.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) glueContext.getSinkWithFormat( connectionType="s3", options=JsonOptions("""{"path": "s3://s3path"}"""), format="avro" ).writeDynamicFrame(dynamicFrame) } } ``` ------ ## Referencia de configuración de Avro Puede utilizar los siguientes valores `format_options` donde las bibliotecas de AWS Glue especifiquen `format="avro"`: + `version`: especifica la versión del formato lector/escritor Apache Avro que se va a soportar. El valor predeterminado es 1.7. Puede especificar `format_options={"version": “1.8”}` para habilitar el tipo de lectura y escritura lógico de Avro. Para obtener más información, consulte la [especificación de Apache Avro 1.7.7](https://avro.apache.org/docs/1.7.7/spec.html) y la [especificación de Apache Avro 1.8.2](https://avro.apache.org/docs/1.8.2/spec.html). El conector de Apache Avro 1.8 admite las siguientes conversiones de tipo lógico: Para el lector: en esta tabla, se muestra la conversión entre el tipo de datos de Avro (tipo lógico y tipo primitivo de Avro) y el tipo de datos `DynamicFrame` de AWS Glue para las versiones 1.7 y 1.8 del lector de Avro. | Tipo de datos de Avro: Tipo lógico | Tipo de datos de Avro: Tipo primitivo de Avro | Tipo de datos DynamicFrame de Glue:Lector 1.7 de Avro | Tipo de datos DynamicFrame de Glue: Lector 1.8 de Avro | | --- | --- | --- | --- | | Decimal | bytes | BINARIO | Decimal | | Decimal | fijo | BINARIO | Decimal | | Date | int | INT | Date | | Tiempo (milisegundos) | int | INT | INT | | Tiempo (microsegundos) | long | LONG | LONG | | Marca de tiempo (milisegundos) | long | LONG | Timestamp | | Marca de tiempo (microsegundos) | long | LONG | LONG | | Duración (no es un tipo lógico) | fijo de 12 | BINARIO | BINARIO | Para el escritor: en esta tabla, se muestra la conversión entre el tipo de datos `DynamicFrame` de AWS Glue y el tipo de datos de Avro para las versiones 1.7 y 1.8 del escritor de Avro. | Tipo de datos `DynamicFrame` de AWS Glue | Tipo de datos de Avro:Escritor 1.7 de Avro | Tipo de datos de Avro:Escritor 1.8 de Avro | | --- | --- | --- | | Decimal | Cadena | decimal | | Date | Cadena | date | | Timestamp | Cadena | marca temporal (microsegundos) | ## Compatibilidad entre Avro y Spark DataFrame Para utilizar Avro desde la API de Spark DataFrame, debe instalar el complemento Spark Avro para la versión de Spark correspondiente. La versión de Spark disponible en su trabajo está determinada por la versión de AWS Glue. Para obtener más información acerca de las versiones de Spark, consulte [AWS GlueVersiones de](release-notes.md). Apache mantiene este complemento; nosotros no ofrecemos garantías específicas de compatibilidad. En AWS Glue 2.0 se utiliza la versión 2.4.3 del complemento Spark Avro. Puede encontrar este JAR en Maven Central, consulte [org.apache.spark:spark-avro\$12.12:2.4.3](https://search.maven.org/artifact/org.apache.spark/spark-avro_2.12/3.1.1/jar). En AWS Glue 3.0 se utiliza la versión 3.1.1 del complemento Spark Avro. Puede encontrar este JAR en Maven Central, consulte [org.apache.spark:spark-avro\$12.12:3.1.1](https://search.maven.org/artifact/org.apache.spark/spark-avro_2.12/3.1.1/jar). Para incluir archivos JAR adicionales en un trabajo de ETL de AWS Glue, utilice el parámetro de trabajo `--extra-jars`. Para obtener más información acerca de la configuración de parámetros de trabajos, consulte [Uso de los parámetros de trabajo en los trabajos de AWS Glue](aws-glue-programming-etl-glue-arguments.md). También puede configurar este parámetro en la Consola de administración de AWS. # Uso del formato grokLog en AWS Glue AWS Glue recupera datos de fuentes y escribe datos en destinos almacenados y transportados en varios formatos de datos. Si los datos se almacenan o se transportan en texto sin formato y en un formato poco estructurado, este documento presenta las características disponibles para utilizar los datos en AWS Glue a través de patrones de Grok. AWS Glue admite el uso de patrones de Grok. Los patrones de Grok son similares a los grupos de captura de expresiones regulares. Reconocen patrones de secuencias de caracteres en un archivo de texto sin formato y les dan un tipo y un propósito. En AWS Glue, su objetivo principal es leer registros. Para obtener una introducción a Grok por parte de los autores, consulte [Referencia de Logstash: complemento de filtro de Grok](https://www.elastic.co/guide/en/logstash/current/plugins-filters-grok.html). | Lectura | Escritura | Lectura de streaming | Grupo de archivos pequeños | Marcadores de trabajo | | --- | --- | --- | --- | --- | | Compatible | No aplicable | Soportado | Compatible | No se admite | ## Referencia de configuración de grokLog Puede utilizar los siguientes valores `format_options` con `format="grokLog"`: + `logFormat`: especifica el patrón de Grok que coincide con el formato del registro. + `customPatterns`: especifica los patrones de Grok adicionales que se utilizan aquí. + `MISSING`: especifica la señal que se utilizará en la identificación de los valores que faltan. El valor predeterminado es `'-'`. + `LineCount`: especifica el número de líneas en cada registro. El valor predeterminado es `'1'` y actualmente solo se admiten los registros de una sola línea. + `StrictMode`: un valor booleano que especifica si el modo estricto está habilitado. En modo estricto, el lector no efectúa la conversión o recuperación de tipo automática. El valor predeterminado es `"false"`. # Uso del formato Ion en AWS Glue AWS Glue recupera datos de fuentes y escribe datos en destinos almacenados y transportados en varios formatos de datos. Si los datos se almacenan o se transportan en formato de datos Ion, este documento presenta las características disponibles para utilizar los datos en AWS Glue. AWS Glue admite el uso del formato Ion. Este formato representa estructuras de datos (que no están basadas en filas o columnas) en representaciones binarias y de texto sin formato intercambiables. Para obtener una introducción al formato por parte de los autores, consulte [Amazon Ion](https://amzn.github.io/ion-docs/). (Para obtener más información, consulte [Especificación de Amazon Ion](https://amzn.github.io/ion-docs/spec.html)). Puede utilizar AWS Glue para leer archivos Ion de Amazon S3. Puede leer y escribir archivos `bzip` y `gzip` que contengan archivos Ion de S3. Debe configurar el comportamiento de compresión en el [Parámetros de conexión S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) en lugar de en la configuración que se describe en esta página. En la siguiente tabla se muestran las operaciones comunes de AWS Glue que admiten la opción de formato Ion. | Lectura | Escritura | Lectura de streaming | Grupo de archivos pequeños | Marcadores de trabajo | | --- | --- | --- | --- | --- | | Compatible | No se admite | No se admite | Compatible | No se admite | ## Ejemplo: leer archivos o carpetas Ion de S3 **Requisitos previos:** necesitará las rutas de S3 (`s3path`) de las carpetas o los archivos Ion que desee leer. **Configuración:** en las opciones de la función, especifique `format="json"`. En sus `connection_options`, utilice la clave `paths` para especificar su `s3path`. Puede configurar la forma en que el lector interactúa con S3 en la `connection_options`. Para obtener más información, consulte Tipos y opciones de conexión para ETL en AWS Glue: [Referencia de opción de conexión de Amazon S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). El siguiente script de ETL de AWS Glue muestra el proceso de lectura de archivos o carpetas Ion de S3: ------ #### [ Python ] Para este ejemplo, use el método [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options). ``` # Example: Read ION from S3 from pyspark.context import SparkContext from awsglue.context import GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) dynamicFrame = glueContext.create_dynamic_frame.from_options( connection_type="s3", connection_options={"paths": ["s3://s3path"]}, format="ion" ) ``` ------ #### [ Scala ] Para este ejemplo, use la operación [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat). ``` // Example: Read ION from S3 import com.amazonaws.services.glue.util.JsonOptions import com.amazonaws.services.glue.GlueContext import org.apache.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) val dynamicFrame = glueContext.getSourceWithFormat( connectionType="s3", format="ion", options=JsonOptions("""{"paths": ["s3://s3path"], "recurse": true}""") ).getDynamicFrame() } } ``` ------ ## Referencia de configuración de Ion No hay valores `format_options` para `format="ion"`. # Uso del formato JSON en AWS Glue AWS Glue recupera datos de fuentes y escribe datos en destinos almacenados y transportados en varios formatos de datos. Si los datos se almacenan o se transportan en formato de datos JSON, este documento presenta las características disponibles para utilizar los datos en AWS Glue. AWS Glue admite el uso del formato JSON. Este formato representa estructuras de datos con forma consistente, pero con contenido flexible, que no están basadas en filas o columnas. JSON está definido por estándares paralelos emitidos por varias autoridades, una de las cuales es ECMA-404. Para obtener una introducción al formato por parte de un origen al que normalmente se hace referencia, consulte [Introducción a JSON](https://www.json.org/). Puede utilizar AWS Glue para leer archivos JSON de Amazon S3, así como archivos JSON comprimidos con `bzip` y `gzip`. Debe configurar el comportamiento de compresión en el [Parámetros de conexión S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) en lugar de en la configuración que se describe en esta página. | Lectura | Escritura | Lectura de streaming | Grupo de archivos pequeños | Marcadores de trabajo | | --- | --- | --- | --- | --- | | Compatible | Soportado | Soportado | Soportado | Compatible | ## Ejemplo: leer archivos o carpetas JSON de S3 **Requisitos previos:** necesitará las rutas de S3 (`s3path`) de las carpetas o los archivos JSON que desee leer. **Configuración:** en las opciones de la función, especifique `format="json"`. En sus `connection_options`, utilice la clave `paths` para especificar su `s3path`. Puede modificar aún más la manera en que la operación de lectura atravesará S3 en las opciones de conexión; consulte [Referencia de opción de conexión de Amazon S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) para obtener más detalles. Puede configurar la manera en que el lector interpreta los archivos JSON en sus `format_options`. Para obtener más información, consulte [Referencia de configuración de JSON](#aws-glue-programming-etl-format-json-reference). El siguiente script de ETL de AWS Glue muestra el proceso de lectura de archivos o carpetas JSON de S3: ------ #### [ Python ] Para este ejemplo, use el método [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options). ``` # Example: Read JSON from S3 # For show, we handle a nested JSON file that we can limit with the JsonPath parameter # For show, we also handle a JSON where a single entry spans multiple lines # Consider whether optimizePerformance is right for your workflow. from pyspark.context import SparkContext from awsglue.context import GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) spark = glueContext.spark_session dynamicFrame = glueContext.create_dynamic_frame.from_options( connection_type="s3", connection_options={"paths": ["s3://s3path"]}, format="json", format_options={ "jsonPath": "$.id", "multiline": True, # "optimizePerformance": True, -> not compatible with jsonPath, multiline } ) ``` También puede usar DataFrames en un script (`pyspark.sql.DataFrame`). ``` dataFrame = spark.read\ .option("multiline", "true")\ .json("s3://s3path") ``` ------ #### [ Scala ] Para este ejemplo, use la operación [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat). ``` // Example: Read JSON from S3 // For show, we handle a nested JSON file that we can limit with the JsonPath parameter // For show, we also handle a JSON where a single entry spans multiple lines // Consider whether optimizePerformance is right for your workflow. import com.amazonaws.services.glue.util.JsonOptions import com.amazonaws.services.glue.{DynamicFrame, GlueContext} import org.apache.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) val dynamicFrame = glueContext.getSourceWithFormat( formatOptions=JsonOptions("""{"jsonPath": "$.id", "multiline": true, "optimizePerformance":false}"""), connectionType="s3", format="json", options=JsonOptions("""{"paths": ["s3://s3path"], "recurse": true}""") ).getDynamicFrame() } } ``` También puede usar DataFrames en un script (`pyspark.sql.DataFrame`). ``` val dataFrame = spark.read .option("multiline", "true") .json("s3://s3path") ``` ------ ## Ejemplo: escribir archivos y carpetas JSON en S3 **Requisitos previos:** necesitará un DataFrame inicializado (`dataFrame`) o un DynamicFrame (`dynamicFrame`). También necesitará la ruta de salida S3 prevista, `s3path`. **Configuración:** en las opciones de la función, especifique `format="json"`. En sus `connection_options`, utilice la clave `paths` para especificar `s3path`. Puede modificar aún más la forma en que el escritor interactúa con S3 en las `connection_options`. Para obtener más información, consulte Opciones de formato de datos para entradas y salidas de ETL en AWS Glue: [Referencia de opción de conexión de Amazon S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Puede configurar la forma en que el escritor interpreta los archivos JSON en sus `format_options`. Para obtener más información, consulte [Referencia de configuración de JSON](#aws-glue-programming-etl-format-json-reference). El siguiente script de ETL de AWS Glue muestra el proceso de escritura de archivos o carpetas JSON de S3: ------ #### [ Python ] Para este ejemplo, use el método [write\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options). ``` # Example: Write JSON to S3 from pyspark.context import SparkContext from awsglue.context import GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) glueContext.write_dynamic_frame.from_options( frame=dynamicFrame, connection_type="s3", connection_options={"path": "s3://s3path"}, format="json" ) ``` También puede usar DataFrames en un script (`pyspark.sql.DataFrame`). ``` df.write.json("s3://s3path/") ``` ------ #### [ Scala ] Para este ejemplo, use el método [getSinkWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSinkWithFormat). ``` // Example: Write JSON to S3 import com.amazonaws.services.glue.util.JsonOptions import com.amazonaws.services.glue.{DynamicFrame, GlueContext} import org.apache.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) glueContext.getSinkWithFormat( connectionType="s3", options=JsonOptions("""{"path": "s3://s3path"}"""), format="json" ).writeDynamicFrame(dynamicFrame) } } ``` También puede usar DataFrames en un script (`pyspark.sql.DataFrame`). ``` df.write.json("s3://s3path") ``` ------ ## Referencia de configuración de JSON Puede utilizar los siguientes valores `format_options` con `format="json"`: + `jsonPath`: una expresión [JsonPath](https://github.com/json-path/JsonPath) que identifica un objeto que se leerá en los registros. Esto resulta particularmente útil cuando un archivo contiene registros anidados en una matriz exterior. Por ejemplo, la siguiente expresión JsonPath se dirige al campo `id` de un objeto JSON. ``` format="json", format_options={"jsonPath": "$.id"} ``` + `multiline`: un valor booleano que especifica si un solo registro puede abarcar varias líneas. Esto puede suceder cuando un campo contiene un carácter de nueva línea entre comillas. Debe configurar esta opción en `"true"` si un registro abarca varias líneas. El valor predeterminado es `"false"`, que permite una división de archivo más dinámica durante el análisis. + `optimizePerformance`: un valor booleano que especifica si se debe utilizar el lector SIMD JSON avanzado junto con los formatos de memoria en columnas basados en Apache Arrow. Solo se encuentra disponible en AWS Glue 3.0. No compatible con `multiline` ni `jsonPath`. Proporcionar cualquiera de esas opciones indicará a AWS Glue que regrese al lector estándar. + `withSchema`— Un valor de cadena que especifica un esquema de tabla en el formato descrito en [Especifique manualmente el esquema XML](aws-glue-programming-etl-format-xml-home.md#aws-glue-programming-etl-format-xml-withschema). Solo se usa con `optimizePerformance` al leer desde conexiones que no son de catálogo. ## Uso del lector SIMD JSON vectorizado con formato en columnas de Apache Arrow AWS Glue versión 3.0 agrega un lector vectorizado para datos JSON. Funciona dos veces más rápido en ciertas condiciones, en comparación con el lector estándar. Este lector viene con ciertas limitaciones documentadas en esta sección que los usuarios deben tener en cuenta antes de usarlo. Para usar el lector optimizado, configure `"optimizePerformance"` como True en `format_options` o propiedad de tabla. También deberá proporcionar `withSchema` a menos que esté leyendo del catálogo. `withSchema` espera una entrada como se describe en [Especifique manualmente el esquema XML](aws-glue-programming-etl-format-xml-home.md#aws-glue-programming-etl-format-xml-withschema) ``` // Read from S3 data source glueContext.create_dynamic_frame.from_options( connection_type = "s3", connection_options = {"paths": ["s3://s3path"]}, format = "json", format_options={ "optimizePerformance": True, "withSchema": SchemaString }) // Read from catalog table glueContext.create_dynamic_frame.from_catalog( database = database, table_name = table, additional_options = { // The vectorized reader for JSON can read your schema from a catalog table property. "optimizePerformance": True, }) ``` Para obtener más información sobre la creación de un *SchemaString* en la biblioteca de AWS Glue, consulte [Tipos de extensión PySpark](aws-glue-api-crawler-pyspark-extensions-types.md). **Limitaciones para el lector CSV vectorizado** Presenta las siguientes limitaciones: + No se admiten elementos JSON con objetos anidados o valores de matriz. Si se proporciona, AWS Glue volverá al lector estándar. + Se debe proporcionar un esquema, ya sea del Catálogo o con `withSchema`. + No compatible con `multiline` ni `jsonPath`. Proporcionar cualquiera de esas opciones indicará a AWS Glue que regrese al lector estándar. + Proporcionar registros de entrada que no coincidan con el esquema de entrada provocará un error en el lector. + No se crearán [registros de errores](https://docs.aws.amazon.com/glue/latest/dg/glue-etl-scala-apis-glue-dynamicframe-class.html#glue-etl-scala-apis-glue-dynamicframe-class-defs-errorsAsDynamicFrame). + No se admiten archivos JSON con caracteres multibytes (como caracteres japoneses o chinos). # Uso del formato ORC en AWS Glue AWS Glue recupera datos de fuentes y escribe datos en destinos almacenados y transportados en varios formatos de datos. Si los datos se almacenan o se transportan en formato de datos ORC, este documento presenta las características disponibles para utilizar los datos en AWS Glue. AWS Glue admite el uso del formato ORC. Este formato es un formato de datos basado en columnas y orientado al rendimiento. Para obtener una introducción al formato por parte de la autoridad de normalización, consulte [Apache Orc](https://orc.apache.org/docs/). Puede utilizar AWS Glue para leer archivos ORC de Amazon S3 y de orígenes de streaming, como también para escribir archivos ORC en Amazon S3. Puede leer y escribir archivos `bzip` y `gzip` que contengan archivos ORC de S3. Debe configurar el comportamiento de compresión en el [Parámetros de conexión S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) en lugar de en la configuración que se describe en esta página. En la siguiente tabla se muestran las operaciones comunes de AWS Glue que admiten la opción de formato ORC. | Lectura | Escritura | Lectura de streaming | Grupo de archivos pequeños | Marcadores de trabajo | | --- | --- | --- | --- | --- | | Compatible | Soportado | Compatible | No se admite | Compatible\$1 | \$1Compatible con AWS Glue versión 1.0 y posterior ## Ejemplo: leer archivos o carpetas ORC de S3 **Requisitos previos:** necesitará las rutas de S3 (`s3path`) de las carpetas o los archivos ORC que desee leer. **Configuración:** en las opciones de la función, especifique `format="orc"`. En sus `connection_options`, utilice la clave `paths` para especificar su `s3path`. Puede configurar la forma en que el lector interactúa con S3 en la `connection_options`. Para obtener más información, consulte Tipos y opciones de conexión para ETL en AWS Glue: [Referencia de opción de conexión de Amazon S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). El siguiente script de ETL de AWS Glue muestra el proceso de lectura de archivos o carpetas ORC de S3: ------ #### [ Python ] Para este ejemplo, use el método [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options). ``` from pyspark.context import SparkContext from awsglue.context import GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) dynamicFrame = glueContext.create_dynamic_frame.from_options( connection_type="s3", connection_options={"paths": ["s3://s3path"]}, format="orc" ) ``` También puede usar DataFrames en un script (`pyspark.sql.DataFrame`). ``` dataFrame = spark.read\ .orc("s3://s3path") ``` ------ #### [ Scala ] Para este ejemplo, use la operación [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat). ``` import com.amazonaws.services.glue.util.JsonOptions import com.amazonaws.services.glue.GlueContext import org.apache.spark.sql.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) val dynamicFrame = glueContext.getSourceWithFormat( connectionType="s3", format="orc", options=JsonOptions("""{"paths": ["s3://s3path"]}""") ).getDynamicFrame() } } ``` También puede usar DataFrames en un script (`pyspark.sql.DataFrame`). ``` val dataFrame = spark.read .orc("s3://s3path") ``` ------ ## Ejemplo: escribir archivos y carpetas ORC en S3 **Requisitos previos:** necesitará un DataFrame inicializado (`dataFrame`) o DynamicFrame (`dynamicFrame`). También necesitará la ruta de salida S3 prevista, `s3path`. **Configuración:** en las opciones de la función, especifique `format="orc"`. En las opciones de conexión, utilice la clave `paths` para especificar `s3path`. Puede modificar aún más la forma en que el escritor interactúa con S3 en las `connection_options`. Para obtener más información, consulte Opciones de formato de datos para entradas y salidas de ETL en AWS Glue: [Referencia de opción de conexión de Amazon S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). El siguiente ejemplo de código muestra el proceso: ------ #### [ Python ] Para este ejemplo, use el método [write\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options). ``` from pyspark.context import SparkContext from awsglue.context import GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) glueContext.write_dynamic_frame.from_options( frame=dynamicFrame, connection_type="s3", format="orc", connection_options={ "path": "s3://s3path" } ) ``` También puede usar DataFrames en un script (`pyspark.sql.DataFrame`). ``` df.write.orc("s3://s3path/") ``` ------ #### [ Scala ] Para este ejemplo, use el método [getSinkWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSinkWithFormat). ``` import com.amazonaws.services.glue.util.JsonOptions import com.amazonaws.services.glue.{DynamicFrame, GlueContext} import org.apache.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) glueContext.getSinkWithFormat( connectionType="s3", options=JsonOptions("""{"path": "s3://s3path"}"""), format="orc" ).writeDynamicFrame(dynamicFrame) } } ``` También puede usar DataFrames en un script (`pyspark.sql.DataFrame`). ``` df.write.orc("s3://s3path/") ``` ------ ## Referencia de configuración de ORC No hay valores `format_options` para `format="orc"`. No obstante, se le pueden pasar las opciones que acepte el código SparkSQL subyacente mediante el parámetro de mapa `connection_options`. # Uso de marcos de lagos de datos con trabajos de ETL de AWS Glue Los marcos de lagos de datos de código abierto simplifican el procesamiento incremental de los datos para los archivos que se almacenan en los lagos de datos creados en Amazon S3. AWS Glue 3.0 y versiones posteriores admiten los siguientes marcos de lagos de datos de código abierto: + Apache Hudi + Linux Foundation Delta Lake + Apache Iceberg Proporcionamos compatibilidad nativa para estos marcos para que pueda leer y escribir los datos que almacena en Amazon S3 de manera coherente desde el punto de vista transaccional. No es necesario instalar ningún conector independiente ni completar pasos de configuración adicionales para utilizar estos marcos en los trabajos de ETL de AWS Glue. Cuando administre conjuntos de datos mediante AWS Glue Data Catalog, puede utilizar los métodos AWS Glue para leer y escribir tablas de lagos de datos con DataFrames de Spark. También puede leer y escribir datos de Amazon S3 mediante la API de DataFrame de Spark. En este video, puede obtener información básica sobre el trabajo de Apache Hudi, Apache Iceberg y Delta Lake. Verá cómo insertar, actualizar y eliminar datos en su lago de datos y cómo funciona cada uno de estos marcos. [![AWS Videos](http://img.youtube.com/vi/https://www.youtube.com/embed/fryfx0Zg7KA/0.jpg)](http://www.youtube.com/watch?v=https://www.youtube.com/embed/fryfx0Zg7KA) **Topics** + [Limitaciones](aws-glue-programming-etl-datalake-native-frameworks-limitations.md) + [Uso del marco de Hudi en AWS Glue](aws-glue-programming-etl-format-hudi.md) + [Uso del marco de Delta Lake en AWS Glue](aws-glue-programming-etl-format-delta-lake.md) + [Uso del marco de Iceberg en AWS Glue](aws-glue-programming-etl-format-iceberg.md) # Limitaciones Tenga en cuenta las siguientes limitaciones antes de utilizar los marcos de lagos de datos con AWS Glue. + Los siguientes métodos de AWS Glue `GlueContext` para DynamicFrame no admiten la lectura ni la escritura de tablas de marcos del lagos de datos. En su lugar, utilice los métodos `GlueContext` para la API de DataFrame o Spark DataFrame. + `create_dynamic_frame.from_catalog` + `write_dynamic_frame.from_catalog` + `getDynamicFrame` + `writeDynamicFrame` + El control de permisos de Lake Formation admite los siguientes métodos de `GlueContext` para DataFrame: + `create_data_frame.from_catalog` + `write_data_frame.from_catalog` + `getDataFrame` + `writeDataFrame` + No se admite la [agrupación de archivos pequeños](grouping-input-files.md). + No se admiten los [marcadores de trabajo](monitor-continuations.md). + Apache Hudi 0.10.1 para AWS Glue 3.0 no admite las tablas Merge on Read (MoR, fusionar al leer) de Hudi. + `ALTER TABLE … RENAME TO` no está disponible para Apache Iceberg 0.13.1 para AWS Glue 3.0. ## Limitaciones de las tablas con formato de lago de datos administradas por los permisos de Lake Formation Los formatos de lago de datos se integran con AWS Glue ETL a través de los permisos de Lake Formation. No se admite la creación de un DynamicFrame utilizando `create_dynamic_frame`. Para obtener más información, consulte los ejemplos siguientes: + [Ejemplo: Lea y escriba una tabla de iceberg con el control de permisos de Lake Formation](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-format-iceberg.html#aws-glue-programming-etl-format-iceberg-read-write-lake-formation-tables) + [Ejemplo: Lea y escriba una tabla Hudi con el control de permisos de Lake Formation](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-format-hudi.html#aws-glue-programming-etl-format-hudi-read-write-lake-formation-tables) + [Ejemplo: Lea y escriba la tabla de Delta Lake con el control de permisos de Lake Formation](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-format-delta-lake.html#aws-glue-programming-etl-format-delta-lake-read-write-lake-formation-tables) **nota** La integración con AWS Glue ETL mediante los permisos de Lake Formation para Apache Hudi, Apache Iceberg y Delta Lake solo se admite en la AWS Glue versión 4.0. Apache Iceberg tiene la mejor integración con AWS Glue ETL a través de los permisos de Lake Formation. Es compatible con casi todas las operaciones e incluye soporte para SQL. Hudi es compatible con la mayoría de las operaciones básicas, con la excepción de las operaciones administrativas. Esto se debe a que estas opciones generalmente se realizan mediante la escritura de marcos de datos y se especifican mediante `additional_options`. Debe usar las API AWS Glue para crear DataFrames para sus operaciones, ya que SparkSQL no es compatible. Delta Lake solo admite la lectura, la adición y la sobrescritura de datos de tablas. Delta Lake requiere el uso de sus propias bibliotecas para poder realizar diversas tareas, como las actualizaciones. Las siguientes funciones no están disponibles para las tablas Iceberg administradas por los permisos de Lake Formation. + Compactación mediante ETL AWS Glue + Soporte para Spark SQL a través de AWS Glue ETL Las siguientes son limitaciones de las tablas Hudi administradas por los permisos de Lake Formation: + Eliminación de archivos huérfanos Las siguientes son limitaciones de las tablas de Delta Lake administradas por los permisos de Lake Formation: + Todas las funciones, excepto la inserción y lectura de las tablas de Delta Lake. # Uso del marco de Hudi en AWS Glue AWS Glue 3.0 y versiones posteriores son compatibles con el marco de Apache Hudi para lagos de datos. Hudi es un marco de almacenamiento de lagos de datos de código abierto que simplifica el procesamiento progresivo de datos y el desarrollo de canalizaciones de datos. En este tema, se describen las características disponibles para usar los datos en AWS Glue al transportar o almacenar datos en una tabla de Hudi. Para más información sobre Hudi, consulte la [documentación oficial de Apache Hudi](https://hudi.apache.org/docs/overview/). Puede usar AWS Glue para llevar a cabo operaciones de lectura y escritura en tablas de Hudi en Amazon S3, o trabajar con tablas de Hudi mediante el Catálogo de datos de AWS Glue. También se admiten operaciones adicionales, como insertar, actualizar y todas las [operaciones de Apache Spark](https://hudi.apache.org/docs/quick-start-guide/). **nota** La implementación de Apache Hudi 0.15.0 en AWS Glue 5.0 revierte internamente [HUDI-7001](https://github.com/apache/hudi/pull/9936). No muestra la regresión relacionada con la generación de claves complejas cuando la clave de registro consta de un solo campo. Sin embargo, este comportamiento es diferente al de OSS Apache Hudi 0.15.0. Apache Hudi 0.10.1 para AWS Glue 3.0 no admite las tablas Merge on Read (MoR, fusionar al leer) de Hudi. La siguiente tabla muestra la versión de Hudi que se incluye en cada versión de AWS Glue. **** | Versión de AWS Glue | Versión de Hudi compatible | | --- | --- | | 5.1 | 1.0.2 | | 5.0 | 0.15.0 | | 4.0 | 0.12.1 | | 3.0 | 0.10.1 | Para más información sobre los marcos de lagos de datos compatibles con AWS Glue, consulte [Uso de marcos de lagos de datos con trabajos de ETL de AWS Glue](aws-glue-programming-etl-datalake-native-frameworks.md). ## Activación de Hudi Para activar Hudi para AWS Glue, haga las siguientes tareas: + Especifique `hudi` como valor para el parámetro del trabajo `--datalake-formats`. Para obtener más información, consulte [Uso de los parámetros de trabajo en los trabajos de AWS Glue](aws-glue-programming-etl-glue-arguments.md). + Cree una clave con el nombre `--conf` para el trabajo de AWS Glue y establézcala en el siguiente valor. Como alternativa, puede establecer la siguiente configuración mediante `SparkConf` en su script. Esta configuración ayuda a Apache Spark a gestionar correctamente las tablas de Hudi. ``` spark.serializer=org.apache.spark.serializer.KryoSerializer ``` + La compatibilidad con los permisos de Lake Formation para Hudi está habilitada de forma predeterminada en AWS Glue 4.0. No se necesita ninguna configuración adicional para leer o escribir en las tablas Hudi registradas en Lake Formation. Para leer una tabla Hudi registrada, el rol de IAM del trabajo de AWS Glue debe tener el permiso SELECT. Para escribir en una tabla Hudi registrada, el rol de IAM del trabajo de AWS Glue debe tener el permiso SUPER. Para obtener más información sobre la administración de los permisos de Lake Formation, consulte [Otorgar y revocar permisos en los recursos del catálogo de datos](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-catalog-permissions.html). **Uso de una versión diferente de Hudi** Para usar una versión de Hudi que no sea compatible con AWS Glue, indique sus propios archivos JAR de Hudi mediante el parámetro de trabajo `--extra-jars`. No incluya `hudi` como valor para el parámetro de trabajo `--datalake-formats`. Si usa AWS Glue 5.0 o versiones posteriores, debe configurar el parámetro de trabajo `--user-jars-first true`. ## Ejemplo: escribir una tabla de Hudi en Amazon S3 y registrarla en el Catálogo de datos de AWS Glue En este script de ejemplo, se muestra cómo escribir una tabla de Hudi en Amazon S3 y registrar la tabla en el Catálogo de datos de AWS Glue. En el ejemplo, se utiliza la [herramienta Hive Sync](https://hudi.apache.org/docs/syncing_metastore/) de Hudi para registrar la tabla. **nota** En este ejemplo, se requiere que establezca el parámetro de trabajo de `--enable-glue-datacatalog` para utilizar el Catálogo de datos de AWS Glue como metaalmacén de Apache Spark Hive. Para obtener más información, consulte [Uso de los parámetros de trabajo en los trabajos de AWS Glue](aws-glue-programming-etl-glue-arguments.md). ------ #### [ Python ] ``` # Example: Create a Hudi table from a DataFrame # and register the table to Glue Data Catalog additional_options={ "hoodie.table.name": "", "hoodie.database.name": "", "hoodie.datasource.write.storage.type": "COPY_ON_WRITE", "hoodie.datasource.write.operation": "upsert", "hoodie.datasource.write.recordkey.field": "", "hoodie.datasource.write.precombine.field": "", "hoodie.datasource.write.partitionpath.field": "", "hoodie.datasource.write.hive_style_partitioning": "true", "hoodie.datasource.hive_sync.enable": "true", "hoodie.datasource.hive_sync.database": "", "hoodie.datasource.hive_sync.table": "", "hoodie.datasource.hive_sync.partition_fields": "", "hoodie.datasource.hive_sync.partition_extractor_class": "org.apache.hudi.hive.MultiPartKeysValueExtractor", "hoodie.datasource.hive_sync.use_jdbc": "false", "hoodie.datasource.hive_sync.mode": "hms", "path": "s3://" } dataFrame.write.format("hudi") \ .options(**additional_options) \ .mode("overwrite") \ .save() ``` ------ #### [ Scala ] ``` // Example: Example: Create a Hudi table from a DataFrame // and register the table to Glue Data Catalog val additionalOptions = Map( "hoodie.table.name" -> "", "hoodie.database.name" -> "", "hoodie.datasource.write.storage.type" -> "COPY_ON_WRITE", "hoodie.datasource.write.operation" -> "upsert", "hoodie.datasource.write.recordkey.field" -> "", "hoodie.datasource.write.precombine.field" -> "", "hoodie.datasource.write.partitionpath.field" -> "", "hoodie.datasource.write.hive_style_partitioning" -> "true", "hoodie.datasource.hive_sync.enable" -> "true", "hoodie.datasource.hive_sync.database" -> "", "hoodie.datasource.hive_sync.table" -> "", "hoodie.datasource.hive_sync.partition_fields" -> "", "hoodie.datasource.hive_sync.partition_extractor_class" -> "org.apache.hudi.hive.MultiPartKeysValueExtractor", "hoodie.datasource.hive_sync.use_jdbc" -> "false", "hoodie.datasource.hive_sync.mode" -> "hms", "path" -> "s3://") dataFrame.write.format("hudi") .options(additionalOptions) .mode("append") .save() ``` ------ ## Ejemplo: leer una tabla de Hudi de Amazon S3 con el Catálogo de datos de AWS Glue En este ejemplo, se lee la tabla de Hudi que creó en [Ejemplo: escribir una tabla de Hudi en Amazon S3 y registrarla en el Catálogo de datos de AWS Glue](#aws-glue-programming-etl-format-hudi-write) de Amazon S3. **nota** En este ejemplo, se requiere que establezca el parámetro de trabajo de `--enable-glue-datacatalog` para utilizar el Catálogo de datos de AWS Glue como metaalmacén de Apache Spark Hive. Para obtener más información, consulte [Uso de los parámetros de trabajo en los trabajos de AWS Glue](aws-glue-programming-etl-glue-arguments.md). ------ #### [ Python ] Para este ejemplo, utilice el método `GlueContext.create\$1data\$1frame.from\$1catalog()`. ``` # Example: Read a Hudi table from Glue Data Catalog from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) dataFrame = glueContext.create_data_frame.from_catalog( database = "", table_name = "" ) ``` ------ #### [ Scala ] Para este ejemplo, utilice el método [getCatalogSource](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSource). ``` // Example: Read a Hudi table from Glue Data Catalog import com.amazonaws.services.glue.GlueContext import org.apache.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) val dataFrame = glueContext.getCatalogSource( database = "", tableName = "" ).getDataFrame() } } ``` ------ ## Ejemplo: actualizar e insertar un objeto `DataFrame` en una tabla de Hudi en Amazon S3 En este ejemplo, se utiliza el Catálogo de datos de AWS Glue para insertar un DataFrame en la tabla de Hudi que creó en [Ejemplo: escribir una tabla de Hudi en Amazon S3 y registrarla en el Catálogo de datos de AWS Glue](#aws-glue-programming-etl-format-hudi-write). **nota** En este ejemplo, se requiere que establezca el parámetro de trabajo de `--enable-glue-datacatalog` para utilizar el Catálogo de datos de AWS Glue como metaalmacén de Apache Spark Hive. Para obtener más información, consulte [Uso de los parámetros de trabajo en los trabajos de AWS Glue](aws-glue-programming-etl-glue-arguments.md). ------ #### [ Python ] Para este ejemplo, utilice el método `GlueContext.write\$1data\$1frame.from\$1catalog()`. ``` # Example: Upsert a Hudi table from Glue Data Catalog from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) glueContext.write_data_frame.from_catalog( frame = dataFrame, database = "", table_name = "", additional_options={ "hoodie.table.name": "", "hoodie.database.name": "", "hoodie.datasource.write.storage.type": "COPY_ON_WRITE", "hoodie.datasource.write.operation": "upsert", "hoodie.datasource.write.recordkey.field": "", "hoodie.datasource.write.precombine.field": "", "hoodie.datasource.write.partitionpath.field": "", "hoodie.datasource.write.hive_style_partitioning": "true", "hoodie.datasource.hive_sync.enable": "true", "hoodie.datasource.hive_sync.database": "", "hoodie.datasource.hive_sync.table": "", "hoodie.datasource.hive_sync.partition_fields": "", "hoodie.datasource.hive_sync.partition_extractor_class": "org.apache.hudi.hive.MultiPartKeysValueExtractor", "hoodie.datasource.hive_sync.use_jdbc": "false", "hoodie.datasource.hive_sync.mode": "hms" } ) ``` ------ #### [ Scala ] Para este ejemplo, utilice el método [getCatalogSink](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSink). ``` // Example: Upsert a Hudi table from Glue Data Catalog import com.amazonaws.services.glue.GlueContext import com.amazonaws.services.glue.util.JsonOptions import org.apacke.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) glueContext.getCatalogSink("", "", additionalOptions = JsonOptions(Map( "hoodie.table.name" -> "", "hoodie.database.name" -> "", "hoodie.datasource.write.storage.type" -> "COPY_ON_WRITE", "hoodie.datasource.write.operation" -> "upsert", "hoodie.datasource.write.recordkey.field" -> "", "hoodie.datasource.write.precombine.field" -> "", "hoodie.datasource.write.partitionpath.field" -> "", "hoodie.datasource.write.hive_style_partitioning" -> "true", "hoodie.datasource.hive_sync.enable" -> "true", "hoodie.datasource.hive_sync.database" -> "", "hoodie.datasource.hive_sync.table" -> "", "hoodie.datasource.hive_sync.partition_fields" -> "", "hoodie.datasource.hive_sync.partition_extractor_class" -> "org.apache.hudi.hive.MultiPartKeysValueExtractor", "hoodie.datasource.hive_sync.use_jdbc" -> "false", "hoodie.datasource.hive_sync.mode" -> "hms" ))) .writeDataFrame(dataFrame, glueContext) } } ``` ------ ## Ejemplo: leer una tabla de Hudi de Amazon S3 con Spark En este ejemplo, se lee una tabla de Hudi de Amazon S3 con la API de DataFrame de Spark. ------ #### [ Python ] ``` # Example: Read a Hudi table from S3 using a Spark DataFrame dataFrame = spark.read.format("hudi").load("s3://") ``` ------ #### [ Scala ] ``` // Example: Read a Hudi table from S3 using a Spark DataFrame val dataFrame = spark.read.format("hudi").load("s3://") ``` ------ ## Ejemplo: escribir una tabla de Hudi en Amazon S3 con Spark En este ejemplo, se escribe una tabla de Hudi en Amazon S3 con Spark. ------ #### [ Python ] ``` # Example: Write a Hudi table to S3 using a Spark DataFrame dataFrame.write.format("hudi") \ .options(**additional_options) \ .mode("overwrite") \ .save("s3://) ``` ------ #### [ Scala ] ``` // Example: Write a Hudi table to S3 using a Spark DataFrame dataFrame.write.format("hudi") .options(additionalOptions) .mode("overwrite") .save("s3://") ``` ------ ## Ejemplo: Lea y escriba una tabla Hudi con el control de permisos de Lake Formation En este ejemplo se lee y escribe una tabla Hudi con el control de permisos de Lake Formation. 1. Cree una tabla Hudi y regístrela en Lake Formation. 1. Para habilitar el control de permisos de Lake Formation, primero tendrá que registrar la tabla de la ruta Amazon S3 en Lake Formation. Para obtener más información, consulte [Registro de una ubicación de Amazon S3](https://docs.aws.amazon.com/lake-formation/latest/dg/register-location.html). Puede registrarlo desde la consola de Lake Formation o mediante la AWS CLI: ``` aws lakeformation register-resource --resource-arn arn:aws:s3:::/ --use-service-linked-role --region ``` Una vez que registre una ubicación de Amazon S3, cualquier tabla de AWS Glue que apunte a la ubicación (o a cualquiera de sus ubicaciones secundarias) devolverá el valor del parámetro `IsRegisteredWithLakeFormation` como verdadero en la llamada `GetTable`. 1. Cree una tabla Hudi que apunte a la ruta de Amazon S3 registrada a través de la API de marcos de datos de Spark: ``` hudi_options = { 'hoodie.table.name': table_name, 'hoodie.database.name': database_name, 'hoodie.datasource.write.storage.type': 'COPY_ON_WRITE', 'hoodie.datasource.write.recordkey.field': 'product_id', 'hoodie.datasource.write.table.name': table_name, 'hoodie.datasource.write.operation': 'upsert', 'hoodie.datasource.write.precombine.field': 'updated_at', 'hoodie.datasource.write.hive_style_partitioning': 'true', 'hoodie.upsert.shuffle.parallelism': 2, 'hoodie.insert.shuffle.parallelism': 2, 'path': , 'hoodie.datasource.hive_sync.enable': 'true', 'hoodie.datasource.hive_sync.database': database_name, 'hoodie.datasource.hive_sync.table': table_name, 'hoodie.datasource.hive_sync.use_jdbc': 'false', 'hoodie.datasource.hive_sync.mode': 'hms' } df_products.write.format("hudi") \ .options(**hudi_options) \ .mode("overwrite") \ .save() ``` 1. Conceda permiso a Lake Formation para el rol de IAM del trabajo de AWS Glue. Puede conceder permisos desde la consola de Lake Formation o mediante la AWS CLI. Para obtener más información, consulte [Concesión de permisos de tabla mediante la consola de Lake Formation y el método de recurso con nombre](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-table-permissions.html) 1. Lea la tabla Hudi registrada en Lake Formation. El código es el mismo que leer una tabla Hudi no registrada. Tenga en cuenta que el rol de IAM del trabajo de AWS Glue debe tener el permiso SELECT para que la lectura se realice correctamente. ``` val dataFrame = glueContext.getCatalogSource( database = "", tableName = "" ).getDataFrame() ``` 1. Escribe en una tabla Hudi registrada en Lake Formation. El código es el mismo que escribir en una tabla Hudi no registrada. Tenga en cuenta que el rol de IAM del trabajo de AWS Glue debe tener el permiso SUPER para que la escritura se realice correctamente. ``` glueContext.getCatalogSink("", "", additionalOptions = JsonOptions(Map( "hoodie.table.name" -> "", "hoodie.database.name" -> "", "hoodie.datasource.write.storage.type" -> "COPY_ON_WRITE", "hoodie.datasource.write.operation" -> "", "hoodie.datasource.write.recordkey.field" -> "", "hoodie.datasource.write.precombine.field" -> "", "hoodie.datasource.write.partitionpath.field" -> "", "hoodie.datasource.write.hive_style_partitioning" -> "true", "hoodie.datasource.hive_sync.enable" -> "true", "hoodie.datasource.hive_sync.database" -> "", "hoodie.datasource.hive_sync.table" -> "", "hoodie.datasource.hive_sync.partition_fields" -> "", "hoodie.datasource.hive_sync.partition_extractor_class" -> "org.apache.hudi.hive.MultiPartKeysValueExtractor", "hoodie.datasource.hive_sync.use_jdbc" -> "false", "hoodie.datasource.hive_sync.mode" -> "hms" ))) .writeDataFrame(dataFrame, glueContext) ``` # Uso del marco de Delta Lake en AWS Glue AWS Glue 3.0 y versiones posteriores son compatibles con el marco de Linux Foundation Delta Lake. Delta Lake es un marco de almacenamiento de lagos de datos de código abierto para hacer transacciones de ACID, escalar el manejo de metadatos y unificar la transmisión y el procesamiento de datos por lotes. En este tema se describen las características disponibles para usar los datos en AWS Glue al transportar o almacenar datos en una tabla de Delta Lake. Para más información acerca de Delta Lake, consulte la [documentación oficial de Delta Lake](https://docs.delta.io/latest/delta-intro.html). Puede usar AWS Glue para llevar a cabo operaciones de lectura y escritura en tablas de Delta Lake en Amazon S3, o trabajar con tablas de Delta Lake mediante el Catálogo de datos de AWS Glue. También se admiten operaciones adicionales, como la inserción, la actualización y las [lecturas y escrituras de tablas por lotes](https://docs.delta.io/0.7.0/api/python/index.html). Cuando usa tablas de Delta Lake, también tiene la opción de usar métodos de la biblioteca de Python de Delta Lake, como `DeltaTable.forPath`. Para obtener más información sobre la biblioteca de Python de Delta Lake, consulte la documentación de Python de Delta Lake. En la siguiente tabla, se muestra la versión de Delta Lake que se incluye en cada versión de AWS Glue. **** | Versión de AWS Glue | Versión de Delta Lake compatible | | --- | --- | | 5.1 | 3.3.2 | | 5.0 | 3.3.0 | | 4.0 | 2.1.0 | | 3.0 | 1.0.0 | Para más información sobre los marcos de lagos de datos compatibles con AWS Glue, consulte [Uso de marcos de lagos de datos con trabajos de ETL de AWS Glue](aws-glue-programming-etl-datalake-native-frameworks.md). ## Habilitar Delta Lake para AWS Glue Para activar Delta Lake para AWS Glue, haga las siguientes tareas: + Especifique `delta` como valor para el parámetro del trabajo `--datalake-formats`. Para obtener más información, consulte [Uso de los parámetros de trabajo en los trabajos de AWS Glue](aws-glue-programming-etl-glue-arguments.md). + Cree una clave con el nombre `--conf` para el trabajo de AWS Glue y establézcala en el siguiente valor. Como alternativa, puede establecer la siguiente configuración mediante `SparkConf` en su script. Esta configuración ayuda a Apache Spark a gestionar correctamente las tablas de Delta Lake. ``` spark.sql.extensions=io.delta.sql.DeltaSparkSessionExtension --conf spark.sql.catalog.spark_catalog=org.apache.spark.sql.delta.catalog.DeltaCatalog --conf spark.delta.logStore.class=org.apache.spark.sql.delta.storage.S3SingleDriverLogStore ``` + La compatibilidad con los permisos de Lake Formation para las tablas Delta está habilitada de forma predeterminada en AWS Glue 4.0. No se necesita ninguna configuración adicional para leer o escribir en las tablas Delta registradas en Lake Formation. Para leer una tabla Delta registrada, el rol de IAM del trabajo de AWS Glue debe tener el permiso SELECT. Para escribir en una tabla Delta registrada, el rol de IAM de AWS Glue debe tener el permiso SUPER. Para obtener más información sobre la administración de los permisos de Lake Formation, consulte [Otorgar y revocar permisos en los recursos del catálogo de datos](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-catalog-permissions.html). **Uso de una versión diferente de Delta Lake** Para usar una versión de Delta Lake que no sea compatible con AWS Glue, indique sus propios archivos JAR de Delta Lake mediante el parámetro de trabajo `--extra-jars`. No incluya `delta` como valor para el parámetro de trabajo `--datalake-formats`. Si usa AWS Glue 5.0 o versiones posteriores, debe configurar el parámetro de trabajo `--user-jars-first true`. En este caso, para utilizar la biblioteca de Python de Delta Lake, debe especificar los archivos JAR de la biblioteca mediante el parámetro de trabajo `--extra-py-files`. La biblioteca de Python viene empaquetada en los archivos JAR de Delta Lake. ## Ejemplo: escribir una tabla de Delta Lake en Amazon S3 y regístrela en el Catálogo de datos de AWS Glue El siguiente script ETL de AWS Glue muestra cómo escribir una tabla de Delta Lake en Amazon S3 y registrar la tabla en el Catálogo de datos de AWS Glue. ------ #### [ Python ] ``` # Example: Create a Delta Lake table from a DataFrame # and register the table to Glue Data Catalog additional_options = { "path": "s3://" } dataFrame.write \ .format("delta") \ .options(**additional_options) \ .mode("append") \ .partitionBy("") \ .saveAsTable(".") ``` ------ #### [ Scala ] ``` // Example: Example: Create a Delta Lake table from a DataFrame // and register the table to Glue Data Catalog val additional_options = Map( "path" -> "s3://" ) dataFrame.write.format("delta") .options(additional_options) .mode("append") .partitionBy("") .saveAsTable(".") ``` ------ ## Ejemplo: leer una tabla de Delta Lake de Amazon S3 con el Catálogo de datos de AWS Glue El siguiente script de ETL de AWS Glue lee la tabla de Delta Lake que creó en [Ejemplo: escribir una tabla de Delta Lake en Amazon S3 y regístrela en el Catálogo de datos de AWS Glue](#aws-glue-programming-etl-format-delta-lake-write). ------ #### [ Python ] Para este ejemplo, utilice el método [create\$1data\$1frame.from\$1catalog](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create-dataframe-from-catalog). ``` # Example: Read a Delta Lake table from Glue Data Catalog from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) df = glueContext.create_data_frame.from_catalog( database="", table_name="", additional_options=additional_options ) ``` ------ #### [ Scala ] Para este ejemplo, utilice el método [getCatalogSource](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSource). ``` // Example: Read a Delta Lake table from Glue Data Catalog import com.amazonaws.services.glue.GlueContext import org.apacke.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) val df = glueContext.getCatalogSource("", "", additionalOptions = additionalOptions) .getDataFrame() } } ``` ------ ## Ejemplo: insertar un elemento `DataFrame` en una tabla de Delta Lake de Amazon S3 con el Catálogo de datos de AWS Glue En este ejemplo, se insertan los datos en la tabla de Delta Lake que creó en [Ejemplo: escribir una tabla de Delta Lake en Amazon S3 y regístrela en el Catálogo de datos de AWS Glue](#aws-glue-programming-etl-format-delta-lake-write). **nota** En este ejemplo, se requiere que establezca el parámetro de trabajo de `--enable-glue-datacatalog` para utilizar el Catálogo de datos de AWS Glue como metaalmacén de Apache Spark Hive. Para obtener más información, consulte [Uso de los parámetros de trabajo en los trabajos de AWS Glue](aws-glue-programming-etl-glue-arguments.md). ------ #### [ Python ] Para este ejemplo, utilice el método [write\$1data\$1frame.from\$1catalog](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_data_frame_from_catalog). ``` # Example: Insert into a Delta Lake table in S3 using Glue Data Catalog from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) glueContext.write_data_frame.from_catalog( frame=dataFrame, database="", table_name="", additional_options=additional_options ) ``` ------ #### [ Scala ] Para este ejemplo, utilice el método [getCatalogSink](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSink). ``` // Example: Insert into a Delta Lake table in S3 using Glue Data Catalog import com.amazonaws.services.glue.GlueContext import org.apacke.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) glueContext.getCatalogSink("", "", additionalOptions = additionalOptions) .writeDataFrame(dataFrame, glueContext) } } ``` ------ ## Ejemplo: leer una tabla de Delta Lake de Amazon S3 con la API de Spark En este ejemplo, se lee una tabla de Delta Lake de Amazon S3 con la API de Spark. ------ #### [ Python ] ``` # Example: Read a Delta Lake table from S3 using a Spark DataFrame dataFrame = spark.read.format("delta").load("s3://") ``` ------ #### [ Scala ] ``` // Example: Read a Delta Lake table from S3 using a Spark DataFrame val dataFrame = spark.read.format("delta").load("s3://") ``` ------ ## Ejemplo: escribir una tabla de Delta Lake en Amazon S3 con Spark En este ejemplo, se escribe una tabla de Delta Lake en Amazon S3 con Spark. ------ #### [ Python ] ``` # Example: Write a Delta Lake table to S3 using a Spark DataFrame dataFrame.write.format("delta") \ .options(**additional_options) \ .mode("overwrite") \ .partitionBy("") .save("s3://") ``` ------ #### [ Scala ] ``` // Example: Write a Delta Lake table to S3 using a Spark DataFrame dataFrame.write.format("delta") .options(additionalOptions) .mode("overwrite") .partitionBy("") .save("s3://") ``` ------ ## Ejemplo: Lea y escriba la tabla de Delta Lake con el control de permisos de Lake Formation En este ejemplo se lee y escribe una tabla de Delta Lake con el control de permisos de Lake Formation. 1. Cree una tabla Delta y regístrela en Lake Formation 1. Para habilitar el control de permisos de Lake Formation, primero tendrá que registrar la tabla de la ruta Amazon S3 en Lake Formation. Para obtener más información, consulte [Registro de una ubicación de Amazon S3](https://docs.aws.amazon.com/lake-formation/latest/dg/register-location.html). Puede registrarlo desde la consola de Lake Formation o mediante la AWS CLI: ``` aws lakeformation register-resource --resource-arn arn:aws:s3:::/ --use-service-linked-role --region ``` Una vez que registre una ubicación de Amazon S3, cualquier tabla de AWS Glue que apunte a la ubicación (o a cualquiera de sus ubicaciones secundarias) devolverá el valor del parámetro `IsRegisteredWithLakeFormation` como verdadero en la llamada `GetTable`. 1. Cree una tabla Delta que apunte a la ruta de Amazon S3 registrada a través de Spark: **nota** A continuación, se muestran algunos ejemplos de Python. ``` dataFrame.write \ .format("delta") \ .mode("overwrite") \ .partitionBy("") \ .save("s3://") ``` Una vez que los datos se hayan escrito en Amazon S3, utilice el rastreador AWS Glue para crear una nueva tabla de catálogo de Delta. Para obtener más información, consulte [Presentación del soporte de tabla nativa de Delta Lake con rastreadores AWS Glue](https://aws.amazon.com/blogs/big-data/introducing-native-delta-lake-table-support-with-aws-glue-crawlers/). También puede crear la tabla manualmente a través de la API de AWS Glue.`CreateTable` 1. Conceda permiso a Lake Formation para el rol de IAM del trabajo de AWS Glue. Puede conceder permisos desde la consola de Lake Formation o mediante la AWS CLI. Para obtener más información, consulte [Concesión de permisos de tabla mediante la consola de Lake Formation y el método de recurso con nombre](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-table-permissions.html) 1. Lea la tabla Delta registrada en Lake Formation. El código es el mismo que leer una tabla Delta no registrada. Tenga en cuenta que el rol de IAM del trabajo de AWS Glue debe tener el permiso SELECT para que la lectura se realice correctamente. ``` # Example: Read a Delta Lake table from Glue Data Catalog df = glueContext.create_data_frame.from_catalog( database="", table_name="", additional_options=additional_options ) ``` 1. Escribe a una tabla Delta registrada en Lake Formation. El código es el mismo que escribir en una tabla Delta no registrada. Tenga en cuenta que el rol de IAM del trabajo de AWS Glue debe tener el permiso SUPER para que la escritura se realice correctamente. De forma predeterminada, AWS Glue usa `Append` como SaveMode. Puede cambiarlo configurando la opción SaveMode en `additional_options`. Para obtener información sobre la compatibilidad con SaveMode en las tablas Delta, consulte [Escribir en una tabla](https://docs.delta.io/latest/delta-batch.html#write-to-a-table). ``` glueContext.write_data_frame.from_catalog( frame=dataFrame, database="", table_name="", additional_options=additional_options ) ``` # Uso del marco de Iceberg en AWS Glue AWS Glue 3.0 y versiones posteriores son compatibles con el marco de Apache Iceberg para lagos de datos. Iceberg proporciona un formato de tabla de alto rendimiento que funciona igual que una tabla SQL. En este tema, se describen las características disponibles para usar los datos en AWS Glue al transportar o almacenar datos en una tabla de Iceberg. Para más información sobre Iceberg, consulte la [documentación oficial de Apache Iceberg](https://iceberg.apache.org/docs/latest/). Puede usar AWS Glue para llevar a cabo operaciones de lectura y escritura en tablas de Iceberg en Amazon S3, o trabajar con tablas de Iceberg mediante el Catálogo de datos de AWS Glue. También se admiten operaciones adicionales, como insertar, y todas las [consultas de Spark](https://iceberg.apache.org/docs/latest/spark-queries/) [escrituras de Spark](https://iceberg.apache.org/docs/latest/spark-writes/). La actualización no es compatible con las tablas de Iceberg. **nota** `ALTER TABLE … RENAME TO` no está disponible para Apache Iceberg 0.13.1 para AWS Glue 3.0. La siguiente tabla muestra la versión de Iceberg que se incluye en cada versión de AWS Glue. **** | Versión de AWS Glue | Versión de Iceberg compatible | | --- | --- | | 5.1 | 1.10.0 | | 5.0 | 1.7.1 | | 4.0 | 1.0.0 | | 3.0 | 0.13.1 | Para más información sobre los marcos de lagos de datos compatibles con AWS Glue, consulte [Uso de marcos de lagos de datos con trabajos de ETL de AWS Glue](aws-glue-programming-etl-datalake-native-frameworks.md). ## Habilitar el marco de Iceberg Para habilitar Iceberg para AWS Glue, haga las siguientes tareas: + Especifique `iceberg` como valor para el parámetro del trabajo `--datalake-formats`. Para obtener más información, consulte [Uso de los parámetros de trabajo en los trabajos de AWS Glue](aws-glue-programming-etl-glue-arguments.md). + Cree una clave con el nombre `--conf` para el trabajo de AWS Glue y establézcala en el siguiente valor. Como alternativa, puede establecer la siguiente configuración mediante `SparkConf` en su script. Esta configuración ayuda a Apache Spark a gestionar correctamente las tablas de Iceberg. ``` spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions --conf spark.sql.catalog.glue_catalog=org.apache.iceberg.spark.SparkCatalog --conf spark.sql.catalog.glue_catalog.warehouse=s3:/// --conf spark.sql.catalog.glue_catalog.catalog-impl=org.apache.iceberg.aws.glue.GlueCatalog --conf spark.sql.catalog.glue_catalog.io-impl=org.apache.iceberg.aws.s3.S3FileIO ``` Si lee o escribe en tablas de Iceberg registradas en Lake Formation, siga las indicaciones que aparecen en [Uso de AWS Glue con AWS Lake Formation para obtener un control de acceso detallado](security-lf-enable.md) en AWS Glue 5.0 y versiones posteriores. En AWS Glue 4.0, agregue la siguiente configuración para habilitar la compatibilidad con Lake Formation. ``` --conf spark.sql.catalog.glue_catalog.glue.lakeformation-enabled=true --conf spark.sql.catalog.glue_catalog.glue.id= ``` Si utiliza AWS Glue 3.0 con Iceberg 0.13.1, debe establecer las siguientes configuraciones adicionales para utilizar el administrador de bloqueos de Amazon DynamoDB y garantizar la transacción atómica. AWS Glue 4.0 y versiones posteriores utilizan el bloqueo positivo de forma predeterminada. Para obtener más información, consulte [Iceberg AWS Integrations](https://iceberg.apache.org/docs/latest/aws/#dynamodb-lock-manager) en la documentación oficial de Apache Iceberg. ``` --conf spark.sql.catalog.glue_catalog.lock-impl=org.apache.iceberg.aws.glue.DynamoLockManager --conf spark.sql.catalog.glue_catalog.lock.table= ``` **Usar una versión diferente de Iceberg** Para usar una versión de Iceberg que no sea compatible con AWS Glue, indique sus propios archivos JAR de Iceberg mediante el parámetro de trabajo `--extra-jars`. No incluya `iceberg` como valor para el parámetro `--datalake-formats`. Si usa AWS Glue 5.0 o versiones posteriores, debe configurar el parámetro de trabajo `--user-jars-first true`. **Habilitar el cifrado para tablas de Iceberg** **nota** Las tablas de Iceberg tienen sus propios mecanismos para habilitar el cifrado del lado del servidor. Debe habilitar esta configuración además de la configuración de seguridad de Glue AWS. Para habilitar el cifrado del lado del servidor en las tablas de Iceberg, consulte las instrucciones de la [documentación de Iceberg.](https://iceberg.apache.org/docs/latest/aws/#s3-server-side-encryption) **Agregue la configuración de Spark para el acceso entre regiones de Iceberg** Para añadir una configuración adicional de Spark para el acceso a tablas entre regiones de Iceberg con el catálogo de datos de AWS Glue y AWS Lake Formation, siga los pasos que se indican a continuación: 1. Creación de un [punto de acceso de varias regiones](https://docs.aws.amazon.com/AmazonS3/latest/userguide/multi-region-access-point-create-examples.html). 1. Defina las siguientes propiedades de Spark: ``` ----- --conf spark.sql.catalog.my_catalog.s3.use-arn-region-enabled=true \ --conf spark.sql.catalog.{CATALOG}.s3.access-points.bucket1", "arn:aws:s3:::accesspoint/.mrap \ --conf spark.sql.catalog.{CATALOG}.s3.access-points.bucket2", "arn:aws:s3:::accesspoint/.mrap ----- ``` ## Ejemplo: escriba una tabla de Iceberg en Amazon S3 y regístrela en el Catálogo de datos de AWS Glue En este script de ejemplo, se muestra cómo escribir una tabla de Iceberg en Amazon S3. En el ejemplo se usan [integraciones de AWS de Iceberg](https://iceberg.apache.org/docs/latest/aws/) para registrar la tabla en el Catálogo de datos de AWS Glue. ------ #### [ Python ] ``` # Example: Create an Iceberg table from a DataFrame # and register the table to Glue Data Catalog dataFrame.createOrReplaceTempView("tmp_") query = f""" CREATE TABLE glue_catalog.. USING iceberg TBLPROPERTIES ("format-version"="2") AS SELECT * FROM tmp_ """ spark.sql(query) ``` ------ #### [ Scala ] ``` // Example: Example: Create an Iceberg table from a DataFrame // and register the table to Glue Data Catalog dataFrame.createOrReplaceTempView("tmp_") val query = """CREATE TABLE glue_catalog.. USING iceberg TBLPROPERTIES ("format-version"="2") AS SELECT * FROM tmp_ """ spark.sql(query) ``` ------ Como alternativa, puede escribir una tabla de Iceberg en Amazon S3 y en el Catálogo de datos con los métodos de Spark. Requisitos previos: deberá disponer de un catálogo para su uso en la biblioteca Iceberg. Cuando se utiliza el AWS catálogo de datos de Glue AWS, Glue lo simplifica. El catálogo de datos de Glue AWS está preconfigurado para que lo utilicen las bibliotecas de Spark como `glue_catalog`. Las tablas del catálogo de datos se identifican mediante un *databaseName* y un *tableName*. Para obtener más información sobre el catálogo de datos de Glue AWS, consulte [Detección y catalogación de datos en AWS Glue](catalog-and-crawler.md). Si no utiliza el catálogo de datos de Glue AWS, tendrá que aprovisionar un catálogo a través de las API de Spark. Para obtener más información, consulte [Configuración de Spark](https://iceberg.apache.org/docs/latest/spark-configuration/) en la documentación de Iceberg. En este ejemplo, se escribe una tabla de Iceberg en Amazon S3 y el Catálogo de datos con Spark. ------ #### [ Python ] ``` # Example: Write an Iceberg table to S3 on the Glue Data Catalog # Create (equivalent to CREATE TABLE AS SELECT) dataFrame.writeTo("glue_catalog.databaseName.tableName") \ .tableProperty("format-version", "2") \ .create() # Append (equivalent to INSERT INTO) dataFrame.writeTo("glue_catalog.databaseName.tableName") \ .tableProperty("format-version", "2") \ .append() ``` ------ #### [ Scala ] ``` // Example: Write an Iceberg table to S3 on the Glue Data Catalog // Create (equivalent to CREATE TABLE AS SELECT) dataFrame.writeTo("glue_catalog.databaseName.tableName") .tableProperty("format-version", "2") .create() // Append (equivalent to INSERT INTO) dataFrame.writeTo("glue_catalog.databaseName.tableName") .tableProperty("format-version", "2") .append() ``` ------ ## Ejemplo: leer una tabla de Iceberg de Amazon S3 con el Catálogo de datos de AWS Glue En este ejemplo, se lee la tabla de Iceberg que creó en [Ejemplo: escriba una tabla de Iceberg en Amazon S3 y regístrela en el Catálogo de datos de AWS Glue](#aws-glue-programming-etl-format-iceberg-write). ------ #### [ Python ] Para este ejemplo, utilice el método `GlueContext.create\$1data\$1frame.from\$1catalog()`. ``` # Example: Read an Iceberg table from Glue Data Catalog from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) df = glueContext.create_data_frame.from_catalog( database="", table_name="", additional_options=additional_options ) ``` ------ #### [ Scala ] Para este ejemplo, utilice el método [getCatalogSource](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSource). ``` // Example: Read an Iceberg table from Glue Data Catalog import com.amazonaws.services.glue.GlueContext import org.apacke.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) val df = glueContext.getCatalogSource("", "", additionalOptions = additionalOptions) .getDataFrame() } } ``` ------ ## Ejemplo: insertar un `DataFrame` en una tabla de Iceberg de Amazon S3 con el Catálogo de datos de AWS Glue En este ejemplo, se insertan los datos en la tabla de Iceberg que creó en [Ejemplo: escriba una tabla de Iceberg en Amazon S3 y regístrela en el Catálogo de datos de AWS Glue](#aws-glue-programming-etl-format-iceberg-write). **nota** En este ejemplo, se requiere que establezca el parámetro de trabajo de `--enable-glue-datacatalog` para utilizar el Catálogo de datos de AWS Glue como metaalmacén de Apache Spark Hive. Para obtener más información, consulte [Uso de los parámetros de trabajo en los trabajos de AWS Glue](aws-glue-programming-etl-glue-arguments.md). ------ #### [ Python ] Para este ejemplo, utilice el método `GlueContext.write\$1data\$1frame.from\$1catalog()`. ``` # Example: Insert into an Iceberg table from Glue Data Catalog from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) glueContext.write_data_frame.from_catalog( frame=dataFrame, database="", table_name="", additional_options=additional_options ) ``` ------ #### [ Scala ] Para este ejemplo, utilice el método [getCatalogSink](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSink). ``` // Example: Insert into an Iceberg table from Glue Data Catalog import com.amazonaws.services.glue.GlueContext import org.apacke.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) glueContext.getCatalogSink("", "", additionalOptions = additionalOptions) .writeDataFrame(dataFrame, glueContext) } } ``` ------ ## Ejemplo: leer una tabla de Iceberg de Amazon S3 con Spark Requisitos previos: deberá disponer de un catálogo para su uso en la biblioteca Iceberg. Cuando se utiliza el AWS catálogo de datos de Glue AWS, Glue lo simplifica. El catálogo de datos de Glue AWS está preconfigurado para que lo utilicen las bibliotecas de Spark como `glue_catalog`. Las tablas del catálogo de datos se identifican mediante un *databaseName* y un *tableName*. Para obtener más información sobre el catálogo de datos de Glue AWS, consulte [Detección y catalogación de datos en AWS Glue](catalog-and-crawler.md). Si no utiliza el catálogo de datos de Glue AWS, tendrá que aprovisionar un catálogo a través de las API de Spark. Para obtener más información, consulte [Configuración de Spark](https://iceberg.apache.org/docs/latest/spark-configuration/) en la documentación de Iceberg. En este ejemplo, se lee una tabla de Iceberg en Amazon S3 del catálogo de datos con Spark. ------ #### [ Python ] ``` # Example: Read an Iceberg table on S3 as a DataFrame from the Glue Data Catalog dataFrame = spark.read.format("iceberg").load("glue_catalog.databaseName.tableName") ``` ------ #### [ Scala ] ``` // Example: Read an Iceberg table on S3 as a DataFrame from the Glue Data Catalog val dataFrame = spark.read.format("iceberg").load("glue_catalog.databaseName.tableName") ``` ------ ## Ejemplo: Lea y escriba una tabla de iceberg con el control de permisos de Lake Formation En este ejemplo se lee y escribe una tabla de Iceberg con el control de permisos de Lake Formation. **nota** Este ejemplo solo funciona en AWS Glue 4.0. En AWS Glue 5.0 y versiones posteriores, siga las indicaciones que aparece en [Uso de AWS Glue con AWS Lake Formation para obtener un control de acceso detallado](security-lf-enable.md). 1. Cree una tabla de iceberg y regístrela en Lake Formation: 1. Para habilitar el control de permisos de Lake Formation, primero tendrá que registrar la tabla de la ruta Amazon S3 en Lake Formation. Para obtener más información, consulte [Registro de una ubicación de Amazon S3](https://docs.aws.amazon.com/lake-formation/latest/dg/register-location.html). Puede registrarlo desde la consola de Lake Formation o mediante la AWS CLI: ``` aws lakeformation register-resource --resource-arn arn:aws:s3:::/ --use-service-linked-role --region ``` Una vez que registre una ubicación de Amazon S3, cualquier tabla de AWS Glue que apunte a la ubicación (o a cualquiera de sus ubicaciones secundarias) devolverá el valor del parámetro `IsRegisteredWithLakeFormation` como verdadero en la llamada `GetTable`. 1. Cree una tabla de Iceberg que apunte a la ruta registrada mediante Spark SQL: **nota** A continuación, se muestran algunos ejemplos de Python. ``` dataFrame.createOrReplaceTempView("tmp_") query = f""" CREATE TABLE glue_catalog.. USING iceberg AS SELECT * FROM tmp_ """ spark.sql(query) ``` También puede crear la tabla manualmente mediante la API de AWS Glue.`CreateTable` Para obtener más información, consulte [Creación de tablas de Apache Iceberg](https://docs.aws.amazon.com/lake-formation/latest/dg/creating-iceberg-tables.html). **nota** Actualmente, la API `UpdateTable` no es compatible con el formato de tabla Iceberg como entrada para la operación. 1. Conceda permiso a Lake Formation para el rol de IAM. Puede conceder permisos desde la consola de Lake Formation o mediante la AWS CLI. Para obtener más información, consulte: https://docs.aws.amazon.com/lake-formation/latest/dg/granting-table-permissions.html 1. Lea una tabla de Iceberg registrada en Lake Formation. El código es el mismo que leer una tabla de Icebergs no registrada. Tenga en cuenta que el rol de IAM de su trabajo de AWS Glue debe tener el permiso SELECT para que la lectura se realice correctamente. ``` # Example: Read an Iceberg table from the AWS Glue Data Catalog from awsglue.context import GlueContextfrom pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) df = glueContext.create_data_frame.from_catalog( database="", table_name="", additional_options=additional_options ) ``` 1. Escriba en una tabla de Iceberg registrada en Lake Formation. El código es el mismo que escribir en una tabla Iceberg no registrada. Tenga en cuenta que su rol de IAM del trabajo de AWS Glue debe tener el permiso SUPER para que la escritura se realice correctamente. ``` glueContext.write_data_frame.from_catalog( frame=dataFrame, database="", table_name="", additional_options=additional_options ) ``` ## Referencia de configuración compartida Puede utilizar los siguientes `format_options` valores con cualquier tipo de formato. + `attachFilename` — Una cadena en el formato adecuado para utilizarla como nombre de columna. Si proporciona esta opción, el nombre del archivo de origen para el registro se adjuntará a él. El valor del parámetro se utilizará como nombre de la columna. + `attachTimestamp` — Una cadena en el formato adecuado para utilizarla como nombre de columna. Si proporciona esta opción, la hora de modificación del archivo de origen para el registro se adjuntará a él. El valor del parámetro se utilizará como nombre de la columna.