# 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.