Utilisation du format Parquet dans AWS Glue

AWS Glue récupère les données des sources et écrit les données sur des cibles stockées et transportées dans différents formats de données. Si vos données sont stockées ou transportées au format de données Parquet, ce document présente les fonctionnalités disponibles pour l'utilisation de vos données dans AWS Glue.

AWS Glue prend en charge l'utilisation du format Parquet. Ce format est un format de données en colonnes, orienté vers la performance. Pour accéder à une présentation du format par l'autorité standard, consultez Apache Parquet Documentation Overview (Présentation de la documentation Apache Parquet).

Vous pouvez utiliser AWS Glue pour lire des fichiers Parquet depuis Amazon S3 et depuis des sources de streaming, ainsi que pour écrire des fichiers Parquet sur Amazon S3. Vous pouvez lire et écrire des archives bzip et gzip contenant des fichiers Parquet provenant de S3. Vous configurez le comportement de compression sur Paramètres de connexion S3 plutôt que dans la configuration décrite sur cette page.

Le tableau suivant indique les fonctionnalités courantes de AWS Glue qui prennent en charge l'option de format Parquet.

Lire	Écrire	Lecture en streaming	Groupement des petits fichiers	Signets de tâche
Pris en charge	Pris en charge	Pris en charge	Non pris en charge	Pris en charge*

^* Pris en charge dans AWS Glue version 1.0+

Exemple : lecture de fichiers ou dossiers Parquet depuis S3

Prérequis : vous aurez besoin des chemins S3 (s3path) vers des fichiers ou dossiers Parquet que vous souhaitez lire.

Configuration : dans vos options de fonction, spécifiez format="parquet". Dans vos connection_options, utilisez la clé paths pour spécifier votre s3path.

Vous pouvez configurer la manière dont le lecteur interagit avec S3 dans les connection_options. Pour plus d'informations, consultez les Types et options de connexion pour ETL dans AWS Glue : Paramètres de connexion S3.

Vous pouvez configurer la manière dont le lecteur interprète les fichiers Parquet dans votre format_options. Pour plus d'informations, consultez Parquet Configuration Reference (Référence de configuration Parquet).

Le script ETL AWS Glue suivant montre le processus de lecture de fichiers ou dossiers Parquet à partir de S3 :

Python

Pour cet exemple, utilisez la méthode 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"
)

Vous pouvez également utiliser DataFrames dans un script (pyspark.sql.DataFrame).

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

Scala

Pour cet exemple, utilisez la méthode 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()
  }
}

Vous pouvez également utiliser DataFrames dans un script (org.apache.spark.sql.DataFrame).

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

Exemple : écriture de fichiers et dossiers Parquet dans S3

Prérequis : vous aurez besoin d'un DataFrame (dataFrame) ou un d'un DynamicFrame (dynamicFrame) lancé. Vous aurez également besoin de votre chemin de sortie S3, s3path.

Configuration : dans vos options de fonction, spécifiez format="parquet". Dans vos connection_options, utilisez la clé paths pour spécifier s3path.

Vous pouvez modifier davantage la manière dont le scripteur interagit avec S3 dans les connection_options. Pour plus d'informations, consultez les Types et options de connexion pour ETL dans AWS Glue : Paramètres de connexion S3. Vous pouvez configurer la manière dont votre opération écrit le contenu de vos fichiers dans format_options. Pour plus d'informations, consultez Parquet Configuration Reference (Référence de configuration Parquet).

Le script ETL AWS Glue suivant montre le processus d'écriture de fichiers et dossiers Parquet vers S3.

Nous fournissons un scripteur de fichier Parquet personnalisé avec des optimisations de performance pour DynamicFrames, à travers la clé de configuration useGlueParquetWriter. Pour déterminer si ce scripteur est adapté à votre charge de travail, consultez Glue Parquet Writer (Scripteur Parquet Glue).

Python

Pour cet exemple, utilisez la méthode 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,
    },
)

Vous pouvez également utiliser DataFrames dans un script (pyspark.sql.DataFrame).

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

Scala

Pour cet exemple, utilisez la méthode 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)
  }
}

Vous pouvez également utiliser DataFrames dans un script (org.apache.spark.sql.DataFrame).

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

Référence de configuration Parquet

Vous pouvez utiliser les format_options suivantes partout où les bibliothèques AWS Glue spécifient format="parquet" :

• useGlueParquetWriter – spécifie l'utilisation d'un scripteur Parquet personnalisé dont les performances sont optimisées pour les flux de travail DynamicFrame. Pour plus d'informations, consultez Glue Parquet Writer (Scripteur Parquet Glue).

  • Type : Booléen, Valeur par défaut :false

• compression – spécifie le codec de compression utilisé. Les valeurs sont entièrement compatibles avec org.apache.parquet.hadoop.metadata.CompressionCodecName.

  • Type : Texte énuméré, Valeur par défaut : "snappy"

  • Valeurs : "uncompressed", "snappy", "gzip", et "lzo"

• blockSize – spécifie la taille en octets d'un groupe de lignes mis en mémoire. Vous l'utilisez pour régler les performances. La taille doit être divisée exactement en un certain nombre de mégaoctets.

  • Type : Numérique, Valeur par défaut :134217728

  • La valeur par défaut est égale à 128 Mo.

• pageSize – spécifie la taille d'une page en octets. Vous l'utilisez pour régler les performances. Une page est la plus petite unité qui doit être lue entièrement pour accéder à un enregistrement unique.

  • Type : Numérique, Valeur par défaut :1048576

  • La valeur par défaut est égale à 1 Mo.

Note

De plus, toutes les options acceptées par le code SparkSQL sous-jacent peuvent être transmises à ce format via le paramètre map connection_options. Par exemple, vous pouvez définir une configuration Spark telle que mergeSchema pour le dispositif d'écriture AWS Glue Spark pour fusionner le schéma de tous les fichiers.

Optimiser les performances d'écriture avec le scripteur AWS Glue Parquet

Note

Le scripteur AWS Glue Parquet est historiquement accessible à travers le type de format glueparquet. Ce modèle d'accès n'est plus préconisé. Utilisez plutôt le type parquet avec useGlueParquetWriter activé.

Le scripteur AWS Glue Parquet présente des améliorations de performances qui permettent une écriture plus rapide des fichiers Parquet. Le scripteur traditionnel calcule un schéma avant d'écrire. Le format Parquet ne stocke pas le schéma de manière rapidement récupérable, ce qui peut prendre un certain temps. Avec le scripteur AWS Glue Parquet, un schéma pré-calculé n'est pas nécessaire. Au fur et à mesure que les données sont introduites, le scripteur calcule et modifie le schéma de manière dynamique.

Notez les limitations suivantes lorsque vous spécifiez useGlueParquetWriter :

• Le dispositif d'écriture prend uniquement en charge l'évolution du schéma, comme l'ajout ou la suppression de colonnes, mais pas la modification des types de colonnes, par exemple avec ResolveChoice.

• Le dispositif d’écriture ne prend pas en charge l’écriture de DataFrames vides ; par exemple, l’écriture d’un fichier schema-only. Lors de l’intégration au catalogue de données AWS Glue via un paramètre enableUpdateCatalog=True, toute tentative d’écriture d’un DataFrame vide ne mettra pas à jour le catalogue de données. Cela entraînera la création d’une table sans schéma dans le catalogue de données.

Si votre transformation ne nécessite pas ces limitations, l'activation du dispositif d'écriture AWS Glue Parquet devrait augmenter les performances.