Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Utilizzo del formato Parquet in AWS Glue AWS Glue recupera i dati dalle fonti e li scrive su destinazioni archiviate e trasportate in vari formati di dati. Se i dati vengono archiviati o trasportati nel formato dati Parquet, questo documento presenta le funzionalità disponibili per l'utilizzo dei dati in AWS Glue. AWS Glue supporta l'utilizzo del formato Parquet. Questo formato è un formato dati basato su colonne orientato alle prestazioni. Per un'introduzione al formato da parte dell'autorità standard, consulta [Panoramica della documentazione di Apache Parquet](https://parquet.apache.org/docs/overview/). Puoi usare AWS Glue per leggere file Parquet da Amazon S3 e da sorgenti di streaming, nonché scrivere file Parquet su Amazon S3. Puoi leggere e scrivere gli archivi `bzip` e `gzip` contenenti file Parquet da S3. Puoi configurare il comportamento di compressione sul [Parametri di connessione di S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) invece che nella configurazione discussa in questa pagina. La tabella seguente mostra quali funzioni comuni di AWS Glue supportano l'opzione di formato Parquet. | Lettura | Scrittura | Lettura in streaming | Gruppo di file piccoli | Segnalibri di processo | | --- | --- | --- | --- | --- | | Supportata | Supportato | Supportata | Non supportato. | Supportato\$1 | \$1 Supportato nella versione AWS Glue 1.0\$1 ## Esempio: lettura di file Parquet o cartelle da S3 **Prerequisiti:** avrai bisogno dei percorsi S3 (`s3path`) nei file Parquet o nelle cartelle che desideri leggere. **Configurazione:** nelle opzioni della funzione, specifica `format="parquet"`. Nelle tue `connection_options`, utilizza la chiave `paths` per specificare `s3path`. Puoi configurare il modo in cui il reader interagisce con S3 in `connection_options`. Per i dettagli, vedi Tipi di connessione e opzioni per ETL in AWS Glue:[Parametri di connessione di S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Puoi configurare il modo in cui il reader interpreta i file Parquet nel tuo `format_options`. Per maggiori dettagli, consulta [Riferimento alla configurazione Parquet](#aws-glue-programming-etl-format-parquet-reference). Il seguente script AWS Glue ETL mostra il processo di lettura dei file o delle cartelle Parquet da S3: ------ #### [ Python ] Per questo esempio, utilizzare il metodo [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" ) ``` Puoi anche usarlo DataFrames in uno script ()`pyspark.sql.DataFrame`. ``` dataFrame = spark.read.parquet("s3://s3path/") ``` ------ #### [ Scala ] Per questo esempio, utilizzate il metodo [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() } } ``` È inoltre possibile utilizzare DataFrames in uno script (`org.apache.spark.sql.DataFrame`). ``` spark.read.parquet("s3://s3path/") ``` ------ ## Esempio: scrittura di file e cartelle Parquet su S3 **Prerequisiti:** è necessario un DataFrame (`dataFrame`) o DynamicFrame (`dynamicFrame`) inizializzato. È necessario anche del tuo percorso di output S3 previsto, `s3path`. **Configurazione:** nelle opzioni della funzione, specifica `format="parquet"`. In `connection_options`, utilizzare la chiave `paths` per specificare `s3path`. È possibile modificare ulteriormente il modo in cui il writer interagisce con S3 nelle `connection_options`. Per i dettagli, vedi Tipi di connessione e opzioni per ETL in AWS Glue:[Parametri di connessione di S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Puoi configurare il modo in cui l'operazione scrive il contenuto dei file in `format_options`. Per maggiori dettagli, consulta .[Riferimento alla configurazione Parquet](#aws-glue-programming-etl-format-parquet-reference). Il seguente script AWS Glue ETL mostra il processo di scrittura di file e cartelle Parquet su S3. Forniamo uno scrittore Parquet personalizzato con ottimizzazioni delle prestazioni DynamicFrames, tramite la `useGlueParquetWriter` chiave di configurazione. Per determinare se questo writer è adatto al tuo carico di lavoro, consulta [Scrittore Glue Parquet](#aws-glue-programming-etl-format-glue-parquet-writer). ------ #### [ Python ] Per questo esempio, utilizza il metodo [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, }, ) ``` Puoi anche usarlo DataFrames in uno script (`pyspark.sql.DataFrame`). ``` df.write.parquet("s3://s3path/") ``` ------ #### [ Scala ] Per questo esempio, utilizzate il metodo [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) } } ``` È inoltre possibile utilizzare DataFrames in uno script (`org.apache.spark.sql.DataFrame`). ``` df.write.parquet("s3://s3path/") ``` ------ ## Riferimento alla configurazione Parquet Puoi usare quanto segue `format_options` ovunque le librerie AWS Glue lo specifichino`format="parquet"`: + `useGlueParquetWriter`— Speciifica l'uso di un writer Parquet personalizzato con ottimizzazioni delle prestazioni per DynamicFrame i flussi di lavoro. Per informazioni dettagliate sull'utilizzo, consulta [Writer Glue Parquet](#aws-glue-programming-etl-format-glue-parquet-writer). + **Tipo:** booleano, **Valore predefinito:** `false` + `compression`: specifica il codec di compressione utilizzato. I valori sono pienamente compatibili con `org.apache.parquet.hadoop.metadata.CompressionCodecName`. + **Tipo:** testo enumerato, **Valore predefinito:** `"snappy"` + Valori: `"uncompressed"`, `"snappy"`, `"gzip"` e `"lzo"` + `blockSize`: specifica la dimensione in byte di un gruppo di righe memorizzate nel buffer in memoria. Utilizzi questo valore per ottimizzare le prestazioni. Le dimensioni dovrebbero dividersi esattamente in un numero di megabyte. + **Tipo:** numerico, **Valore predefinito:** `134217728` + Il valore predefinito è 128 MB. + `pageSize`: specifica le dimensioni in byte di una pagina. Utilizzi questo valore per ottimizzare le prestazioni. Una pagina è l'unità più piccola che deve essere letta interamente per accedere a un singolo record. + **Tipo:** numerico, **Valore predefinito:** `1048576` + Il valore predefinito è 1 MB. **Nota** Inoltre, tutte le opzioni accettate dal codice SparkSQL sottostante possono essere passate tramite il parametro mappa `connection_options`. Ad esempio, puoi impostare una configurazione Spark come [mergeSchema](https://spark.apache.org/docs/latest/sql-data-sources-parquet.html#schema-merging) per il reader Spark di AWS Glue per unire lo schema di tutti i file. ## Ottimizza le prestazioni di scrittura con AWS Glue Parquet writer **Nota** Storicamente si accedeva al writer AWS Glue Parquet tramite il tipo di `glueparquet` formato. Questo schema di accesso non è più raccomandato. Utilizza invece il tipo `parquet` con `useGlueParquetWriter` abilitato. Il AWS masterizzatore Glue Parquet presenta miglioramenti delle prestazioni che consentono una scrittura più rapida dei file Parquet. Il writer tradizionale calcola uno schema prima della scrittura. Il formato Parquet non memorizza lo schema in un modo recuperabile rapidamente, quindi questa operazione potrebbe richiedere del tempo. Con lo scrittore AWS Glue Parquet, non è necessario uno schema precalcolato. Quando arrivano i dati, il writer calcola e modifica lo schema in modo dinamico. Quando specifichi `useGlueParquetWriter`, tieni presente le seguenti limitazioni: + Il writer supporta solo l'evoluzione dello schema, come l'aggiunta o la rimozione di colonne, ma non la modifica dei tipi di colonna, ad esempio con `ResolveChoice`. + Lo scrittore non supporta la scrittura vuota, ad esempio DataFrames per scrivere un file contenente solo uno schema. Quando si esegue l'integrazione con AWS Glue Data Catalog tramite impostazione`enableUpdateCatalog=True`, il tentativo di scrivere uno spazio vuoto non DataFrame aggiornerà il Data Catalog. Il nome di una tabella nel Catalogo dati. Se la trasformazione non richiede queste limitazioni, l'attivazione dello scrittore AWS Glue Parquet dovrebbe aumentare le prestazioni.