Utilizzo del formato Parquet in AWS Glue

AWS Glue recupera i dati dalle origini e scrive i dati sulle destinazioni archiviati e trasportati in vari formati di dati. Se i tuoi dati sono archiviati o trasportati nel formato di dati Parquet, questo documento descrive le funzionalità disponibili per l'utilizzo dei tuoi dati in AWS Glue.

AWS Glue supporta l'uso 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.

Puoi utilizzare AWS Glue per leggere i Parquet da Amazon S3 e da fonti di streaming e scrivere i 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 invece che nella configurazione discussa in questa pagina.

La tabella seguente mostra quali funzionalità comuni di AWS Glue supportano l'opzione del formato Parquet.

Lettura	Scrittura	Lettura in streaming	Gruppo di file piccoli	Segnalibri di processo
Supportato	Supportato	Supportato	Non supportato.	Supportato*

^* Supportato in AWS Glue versione 1.0 e successive

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 maggiori dettagli, consulta Tipi di connessione e opzioni per ETL in AWS Glue: Parametri di connessione di 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.

Il seguente script ETL di AWS Glue mostra il processo di lettura di file o cartelle Parquet da S3:

Python

Per questo esempio, utilizza il metodo 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 utilizzare DataFrames anche in uno script (pyspark.sql.DataFrame).

dataFrame = spark.read.parquet("s3://s3path/")
                    

Scala

Per questo esempio, utilizza il metodo 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()
  }
}

Puoi utilizzare DataFrames anche in uno script (org.apache.spark.sql.DataFrame).

spark.read.parquet("s3://s3path/")

Esempio: scrittura di file e cartelle Parquet su S3

Prerequisiti: avrai bisogno di un DataFrame inizializzato (dataFrame) o di un DynamicFrame (dynamicFrame). Avrai bisogno anche del tuo percorso di output S3 previsto, s3path.

Configurazione: nelle opzioni della funzione, specifica format="parquet". In connection_options, utilizza la chiave paths per specificare s3path.

Puoi modificare ulteriormente il modo in cui il writer interagisce con S3 nelle connection_options. Per maggiori dettagli, consulta Tipi di connessione e opzioni per ETL in AWS Glue: Parametri di connessione di 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.

Il seguente script ETL di AWS Glue mostra il processo di scrittura di file o cartelle Parquet da S3.

Forniamo un writer Parquet personalizzato con ottimizzazioni delle prestazioni per DynamicFrame, tramite la chiave di configurazione useGlueParquetWriter. Per determinare se questo writer è adatto al tuo carico di lavoro, consulta Scrittore Glue Parquet.

Python

Per questo esempio, utilizza il metodo 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 utilizzare DataFrames anche in uno script (pyspark.sql.DataFrame).

df.write.parquet("s3://s3path/")

Scala

Per questo esempio, utilizza l'operazione 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)
  }
}

Puoi utilizzare DataFrames anche in uno script (org.apache.spark.sql.DataFrame).

df.write.parquet("s3://s3path/")

Riferimento alla configurazione Parquet

Puoi utilizzare le seguenti format_options ovunque le librerie di AWS Glue specifichino format="parquet":

• useGlueParquetWriter: specifica l'utilizzo di un writer Parquet personalizzato con ottimizzazioni delle prestazioni per i flussi di lavoro di DynamicFrame. Per informazioni dettagliate sull'utilizzo, consulta Writer Glue Parquet.

  • 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 per il reader Spark di AWS Glue per unire lo schema di tutti i file.

Ottimizzazione delle prestazioni di scrittura con il writer Parquet di AWS Glue

Nota

Il writer Parquet di AWS Glue è stato storicamente accessibile tramite il tipo di formato glueparquet. Questo schema di accesso non è più raccomandato. Utilizza invece il tipo parquet con useGlueParquetWriter abilitato.

Il writer Parquet di AWS Glue offre miglioramenti delle prestazioni che consentono scritture di file Parquet più veloci. 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 il writer Parquet di AWS Glue non è richiesto uno schema pre-calcolato. 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.

• Il writer non è in grado di memorizzare un DataFrame vuoto, ad esempio per scrivere un file solo su schema. Durante l'integrazione con Catalogo dati AWS Glue tramite l'impostazione enableUpdateCatalog=True, il tentativo di scrivere un DataFrame vuoto non aggiornerà il Catalogo dati. Il nome di una tabella nel Catalogo dati.

Se la trasformazione non richiede queste limitazioni, l'attivazione del writer Parquet di AWS Glue dovrebbe aumentare le prestazioni.