GlueContext classe

Encapsule l'SparkContextobjet Apache Spark et fournit ainsi des mécanismes permettant d'interagir avec la plateforme Apache Spark.

__init__

__init__(sparkContext)

• sparkContext – Contexte Apache Spark à utiliser.

Création

• __init__

• getSource

• create_dynamic_frame_from_rdd

• create_dynamic_frame_from_catalog

• create_dynamic_frame_from_options

• create_sample_dynamic_frame_from_catalog

• create_sample_dynamic_frame_from_options

• add_ingestion_time_columns

• create_data_frame_from_catalog

• create_data_frame_from_options

• forEachBatch

getSource

getSource(connection_type, transformation_ctx = "", **options)

Crée un objet DataSource qui peut être utilisé pour lire DynamicFrames à partir de sources externes.

• connection_type – type de connexion à utiliser, tel qu'Amazon Simple Storage Service (Amazon S3), Amazon Redshift et JDBC. Les valeurs valides sont les suivantes : s3, mysql, postgresql, redshift, sqlserver, oracle et dynamodb.

• transformation_ctx – Contexte de transformation à utiliser (facultatif).

• options – Ensemble de paires nom-valeur facultatives. Pour plus d'informations, consultez Types et options de connexion pour ETL dans AWS Glue pour Spark.

Voici un exemple d'utilisation de  : getSource.

>>> data_source = context.getSource("file", paths=["/in/path"])
>>> data_source.setFormat("json")
>>> myFrame = data_source.getFrame()

create_dynamic_frame_from_rdd

create_dynamic_frame_from_rdd(data, name, schema=None, sample_ratio=None, transformation_ctx="")

Renvoie un objet DynamicFrame créé à partir d'un RDD (Resilient Distributed Dataset) Apache Spark.

• data –- La source de données à utiliser.

• name – Nom des données à utiliser.

• schema – Schéma à utiliser (facultatif).

• sample_ratio – Exemple de ratio à utiliser (facultatif).

• transformation_ctx – Contexte de transformation à utiliser (facultatif).

create_dynamic_frame_from_catalog

create_dynamic_frame_from_catalog(database, table_name, redshift_tmp_dir, transformation_ctx = "", push_down_predicate= "", additional_options = {}, catalog_id = None)

Renvoie un objet DynamicFrame créé à l'aide d'un nom de table et de base de données Data Catalog. Lorsque vous utilisez cette méthode, vous fournissez des format_options propriétés de table sur la table AWS Glue Data Catalog spécifiée et d'autres options via l'additional_optionsargument.

• Database – Base de données à partir de laquelle lire.

• table_name – Nom de la table à partir de laquelle lire.

• redshift_tmp_dir – répertoire Amazon Redshift temporaire à utiliser (facultatif).

• transformation_ctx – Contexte de transformation à utiliser (facultatif).

• push_down_predicate – filtre les partitions sans avoir à répertorier ni lire tous les fichiers de votre jeu de données. Pour connaître les sources prises en charge et les limites, consultez Optimisation des lectures avec pushdown dans AWS Glue ETL. Pour plus d’informations, consultez Préfiltrage à l'aide des prédicats pushdown.

• additional_options — Ensemble de paires nom-valeur facultatives. Les options possibles comprennent celles répertoriées dans Types et options de connexion pour ETL dans AWS Glue pour Spark, sauf pour endpointUrl, streamName, bootstrap.servers, security.protocol, topicName, classification et delimiter. Est une autre option prise en charge  catalogPartitionPredicate:

  catalogPartitionPredicate – Vous pouvez passer une expression de catalogue à filtrer en fonction des colonnes d'index. Cela envoie le filtrage du côté serveur. Pour en savoir plus, consultez AWS Glue Indexes de partition. Notez que push_down_predicate et catalogPartitionPredicate utilisent des syntaxes différentes. Le premier utilise la syntaxe standard SQL Spark et le dernier utilise l'analyseur JSQL.

• catalog_id – ID du catalogue (ID du compte) Data Catalog auquel vous accédez. Lorsque la valeur est Aucun, l'ID de compte par défaut de l'appelant est utilisé.

create_dynamic_frame_from_options

create_dynamic_frame_from_options(connection_type, connection_options={}, format=None, format_options={}, transformation_ctx = "")

Renvoie un DynamicFrame créé avec la connexion et le format spécifiés.

• connection_type – type de connexion, tel qu'Amazon S3, Amazon Redshift et JDBC. Les valeurs valides sont les suivantes : s3, mysql, postgresql, redshift, sqlserver, oracle et dynamodb.

• connection_options – options de connexion, telles que les chemins et la table de base de données (facultatif). Pour un connection_type de s3, une liste de chemins Amazon S3 est définie.

  connection_options = {"paths": ["s3://aws-glue-target/temp"]}

  Pour les connexions JDBC, plusieurs propriétés doivent être définies. Notez que le nom de base de données doit être inclus dans l'URL. Il peut éventuellement être inclus dans les options de connexion.

  Avertissement

  Il n'est pas recommandé de stocker des mots de passe dans votre script. Envisagez de les utiliser boto3 pour les extraire AWS Secrets Manager du catalogue de données AWS Glue.

  connection_options = {"url": "jdbc-url/database", "user": "username", "password": passwordVariable,"dbtable": "table-name", "redshiftTmpDir": "s3-tempdir-path"} 

  La propriété dbtable est le nom de la table JDBC. Pour les magasins de données JDBC qui prennent en charge les schémas dans une base de données, spécifiez schema.table-name. Si aucun schéma n'est fourni, c'est le schéma « public » par défaut qui est utilisé.

  Pour plus d’informations, consultez Types et options de connexion pour ETL dans AWS Glue pour Spark.

• format— Une spécification de format. Utilisée pour une connexion Amazon S3 ou AWS Glue prenant en charge plusieurs formats. Consultez Options de format pour les entrées et sorties dans AWS Glue pour Spark pour connaître les formats pris en charge.

• format_options – options de format pour le format spécifié. Consultez Options de format pour les entrées et sorties dans AWS Glue pour Spark pour connaître les formats pris en charge.

• transformation_ctx – Contexte de transformation à utiliser (facultatif).

• push_down_predicate – filtre les partitions sans avoir à répertorier ni lire tous les fichiers de votre jeu de données. Pour connaître les sources prises en charge et les limites, consultez Optimisation des lectures avec pushdown dans AWS Glue ETL. Pour plus d'informations, consultez Pre-Filtering Using Pushdown Predicates.

create_sample_dynamic_frame_from_catalog

create_sample_dynamic_frame_from_catalog(database, table_name, num, redshift_tmp_dir, transformation_ctx = "", push_down_predicate= "", additional_options = {}, sample_options = {}, catalog_id = None)

Retourne un objet DynamicFrame créé à l'aide d'un nom de tableau et de base de données Data Catalog. Le DynamicFrame ne contient que les premiers enregistrements num provenant d'une source de données.

• database – Base de données à partir de laquelle lire.

• table_name – Nom de la table à partir de laquelle lire.

• num – Nombre maximal d'enregistrements dans la trame dynamique d'échantillon renvoyée.

• redshift_tmp_dir – répertoire Amazon Redshift temporaire à utiliser (facultatif).

• transformation_ctx – Contexte de transformation à utiliser (facultatif).

• push_down_predicate – filtre les partitions sans avoir à répertorier ni lire tous les fichiers de votre jeu de données. Pour plus d'informations, consultez Préfiltrage à l'aide des prédicats pushdown.

• additional_options — Ensemble de paires nom-valeur facultatives. Les options possibles comprennent celles répertoriées dans Types et options de connexion pour ETL dans AWS Glue pour Spark, sauf pour endpointUrl, streamName, bootstrap.servers, security.protocol, topicName, classification et delimiter.

• sample_options — Paramètres permettant de contrôler le comportement d'échantillonnage (facultatif). Paramètres disponibles actuels pour les sources Amazon S3 :

  • maxSamplePartitions — Nombre maximal de partitions que l'échantillonnage lira. Valeur par défaut : 10

  • maxSampleFilesPerPartition — Nombre maximal de fichiers que l'échantillonnage lira dans une partition. Valeur par défaut : 10.

    Ces paramètres permettent de réduire le temps consommé par la liste des fichiers. Par exemple, supposons que le jeu de données comporte 1 000 partitions et que chaque partition comporte 10 fichiers. Si vous définissez maxSamplePartitions = 10, et maxSampleFilesPerPartition = 10, au lieu de répertorier les 10 000 fichiers, l'échantillonnage ne listera et ne lira que les 10 premières partitions avec les 10 premiers fichiers de chacun : 10*10 = 100 au total.

• catalog_id – ID du catalogue Data Catalog auquel vous accédez (ID du compte Data Catalog). Valeur définie sur None par défaut. None correspond par défaut à l'ID de catalogue du compte ayant initié l'appel dans le service.

create_sample_dynamic_frame_from_options

create_sample_dynamic_frame_from_options(connection_type, connection_options={}, num, sample_options={}, format=None, format_options={}, transformation_ctx = "")

Renvoie un DynamicFrame créé avec la connexion et le format spécifiés. Le DynamicFrame ne contient que les premiers enregistrements num provenant d'une source de données.

• connection_type – type de connexion, tel qu'Amazon S3, Amazon Redshift et JDBC. Les valeurs valides sont les suivantes : s3, mysql, postgresql, redshift, sqlserver, oracle et dynamodb.

• connection_options – options de connexion, telles que les chemins et la table de base de données (facultatif). Pour plus d'informations, consultez Types et options de connexion pour ETL dans AWS Glue pour Spark.

• num – Nombre maximal d'enregistrements dans la trame dynamique d'échantillon renvoyée.

• sample_options — Paramètres permettant de contrôler le comportement d'échantillonnage (facultatif). Paramètres disponibles actuels pour les sources Amazon S3 :

  • maxSamplePartitions — Nombre maximal de partitions que l'échantillonnage lira. Valeur par défaut : 10

  • maxSampleFilesPerPartition — Nombre maximal de fichiers que l'échantillonnage lira dans une partition. Valeur par défaut : 10.

    Ces paramètres permettent de réduire le temps consommé par la liste des fichiers. Par exemple, supposons que le jeu de données comporte 1 000 partitions et que chaque partition comporte 10 fichiers. Si vous définissez maxSamplePartitions = 10, et maxSampleFilesPerPartition = 10, au lieu de répertorier les 10 000 fichiers, l'échantillonnage ne listera et ne lira que les 10 premières partitions avec les 10 premiers fichiers de chacun : 10*10 = 100 au total.

• format— Une spécification de format. Utilisée pour une connexion Amazon S3 ou AWS Glue prenant en charge plusieurs formats. Consultez Options de format pour les entrées et sorties dans AWS Glue pour Spark pour connaître les formats pris en charge.

• format_options – options de format pour le format spécifié. Consultez Options de format pour les entrées et sorties dans AWS Glue pour Spark pour connaître les formats pris en charge.

• transformation_ctx – Contexte de transformation à utiliser (facultatif).

• push_down_predicate – filtre les partitions sans avoir à répertorier ni lire tous les fichiers de votre jeu de données. Pour plus d'informations, consultez Préfiltrage à l'aide des prédicats pushdown.

add_ingestion_time_columns

add_ingestion_time_columns(dataFrame, timeGranularity = "")

Ajoute des colonnes de temps d'ingestion, telles que ingest_year, ingest_month, ingest_day, ingest_hour, ingest_minute à l'entrée DataFrame. Cette fonction est automatiquement générée dans le script généré par AWS Glue lorsque vous spécifiez une table Data Catalog avec Amazon S3 comme cible. Cette fonction met automatiquement à jour la partition avec les colonnes de temps d'ingestion sur la table de sortie. Cela permet aux données de sortie d'être automatiquement partitionnées à l'heure d'ingestion sans nécessiter de colonnes d'heure d'ingestion explicites dans les données d'entrée.

• dataFrame – dataFrame auquel ajouter les colonnes de temps d'ingestion.

• timeGranularity — granularité des colonnes de temps. Les valeurs valides sont « day », « hour » et « minute ». Par exemple, si « hour » est transmis à la fonction, les colonnes de temps « ingest_year », « ingest_month », « ingest_day » et « ingest_hour » seront ajoutées à l'original « dataFrame ».

Renvoie le bloc de données après l'ajout des colonnes de granularité temporelle.

Exemple :

dynamic_frame = DynamicFrame.fromDF(glueContext.add_ingestion_time_columns(dataFrame, "hour"))

create_data_frame_from_catalog

create_data_frame_from_catalog(database, table_name, transformation_ctx = "", additional_options = {})

Renvoie un objet DataFrame créé à l'aide d'un nom de table et de base de données Data Catalog.

• database – base de données Data Catalog à lire.

• table_name – nom de la table Data Catalogà partir de laquelle lire.

• transformation_ctx – Contexte de transformation à utiliser (facultatif).

• additional_options – Ensemble de paires nom-valeur facultatives. Les options possibles incluent celles répertoriées dans Types et options de connexion pour ETL dans AWS Glue pour Spark pour les sources de streaming, telles que startingPosition, maxFetchTimeInMs et startingOffsets.

  • useSparkDataSource— Lorsque ce paramètre est défini sur true, force AWS Glue à utiliser l'API native de source de données Spark pour lire le tableau. L'API Spark Data Source prend en charge les formats suivants : AVRO, binaire, CSV, JSON, ORC, Parquet et texte. Dans une table Data Catalog, vous spécifiez le format à l'aide de la propriété classification. Pour en savoir plus sur l'API Spark Data Source, consultez la documentation officielle d'Apache Spark.

    L'utilisation de create_data_frame_from_catalog avec useSparkDataSource offre les avantages suivants :

    • Renvoie directement un DataFrame et fournit une alternative à create_dynamic_frame.from_catalog().toDF().

    • Prend en charge le contrôle des autorisations AWS Lake Formation au niveau de la table pour les formats natifs.

    • Prend en charge la lecture des formats de lacs de données sans contrôle des autorisations AWS Lake Formation au niveau de la table. Pour plus d’informations, consultez Utilisation de cadres de lac de données avec des tâches AWS Glue ETL.

    Lorsque vous l'activezuseSparkDataSource, vous pouvez également ajouter l'une des options de source de données Spark additional_options selon vos besoins. AWS Glue transmet ces options directement au lecteur Spark.

  • useCatalogSchema— Lorsqu'il est défini sur true, AWS Glue applique le schéma du catalogue de données au résultatDataFrame. Sinon, le lecteur déduit le schéma à partir des données. Lorsque vous activez useCatalogSchema, vous devez également définir useSparkDataSource sur true.

Limites

Lorsque vous utilisez l'option useSparkDataSource, tenez compte des restrictions suivantes :

• Lorsque vous l'utilisezuseSparkDataSource, AWS Glue en crée une nouvelle DataFrame dans une session Spark distincte, différente de la session Spark d'origine.

• Le filtrage des DataFrame partitions Spark ne fonctionne pas avec les fonctionnalités de AWS Glue suivantes.

  • Signets de tâche

  • Exclusion des classes de stockage Amazon S3

  • Prédicats de partition de catalogue

  Pour utiliser le filtrage des partitions avec ces fonctionnalités, vous pouvez utiliser le prédicat AWS Glue pushdown. Pour plus d’informations, consultez Préfiltrage à l'aide des prédicats pushdown. Le filtrage sur les colonnes non partitionnées n'est pas concerné.

  L'exemple de script suivant illustre un filtrage de partition inadéquat à l'aide de l'option excludeStorageClasses.

  // Incorrect partition filtering using Spark filter with excludeStorageClasses
  read_df = glueContext.create_data_frame.from_catalog(
      database=database_name,
      table_name=table_name,
      additional_options = {
        "useSparkDataSource": True,
        "excludeStorageClasses" : ["GLACIER", "DEEP_ARCHIVE"]
      }
  )
  
  //  Suppose year and month are partition keys.
  //  Filtering on year and month won't work, the filtered_df will still
  //  contain data with other year/month values.
  filtered_df = read_df.filter("year == '2017 and month == '04' and 'state == 'CA'")

  L'exemple de script suivant illustre l'utilisation adéquate d'un prédicat pushdown dans le cadre d'un filtrage de partition à l'aide de l'option excludeStorageClasses.

  // Correct partition filtering using the AWS Glue pushdown predicate
  // with excludeStorageClasses
  read_df = glueContext.create_data_frame.from_catalog(
      database=database_name,
      table_name=table_name,
      //  Use AWS Glue pushdown predicate to perform partition filtering
      push_down_predicate = "(year=='2017' and month=='04')"
      additional_options = {
        "useSparkDataSource": True,
        "excludeStorageClasses" : ["GLACIER", "DEEP_ARCHIVE"]
      }
  )
  
  //  Use Spark filter only on non-partitioned columns
  filtered_df = read_df.filter("state == 'CA'")

Exemple : Création d'une table CSV à l'aide du lecteur de source de données Spark

//  Read a CSV table with '\t' as separator
read_df = glueContext.create_data_frame.from_catalog(
    database=<database_name>,
    table_name=<table_name>,
    additional_options = {"useSparkDataSource": True,  "sep": '\t'}
)

create_data_frame_from_options

create_data_frame_from_options(connection_type, connection_options={}, format=None, format_options={}, transformation_ctx = "")

Cette API est désormais obsolète. Utilisez plutôt les API getSource(). Renvoie un DataFrame créé avec la connexion et le format spécifiés. Utilisez cette fonction uniquement avec les sources de streaming AWS Glue.

• connection_type – type de connexion en streaming. Les valeurs valides sont kinesis et kafka.

• connection_options – options de connexion, qui sont différentes pour Kinesis et Kafka. Vous trouverez la liste de toutes les options de connexion pour chaque source de données de streaming sur la page Types et options de connexion pour ETL dans AWS Glue pour Spark. Notez les différences suivantes dans les options de connexion en streaming :

  • Les sources de streaming Kinesis nécessitent streamARN, startingPosition, inferSchema et classification.

  • Les sources de streaming Kafka nécessitent connectionName, topicName, startingOffsets, inferSchema et classification.

• format— Une spécification de format. Utilisée pour une connexion Amazon S3 ou AWS Glue prenant en charge plusieurs formats. Pour plus d'informations sur les formats pris en charge, consultez Options de format pour les entrées et sorties dans AWS Glue pour Spark.

• format_options – options de format pour le format spécifié. Pour de plus amples informations sur les options de formats pris en charge, veuillez consulter Options de format pour les entrées et sorties dans AWS Glue pour Spark.

• transformation_ctx – Contexte de transformation à utiliser (facultatif).

Exemple pour la source de streaming Amazon Kinesis :

kinesis_options =
   { "streamARN": "arn:aws:kinesis:us-east-2:777788889999:stream/fromOptionsStream",
     "startingPosition": "TRIM_HORIZON", 
     "inferSchema": "true", 
     "classification": "json" 
   }
data_frame_datasource0 = glueContext.create_data_frame.from_options(connection_type="kinesis", connection_options=kinesis_options)

Exemple pour la source de streaming Kafka :

kafka_options =
    { "connectionName": "ConfluentKafka", 
      "topicName": "kafka-auth-topic", 
      "startingOffsets": "earliest", 
      "inferSchema": "true", 
      "classification": "json" 
    }
data_frame_datasource0 = glueContext.create_data_frame.from_options(connection_type="kafka", connection_options=kafka_options)

forEachBatch

forEachBatch(frame, batch_function, options)

S'applique à batch_function transmis à chaque micro-lot lu à partir de la source de streaming.

• frame— Le DataFrame contenant le microlot actuel.

• batch_function — fonction qui sera appliquée à chaque micro-lot.

• options — collection de paires clé-valeur qui contient des informations sur le traitement de micro-lots. Les options suivantes sont requises :

  • windowSize — durée de traitement de chaque lot.

  • checkpointLocation — emplacement dans lequel les points de contrôle sont stockés pour la tâche ETL en streaming.

  • batchMaxRetries – nombre maximum de nouvelles tentatives pour ce lot en cas d'échec. La valeur par défaut est 3. Cette option n'est configurable que pour Glue version 2.0 et ultérieure.

Exemple :

glueContext.forEachBatch(
    frame = data_frame_datasource0,
    batch_function = processBatch, 
    options = {
        "windowSize": "100 seconds", 
        "checkpointLocation": "s3://kafka-auth-dataplane/confluent-test/output/checkpoint/"
    }
)
   
def processBatch(data_frame, batchId):
    if (data_frame.count() > 0):
        datasource0 = DynamicFrame.fromDF(
          glueContext.add_ingestion_time_columns(data_frame, "hour"), 
          glueContext, "from_data_frame"
        )
        additionalOptions_datasink1 = {"enableUpdateCatalog": True}
        additionalOptions_datasink1["partitionKeys"] = ["ingest_yr", "ingest_mo", "ingest_day"]
        datasink1 = glueContext.write_dynamic_frame.from_catalog(
          frame = datasource0, 
          database = "tempdb", 
          table_name = "kafka-auth-table-output", 
          transformation_ctx = "datasink1", 
          additional_options = additionalOptions_datasink1
        )   

Utilisation des jeux de données dans Amazon S3

• purge_table

• purge_s3_path

• transition_table

• transition_s3_path

purge_table

purge_table(catalog_id=None, database="", table_name="", options={}, transformation_ctx="")

Supprime les fichiers d'Amazon S3 pour la base de données et la table spécifiés pour le catalogue. Si tous les fichiers d'une partition sont supprimés, cette partition est également éliminée du catalogue.

Pour pouvoir récupérer des objets supprimés, vous pouvez activer la gestion des versions d'objet au niveau du compartiment Amazon S3. Lorsqu'un objet est supprimé d'un compartiment pour lequel la gestion des versions d'objet n'est pas activée, il ne peut pas être récupéré. Pour plus d'informations sur la récupération d'objets supprimés dans un compartiment pour lequel la gestion des versions est activée, consultez Comment récupérer un objet Amazon S3 qui a été supprimé ? dans le Centre de connaissances AWS Support .

• catalog_id – ID du catalogue Data Catalog auquel vous accédez (ID du compte Data Catalog). Valeur définie sur None par défaut. None correspond par défaut à l'ID de catalogue du compte ayant initié l'appel dans le service.

• database – Base de données à utiliser.

• table_name – nom de la table à utiliser.

• options – options destinées au filtrage des fichiers à supprimer et à la génération des fichiers manifestes.

  • retentionPeriod – spécifie une période de conservation des fichiers, en nombre d'heures. Les dossiers dont la date est postérieure à cette période sont conservés. Par défaut, elle est réglée sur 168 heures (7 jours).

  • partitionPredicate – les partitions satisfaisant à ce prédicat sont supprimées. Les fichiers qui se situent dans la période de conservation pour ces partitions ne sont pas supprimés. Valeur définie sur "" – vide par défaut.

  • excludeStorageClasses – les fichiers avec classe de stockage dans le jeu excludeStorageClasses ne sont pas supprimés. La valeur par défaut est Set() – jeu vide.

  • manifestFilePath – chemin facultatif pour la génération du fichier manifeste. Tous les fichiers qui ont été purgés avec succès sont enregistrés dans Success.csv, et ceux qui ont échoué dans Failed.csv

• transformation_ctx – Contexte de transformation à utiliser (facultatif). Utilisé dans le chemin du fichier manifeste.

glueContext.purge_table("database", "table", {"partitionPredicate": "(month=='march')", "retentionPeriod": 1, "excludeStorageClasses": ["STANDARD_IA"], "manifestFilePath": "s3://bucketmanifest/"})

purge_s3_path

purge_s3_path(s3_path, options={}, transformation_ctx="")

Supprime les fichiers du chemin Amazon S3 spécifié de manière récursive.

Pour pouvoir récupérer des objets supprimés, vous pouvez activer la gestion des versions d'objet au niveau du compartiment Amazon S3. Lorsqu'un objet est supprimé d'un compartiment pour lequel la gestion des versions d'objet n'est pas activée, il ne peut pas être récupéré. Pour plus d'informations sur la façon de récupérer des objets supprimés dans un compartiment avec gestion des versions, consultez Comment puis-je récupérer un objet Amazon S3 qui a été supprimé ? dans le AWS Support Knowledge Center.

• s3_path – chemin Amazon S3 des fichiers à supprimer dans le format s3://<bucket>/<prefix>/

• options – options destinées au filtrage des fichiers à supprimer et à la génération des fichiers manifestes.

  • retentionPeriod – spécifie une période de conservation des fichiers, en nombre d'heures. Les dossiers dont la date est postérieure à cette période sont conservés. Par défaut, elle est réglée sur 168 heures (7 jours).

  • excludeStorageClasses – les fichiers avec classe de stockage dans le jeu excludeStorageClasses ne sont pas supprimés. La valeur par défaut est Set() – jeu vide.

  • manifestFilePath – chemin facultatif pour la génération du fichier manifeste. Tous les fichiers qui ont été purgés avec succès sont enregistrés dans Success.csv, et ceux qui ont échoué dans Failed.csv

• transformation_ctx – Contexte de transformation à utiliser (facultatif). Utilisé dans le chemin du fichier manifeste.

glueContext.purge_s3_path("s3://bucket/path/", {"retentionPeriod": 1, "excludeStorageClasses": ["STANDARD_IA"], "manifestFilePath": "s3://bucketmanifest/"})

transition_table

transition_table(database, table_name, transition_to, options={}, transformation_ctx="", catalog_id=None)

Transition de la classe de stockage des fichiers stockés sur Amazon S3 pour la base de données et la table spécifiés pour le catalogue.

Vous pouvez effectuer une transition entre deux classes de stockage. Pour les classes de stockage GLACIER et DEEP_ARCHIVE, vous pouvez effectuer la transition vers ces classes. Cependant, vous devez utiliser S3 RESTORE pour effectuer la transition des classes de stockage GLACIER et DEEP_ARCHIVE.

Si vous exécutez des tâches ETL AWS Glue qui lisent des fichiers ou des partitions à partir d'Amazon S3, vous pouvez exclure certains types de classe de stockage Amazon S3. Pour plus d'informations, consultez Exclusion des classes de stockage Amazon S3.

• database – Base de données à utiliser.

• table_name – nom de la table à utiliser.

• transition_to – classe de stockage Amazon S3 vers laquelle effectuer la transition.

• options – options destinées au filtrage des fichiers à supprimer et à la génération des fichiers manifestes.

  • retentionPeriod – spécifie une période de conservation des fichiers, en nombre d'heures. Les dossiers dont la date est postérieure à cette période sont conservés. Par défaut, elle est réglée sur 168 heures (7 jours).

  • partitionPredicate – une transition est effectuée pour les partitions satisfaisant à ce prédicat. Aucune transition n'a lieu pour les fichiers qui se trouvent dans la période de conservation. Valeur définie sur "" – vide par défaut.

  • excludeStorageClasses – aucune transition n'a lieu pour les fichiers avec classe de stockage dans le jeu excludeStorageClasses. La valeur par défaut est Set() – jeu vide.

  • manifestFilePath – chemin facultatif pour la génération du fichier manifeste. Tous les fichiers dont la transition a été effectuée avec succès sont enregistrés dans Success.csv, et ceux qui ont échoué dans Failed.csv

  • accountId – ID de compte Amazon Web Services permettant d'exécuter la transformation de la transition. Obligatoire pour cette transformation.

  • roleArn— Le AWS rôle d'exécuter la transformation de transition. Obligatoire pour cette transformation.

• transformation_ctx – Contexte de transformation à utiliser (facultatif). Utilisé dans le chemin du fichier manifeste.

• catalog_id – ID du catalogue Data Catalog auquel vous accédez (ID du compte Data Catalog). Valeur définie sur None par défaut. None correspond par défaut à l'ID de catalogue du compte ayant initié l'appel dans le service.

glueContext.transition_table("database", "table", "STANDARD_IA", {"retentionPeriod": 1, "excludeStorageClasses": ["STANDARD_IA"], "manifestFilePath": "s3://bucketmanifest/", "accountId": "12345678901", "roleArn": "arn:aws:iam::123456789012:user/example-username"})

transition_s3_path

transition_s3_path(s3_path, transition_to, options={}, transformation_ctx="")

Transition récursive de la classe de stockage des fichiers dans le chemin Amazon S3 spécifié.

Vous pouvez effectuer une transition entre deux classes de stockage. Pour les classes de stockage GLACIER et DEEP_ARCHIVE, vous pouvez effectuer la transition vers ces classes. Cependant, vous devez utiliser S3 RESTORE pour effectuer la transition des classes de stockage GLACIER et DEEP_ARCHIVE.

Si vous exécutez des tâches ETL AWS Glue qui lisent des fichiers ou des partitions à partir d'Amazon S3, vous pouvez exclure certains types de classe de stockage Amazon S3. Pour plus d'informations, consultez Exclusion des classes de stockage Amazon S3.

• s3_path – chemin Amazon S3 des fichiers à passer au format s3://<bucket>/<prefix>/

• transition_to – classe de stockage Amazon S3 vers laquelle effectuer la transition.

• options – options destinées au filtrage des fichiers à supprimer et à la génération des fichiers manifestes.

  • retentionPeriod – spécifie une période de conservation des fichiers, en nombre d'heures. Les dossiers dont la date est postérieure à cette période sont conservés. Par défaut, elle est réglée sur 168 heures (7 jours).

  • partitionPredicate – une transition est effectuée pour les partitions satisfaisant à ce prédicat. Aucune transition n'a lieu pour les fichiers qui se trouvent dans la période de conservation. Valeur définie sur "" – vide par défaut.

  • excludeStorageClasses – aucune transition n'a lieu pour les fichiers avec classe de stockage dans le jeu excludeStorageClasses. La valeur par défaut est Set() – jeu vide.

  • manifestFilePath – chemin facultatif pour la génération du fichier manifeste. Tous les fichiers dont la transition a été effectuée avec succès sont enregistrés dans Success.csv, et ceux qui ont échoué dans Failed.csv

  • accountId – ID de compte Amazon Web Services permettant d'exécuter la transformation de la transition. Obligatoire pour cette transformation.

  • roleArn— Le AWS rôle d'exécuter la transformation de transition. Obligatoire pour cette transformation.

• transformation_ctx – Contexte de transformation à utiliser (facultatif). Utilisé dans le chemin du fichier manifeste.

glueContext.transition_s3_path("s3://bucket/prefix/", "STANDARD_IA", {"retentionPeriod": 1, "excludeStorageClasses": ["STANDARD_IA"], "manifestFilePath": "s3://bucketmanifest/", "accountId": "12345678901", "roleArn": "arn:aws:iam::123456789012:user/example-username"})

Extraction

• extract_jdbc_conf

extract_jdbc_conf

extract_jdbc_conf(connection_name, catalog_id = None)

Retourne un dict dont les clés contiennent les propriétés de configuration de l'objet de connexion AWS Glue dans le catalogue de données.

• user – Nom d'utilisateur de la base de données.

• password – Le mot de passe de la base de données.

• vendor – Spécifie un fournisseur (mysql, postgresql, oracle, sqlserver, etc.).

• enforceSSL – Chaîne booléenne indiquant si une connexion sécurisée est requise.

• customJDBCCert – Utilise un certificat client spécifique à partir du chemin Amazon S3 indiqué.

• skipCustomJDBCCertValidation – Chaîne booléenne indiquant si le customJDBCCert doit être validé par une autorité de certification.

• customJDBCCertString – Informations supplémentaires sur le certificat personnalisé, spécifique au type de pilote.

• url – (Obsolète) URL JDBC avec uniquement le protocole, le serveur et le port.

• fullUrl – URL JDBC telle qu'elle a été saisie lors de la création de la connexion (disponible dans la version AWS Glue 3.0 ou ultérieure).

Exemple de récupération de configurations JDBC :

jdbc_conf = glueContext.extract_jdbc_conf(connection_name="your_glue_connection_name")
print(jdbc_conf)
>>> {'enforceSSL': 'false', 'skipCustomJDBCCertValidation': 'false', 'url': 'jdbc:mysql://myserver:3306', 'fullUrl': 'jdbc:mysql://myserver:3306/mydb', 'customJDBCCertString': '', 'user': 'admin', 'customJDBCCert': '', 'password': '1234', 'vendor': 'mysql'}

Transactions

• start_transaction

• commit_transaction

• cancel_transaction

start_transaction

start_transaction(read_only)

Démarrez une nouvelle transaction. Appelle en interne l'API Démarrer la transaction Lake Formation.

• read_only – Valeur booléenne indiquant si cette transaction doit être en lecture seule ou en lecture et en écriture. Les écritures effectuées à l'aide d'un ID de transaction en lecture seule seront rejetées. Les transactions en lecture seule n'ont pas besoin d'être validées.

Retourne l'ID de transaction.

commit_transaction

commit_transaction(transaction_id, wait_for_commit = True)

Tentative de validation de la transaction spécifiée.commit_transaction peut être renvoyé avant la fin de la validation de la transaction. Appelle en interne la Lake Formation commitTransaction API.

• transaction_id – (Chaîne) La transaction à valider.

• wait_for_commit – (Booléen) Détermine si le commit_transaction retourne immédiatement. La valeur par défaut est True. Si elle est false,commit_transaction interroge et attend que la transaction soit validée. Le temps d'attente est limité à 1 minute en utilisant le backoff exponentiel avec un maximum de 6 tentatives de nouvelle tentative.

Renvoie une valeur de type Boolean pour indiquer si la validation est effectuée ou non.

cancel_transaction

cancel_transaction(transaction_id)

Tentative d'annulation de la transaction spécifiée. Retourne une exception TransactionCommittedException si la transaction a déjà été validée. Appelle en interne l'CancelTransactionAPI Lake Formation.

• transaction_id – (Chaîne) La transaction à annuler.

Ecriture

• getSink

• write_dynamic_frame_from_options

• write_from_options

• write_dynamic_frame_from_catalog

• write_data_frame_from_catalog

• write_dynamic_frame_from_jdbc_conf

• write_from_jdbc_conf

getSink

getSink(connection_type, format = None, transformation_ctx = "", **options)

Obtient un objet DataSink qui peut être utilisé pour écrire DynamicFrames sur des sources externes. Vérifiez d'abord le format SparkSQL pour être sûr d'obtenir le récepteur escompté.

• connection_type – type de connexion à utiliser, telle qu'Amazon S3, Amazon Redshift et JDBC. Les valeurs valides incluent s3mysql, postgresqlredshift,sqlserver,oracle,kinesis, etkafka.

• format – Format SparkSQL à utiliser (facultatif).

• transformation_ctx – Contexte de transformation à utiliser (facultatif).

• options –Ensemble de paires nom-valeur utilisées pour spécifier les options de connexion. Certaines des valeurs possibles sont les suivantes :

  • user et password : Pour autorisation

  • url : Point de terminaison du magasin de données

  • dbtable :Nom de la table cible

  • bulkSize: Degré de parallélisme pour les opérations d'insertion

Les options que vous pouvez spécifier dépendent du type de connexion. Pour obtenir d'autres conseils et d'autres exemples, veuillez consulter Types et options de connexion pour ETL dans AWS Glue pour Spark.

Exemple :

>>> data_sink = context.getSink("s3")
>>> data_sink.setFormat("json"),
>>> data_sink.writeFrame(myFrame)

write_dynamic_frame_from_options

write_dynamic_frame_from_options(frame, connection_type, connection_options={}, format=None, format_options={}, transformation_ctx = "")

Écrit et retourne un DynamicFrame à l'aide de la connexion et du format spécifiés.

• frame – Objet DynamicFrame à écrire.

• connection_type – type de connexion, tel qu'Amazon S3, Amazon Redshift et JDBC. Les valeurs valides incluent s3mysql, postgresqlredshift,sqlserver,oracle,kinesis, etkafka.

• connection_options – Options de connexion, telles que le chemin et la table de base de données (facultatif). Pour un connection_type de s3, un chemin Amazon S3 est défini.

  connection_options = {"path": "s3://aws-glue-target/temp"}

  Pour les connexions JDBC, plusieurs propriétés doivent être définies. Notez que le nom de base de données doit être inclus dans l'URL. Il peut éventuellement être inclus dans les options de connexion.

  Avertissement

  Il n'est pas recommandé de stocker des mots de passe dans votre script. Envisagez de les utiliser boto3 pour les extraire AWS Secrets Manager du catalogue de données AWS Glue.

  connection_options = {"url": "jdbc-url/database", "user": "username", "password": passwordVariable,"dbtable": "table-name", "redshiftTmpDir": "s3-tempdir-path"} 

  La propriété dbtable est le nom de la table JDBC. Pour les magasins de données JDBC qui prennent en charge les schémas dans une base de données, spécifiez schema.table-name. Si aucun schéma n'est fourni, c'est le schéma « public » par défaut qui est utilisé.

  Pour plus d’informations, consultez Types et options de connexion pour ETL dans AWS Glue pour Spark.

• format— Une spécification de format. Utilisée pour une connexion Amazon S3 ou AWS Glue prenant en charge plusieurs formats. Consultez Options de format pour les entrées et sorties dans AWS Glue pour Spark pour connaître les formats pris en charge.

• format_options – options de format pour le format spécifié. Consultez Options de format pour les entrées et sorties dans AWS Glue pour Spark pour connaître les formats pris en charge.

• transformation_ctx – Contexte de transformation à utiliser (facultatif).

write_from_options

write_from_options(frame_or_dfc, connection_type, connection_options={}, format={}, format_options={}, transformation_ctx = "")

Écrit et renvoie un DynamicFrame ou DynamicFrameCollection qui est créé avec la connexion et les informations de format spécifiées.

• frame_or_dfc – Objet DynamicFrame ou DynamicFrameCollection à écrire.

• connection_type – type de connexion, tel qu'Amazon S3, Amazon Redshift et JDBC. Les valeurs valides sont s3, mysql, postgresql, redshift, sqlserver et oracle.

• connection_options – Options de connexion, telles que le chemin et la table de base de données (facultatif). Pour un connection_type de s3, un chemin Amazon S3 est défini.

  connection_options = {"path": "s3://aws-glue-target/temp"}

  Pour les connexions JDBC, plusieurs propriétés doivent être définies. Notez que le nom de base de données doit être inclus dans l'URL. Il peut éventuellement être inclus dans les options de connexion.

  Avertissement

  Il n'est pas recommandé de stocker des mots de passe dans votre script. Envisagez de les utiliser boto3 pour les extraire AWS Secrets Manager du catalogue de données AWS Glue.

  connection_options = {"url": "jdbc-url/database", "user": "username", "password": passwordVariable,"dbtable": "table-name", "redshiftTmpDir": "s3-tempdir-path"} 

  La propriété dbtable est le nom de la table JDBC. Pour les magasins de données JDBC qui prennent en charge les schémas dans une base de données, spécifiez schema.table-name. Si aucun schéma n'est fourni, c'est le schéma « public » par défaut qui est utilisé.

  Pour plus d’informations, consultez Types et options de connexion pour ETL dans AWS Glue pour Spark.

• format— Une spécification de format. Utilisée pour une connexion Amazon S3 ou AWS Glue prenant en charge plusieurs formats. Consultez Options de format pour les entrées et sorties dans AWS Glue pour Spark pour connaître les formats pris en charge.

• format_options – options de format pour le format spécifié. Consultez Options de format pour les entrées et sorties dans AWS Glue pour Spark pour connaître les formats pris en charge.

• transformation_ctx – Contexte de transformation à utiliser (facultatif).

write_dynamic_frame_from_catalog

write_dynamic_frame_from_catalog(frame, database, table_name, redshift_tmp_dir, transformation_ctx = "", additional_options = {}, catalog_id = None)

Écrit et renvoie un objet DynamicFrame utilisant des informations provenant d'une table et d'une base de données Data Catalog.

• frame – Objet DynamicFrame à écrire.

• Database – base de données Data Catalog contenant la table.

• table_name – nom de la table Data Catalog associée à la cible.

• redshift_tmp_dir – répertoire Amazon Redshift temporaire à utiliser (facultatif).

• transformation_ctx – Contexte de transformation à utiliser (facultatif).

• additional_options – Ensemble de paires nom-valeur facultatives.

• catalog_id – ID du catalogue (ID du compte) Data Catalog auquel vous accédez. Lorsque la valeur est Aucun, l'ID de compte par défaut de l'appelant est utilisé.

write_data_frame_from_catalog

write_data_frame_from_catalog(frame, database, table_name, redshift_tmp_dir, transformation_ctx = "", additional_options = {}, catalog_id = None)

Écrit et renvoie un objet DataFrame utilisant des informations provenant d'une table et d'une base de données Data Catalog. Cette méthode prend en charge l'écriture dans les formats de lac de données (Hudi, Iceberg et Delta Lake). Pour plus d'informations, consultez Utilisation de cadres de lac de données avec des tâches AWS Glue ETL.

• frame – Objet DataFrame à écrire.

• Database – base de données Data Catalog contenant la table.

• table_name – nom de la table Data Catalog qui est associée à la cible.

• redshift_tmp_dir – répertoire Amazon Redshift temporaire à utiliser (facultatif).

• transformation_ctx – Contexte de transformation à utiliser (facultatif).

• additional_options – Ensemble de paires nom-valeur facultatives.

  • useSparkDataSink— Lorsque ce paramètre est défini sur true, force AWS Glue à utiliser l'API native de Spark Data Sink pour écrire dans la table. Lorsque vous activez cette option, vous pouvez ajouter toutes les options de source de données Spark selon additional_options vos besoins. AWS Glue transmet ces options directement au Spark Writer.

• catalog_id – ID de catalogue (ID de compte) du catalogue de données auquel vous accédez. Si vous ne spécifiez aucune valeur, l'ID de compte par défaut de l'appelant est utilisé.

Limites

Lorsque vous utilisez l'option useSparkDataSink, tenez compte des restrictions suivantes :

• L'option enableUpdateCatalog n'est pas prise en charge lorsque vous utilisez l'option useSparkDataSink.

Exemple : Écriture dans une table Hudi à l'aide de l'enregistreur de source de données Spark

hudi_options = {
    'useSparkDataSink': True,
    'hoodie.table.name': <table_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,
    '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'}

glueContext.write_data_frame.from_catalog(
    frame = <df_product_inserts>,
    database = <database_name>,
    table_name = <table_name>,
    additional_options = hudi_options
)

write_dynamic_frame_from_jdbc_conf

write_dynamic_frame_from_jdbc_conf(frame, catalog_connection, connection_options={}, redshift_tmp_dir = "", transformation_ctx = "", catalog_id = None)

Écrit et retourne un DynamicFrame à l'aide des informations de connexion JDBC spécifiées.

• frame – Objet DynamicFrame à écrire.

• catalog_connection – Connexion de catalogue à utiliser.

• connection_options – Options de connexion, telles que le chemin et la table de base de données (facultatif). Pour plus d'informations, consultez Types et options de connexion pour ETL dans AWS Glue pour Spark.

• redshift_tmp_dir – répertoire Amazon Redshift temporaire à utiliser (facultatif).

• transformation_ctx – Contexte de transformation à utiliser (facultatif).

• catalog_id – ID du catalogue (ID du compte) Data Catalog auquel vous accédez. Lorsque la valeur est Aucun, l'ID de compte par défaut de l'appelant est utilisé.

write_from_jdbc_conf

write_from_jdbc_conf(frame_or_dfc, catalog_connection, connection_options={}, redshift_tmp_dir = "", transformation_ctx = "", catalog_id = None)

Écrit et retourne un objet DynamicFrame ou DynamicFrameCollection à l'aide des informations de connexion JDBC spécifiées.

• frame_or_dfc – Objet DynamicFrame ou DynamicFrameCollection à écrire.

• catalog_connection – Connexion de catalogue à utiliser.

• connection_options – Options de connexion, telles que le chemin et la table de base de données (facultatif). Pour plus d'informations, consultez Types et options de connexion pour ETL dans AWS Glue pour Spark.

• redshift_tmp_dir – répertoire Amazon Redshift temporaire à utiliser (facultatif).

• transformation_ctx – Contexte de transformation à utiliser (facultatif).

• catalog_id – ID du catalogue (ID du compte) Data Catalog auquel vous accédez. Lorsque la valeur est Aucun, l'ID de compte par défaut de l'appelant est utilisé.