Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Fonctionnalités et optimisations de la programmation des scripts ETL AWS Glue pour Spark
Les sections suivantes décrivent les techniques et les valeurs qui s'appliquent généralement à la programmation ETL (extraction, transformation et chargement) AWS Glue pour Spark quel que soit le langage.
**Topics**
+ [
# Types et options de connexion pour ETL dans AWS Glue pour Spark
](aws-glue-programming-etl-connect.md)
+ [
# Options de format pour les entrées et sorties dans AWS Glue pour Spark
](aws-glue-programming-etl-format.md)
+ [
# AWS Support de Glue Data Catalog pour les tâches Spark SQL
](aws-glue-programming-etl-glue-data-catalog-hive.md)
+ [
# Utilisation des marque-pages de tâche
](programming-etl-connect-bookmarks.md)
+ [
# Utilisation de la détection des données sensibles en dehors de AWS Glue Studio
](aws-glue-api-sensitive-data-example.md)
+ [
# API Visual Job AWS Glue
](visual-job-api-chapter.md)
# Types et options de connexion pour ETL dans AWS Glue pour Spark
Dans AWS Glue Spark, diverses méthodes PySpark et transformations Scala spécifient le type de connexion à l'aide d'un `connectionType` paramètre. Ils spécifient des options de connexion à l'aide d'un paramètre `connectionOptions` ou `options`.
Le paramètre `connectionType` peut prendre les valeurs indiquées dans le tableau suivant. Les valeurs de paramètre associées `connectionOptions` (ou `options`) pour chaque type sont documentées dans les sections suivantes. Sauf indication contraire, les paramètres s'appliquent lorsque la connexion est utilisée comme source ou comme collecteur.
Pour obtenir un exemple de code qui illustre le paramétrage et l’utilisation des options de connexion, consultez la page d’accueil de chaque type de connexion.
| `connectionType` | Se connecte à |
| --- | --- |
| [dynamodb](aws-glue-programming-etl-connect-dynamodb-home.md) | Base de données [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/) |
| [kinesis](aws-glue-programming-etl-connect-kinesis-home.md) | [Amazon Kinesis Data Streams](https://docs.aws.amazon.com/streams/latest/dev/introduction.html) |
| [s3](aws-glue-programming-etl-connect-s3-home.md) | [Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/) |
| [documentdb](aws-glue-programming-etl-connect-documentdb-home.md#aws-glue-programming-etl-connect-documentdb) | Base de données [Amazon DocumentDB (compatible avec MongoDB)](https://docs.aws.amazon.com/documentdb/latest/developerguide/) |
| [openSearch](aws-glue-programming-etl-connect-opensearch-home.md) | [Amazon OpenSearch Service](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/). |
| [redshift](aws-glue-programming-etl-connect-redshift-home.md) | Base de données [Amazon Redshift](https://aws.amazon.com/redshift/) |
| [kafka](aws-glue-programming-etl-connect-kafka-home.md) | [Kafka](https://kafka.apache.org/) ou [Amazon Managed Streaming for Apache Kafka](https://docs.aws.amazon.com/msk/latest/developerguide/what-is-msk.html) |
| [azurecosmos](aws-glue-programming-etl-connect-azurecosmos-home.md) | Azure Cosmos pour NoSQL. |
| [azuresql](aws-glue-programming-etl-connect-azuresql-home.md) | Azure SQL. |
| [bigquery](aws-glue-programming-etl-connect-bigquery-home.md) | Google BigQuery. |
| [mongodb](aws-glue-programming-etl-connect-mongodb-home.md) | Base de données [MongoDB](https://www.mongodb.com/what-is-mongodb), y compris MongoDB Atlas. |
| [sqlserver](aws-glue-programming-etl-connect-jdbc-home.md) | Base de données Microsoft SQL Server (consultez [Connexions JDBC](aws-glue-programming-etl-connect-jdbc-home.md)) |
| [mysql](aws-glue-programming-etl-connect-jdbc-home.md) | Base de données [MySQL](https://www.mysql.com/) (consultez [Connexions JDBC](aws-glue-programming-etl-connect-jdbc-home.md)) |
| [oracle](aws-glue-programming-etl-connect-jdbc-home.md) | Base de données [Oracle](https://www.oracle.com/database/) (consultez [Connexions JDBC](aws-glue-programming-etl-connect-jdbc-home.md)) |
| [postgresql](aws-glue-programming-etl-connect-jdbc-home.md) | Base de données [PostgreSQL](https://www.postgresql.org/) (consultez [Connexions JDBC](aws-glue-programming-etl-connect-jdbc-home.md)) |
| [saphana](aws-glue-programming-etl-connect-saphana-home.md) | SAP HANA. |
| [snowflake](aws-glue-programming-etl-connect-snowflake-home.md) | Lac de données [Snowflake](https://www.snowflake.com/) |
| [teradata](aws-glue-programming-etl-connect-teradata-home.md) | Teradata Vantage. |
| [vertica](aws-glue-programming-etl-connect-vertica-home.md) | Vertica. |
| [personnalisé.\$1](#aws-glue-programming-etl-connect-market) | Magasins de données Spark, Athena ou JDBC (voir [Valeurs personnalisées et AWS Marketplace ConnectionType](#aws-glue-programming-etl-connect-market) |
| [marketplace.\$1](#aws-glue-programming-etl-connect-market) | Magasins de données Spark, Athena ou JDBC (voir [Valeurs personnalisées et AWS Marketplace ConnectionType](#aws-glue-programming-etl-connect-market)) |
# Connexions DynamoDB
Vous pouvez utiliser AWS Glue for Spark pour lire et écrire dans des tables de DynamoDB dans Glue. AWS Vous vous connectez à DynamoDB à l'aide des autorisations IAM associées à votre tâche Glue. AWS AWS Glueprend en charge l'écriture de données dans la table DynamoDB d'un autre AWS compte. Pour de plus amples informations, veuillez consulter [Accès entre régions et entre comptes aux tables DynamoDB](aws-glue-programming-etl-dynamo-db-cross-account.md).
Le connecteur DynamoDB d'origine utilise des objets DynamicFrame Glue pour travailler avec les données extraites de DynamoDB. AWS Glue 5.0\$1 introduit une nouveauté [Connecteur DynamoDB avec prise en charge de Spark DataFrame](aws-glue-programming-etl-connect-dynamodb-dataframe-support.md) qui fournit le support natif de Spark DataFrame .
[Outre le connecteur AWS Glue DynamoDB ETL, vous pouvez lire depuis DynamoDB à l'aide du connecteur d'exportation DynamoDB, qui appelle une demande DynamoDB et la stocke dans un emplacement Amazon `ExportTableToPointInTime` S3 que vous fournissez, au format DynamoDB JSON.](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataExport.Output.html) AWS Gluecrée ensuite un DynamicFrame objet en lisant les données depuis le site d'exportation Amazon S3.
Le dispositif d’écriture DynamoDB est disponible dans la version 1.0 ou les versions ultérieures de AWS Glue. Le dispositif de connecteur d’exportation DynamoDB AWS Glue est disponible dans la version 2.0 ou les versions ultérieures d’AWS Glue. Le nouveau connecteur DataFrame DynamoDB est disponible dans la version 5.0 ou les versions ultérieures de AWS Glue.
Pour plus d’informations sur DynamoDB, consultez la [documentation Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/).
**Note**
Le lecteur ETL DynamoDB ne prend pas en charge les filtres ou les prédicats pushdown.
## Configuration de connexions DynamoDB
Pour vous connecter à DynamoDB AWS depuis Glue, accordez au rôle IAM associé à AWS votre tâche Glue l'autorisation d'interagir avec DynamoDB. Pour plus d’informations sur les autorisations requises pour lire ou écrire à partir de DynamoDB, consultez [Actions, ressources et clés de condition pour DynamoDB](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazondynamodb.html) dans la documentation IAM.
Dans les situations suivantes, vous autre peut-être besoin d’une configuration supplémentaire :
+ Lorsque vous utilisez le connecteur d’exportation DynamoDB, vous devez configurer IAM pour que votre tâche puisse demander des exportations de tables DynamoDB. En outre, vous devrez identifier un compartiment Amazon S3 pour l'exportation et fournir les autorisations appropriées dans IAM pour que DynamoDB puisse y écrire, et pour que votre tâche AWS Glue puisse y lire. Pour plus d’informations, consultez [Demande d’exportation de table dans DynamoDB](https://docs.aws.amazon.com//amazondynamodb/latest/developerguide/S3DataExport_Requesting.html).
+ Si votre tâche AWS Glue comporte des exigences de connectivité Amazon VPC spécifiques, utilisez le type de connexion `NETWORK` AWS Glue pour fournir des options réseau. L'accès à DynamoDB étant autorisé par IAM, il n'est pas nécessaire de recourir à un type de connexion AWS Glue DynamoDB.
## Lecture et écriture dans DynamoDB
Les exemples de code suivants montrent comment lire et écrire des tables DynamoDB. Ils montrent la lecture d'une table et l'écriture dans une autre table.
------
#### [ Python ]
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions
args = getResolvedOptions(sys.argv, ["JOB_NAME"])
glue_context= GlueContext(SparkContext.getOrCreate())
job = Job(glue_context)
job.init(args["JOB_NAME"], args)
dyf = glue_context.create_dynamic_frame.from_options(
connection_type="dynamodb",
connection_options={"dynamodb.input.tableName": test_source,
"dynamodb.throughput.read.percent": "1.0",
"dynamodb.splits": "100"
}
)
print(dyf.getNumPartitions())
glue_context.write_dynamic_frame_from_options(
frame=dyf,
connection_type="dynamodb",
connection_options={"dynamodb.output.tableName": test_sink,
"dynamodb.throughput.write.percent": "1.0"
}
)
job.commit()
```
------
#### [ Scala ]
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.DynamoDbDataSink
import org.apache.spark.SparkContext
import scala.collection.JavaConverters._
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val glueContext = new GlueContext(SparkContext.getOrCreate())
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
val dynamicFrame = glueContext.getSourceWithFormat(
connectionType = "dynamodb",
options = JsonOptions(Map(
"dynamodb.input.tableName" -> test_source,
"dynamodb.throughput.read.percent" -> "1.0",
"dynamodb.splits" -> "100"
))
).getDynamicFrame()
print(dynamicFrame.getNumPartitions())
val dynamoDbSink: DynamoDbDataSink = glueContext.getSinkWithFormat(
connectionType = "dynamodb",
options = JsonOptions(Map(
"dynamodb.output.tableName" -> test_sink,
"dynamodb.throughput.write.percent" -> "1.0"
))
).asInstanceOf[DynamoDbDataSink]
dynamoDbSink.writeDynamicFrame(dynamicFrame)
Job.commit()
}
}
```
------
## Utilisation du connecteur d’exportation DynamoDB
Le connecteur d'exportation fonctionne mieux que le connecteur ETL lorsque la taille de la table DynamoDB est supérieure à 80 Go. En outre, étant donné que la demande d'exportation est effectuée en dehors des processus Spark dans une tâche AWS Glue, vous pouvez activer [l'auto scaling des tâches AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/auto-scaling.html) pour enregistrer l'utilisation du DPU pendant la demande d'exportation. Avec le connecteur d'exportation, vous n'avez pas non plus besoin de configurer le nombre de fractionnements pour le parallélisme de l'exécuteur Spark ou le pourcentage de lecture du débit DynamoDB.
**Note**
DynamoDB a des exigences spécifiques pour recourir aux demandes `ExportTableToPointInTime`. Pour plus d'informations, consultez [Demande d'exportation de table dans DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataExport.Requesting.html). Par exemple, Point-in-Time-Restore (PITR) doit être activé sur la table pour utiliser ce connecteur. Le connecteur DynamoDB prend également en charge le AWS KMS chiffrement pour les exportations DynamoDB vers Amazon S3. La saisie de votre configuration de sécurité dans la configuration de la tâche AWS Glue active AWS KMS le chiffrement pour une exportation DynamoDB. La clé KMS doit être située dans la même région que le compartiment Simple Storage Service (Amazon S3).
Notez que des frais supplémentaires pour l'exportation DynamoDB et les coûts de stockage Simple Storage Service (Amazon S3) s'appliquent. Les données exportées dans Simple Storage Service (Amazon S3) sont conservées une fois l'exécution d'une tâche terminée, ce qui vous permet de les réutiliser sans exportations DynamoDB supplémentaires. L'une des conditions requises pour utiliser ce connecteur est que point-in-time la restauration (PITR) soit activée pour la table.
Le connecteur ETL DynamoDB ou le connecteur d'exportation ne prennent pas en charge les filtres ou les prédicats pushdown à appliquer à la source DynamoDB.
Les exemples de code suivants montrent comment lire (via le connecteur d'exportation) et comment imprimer le nombre de partitions.
------
#### [ Python ]
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions
args = getResolvedOptions(sys.argv, ["JOB_NAME"])
glue_context= GlueContext(SparkContext.getOrCreate())
job = Job(glue_context)
job.init(args["JOB_NAME"], args)
dyf = glue_context.create_dynamic_frame.from_options(
connection_type="dynamodb",
connection_options={
"dynamodb.export": "ddb",
"dynamodb.tableArn": test_source,
"dynamodb.s3.bucket": bucket_name,
"dynamodb.s3.prefix": bucket_prefix,
"dynamodb.s3.bucketOwner": account_id_of_bucket,
}
)
print(dyf.getNumPartitions())
job.commit()
```
------
#### [ Scala ]
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.DynamoDbDataSink
import org.apache.spark.SparkContext
import scala.collection.JavaConverters._
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val glueContext = new GlueContext(SparkContext.getOrCreate())
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
val dynamicFrame = glueContext.getSourceWithFormat(
connectionType = "dynamodb",
options = JsonOptions(Map(
"dynamodb.export" -> "ddb",
"dynamodb.tableArn" -> test_source,
"dynamodb.s3.bucket" -> bucket_name,
"dynamodb.s3.prefix" -> bucket_prefix,
"dynamodb.s3.bucketOwner" -> account_id_of_bucket,
))
).getDynamicFrame()
print(dynamicFrame.getNumPartitions())
Job.commit()
}
}
```
------
Ces exemples montrent comment effectuer la lecture (via le connecteur d'exportation) et imprimer le nombre de partitions à partir d'une table AWS Glue Data Catalog comportant une `dynamodb` classification :
------
#### [ Python ]
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions
args = getResolvedOptions(sys.argv, ["JOB_NAME"])
glue_context= GlueContext(SparkContext.getOrCreate())
job = Job(glue_context)
job.init(args["JOB_NAME"], args)
dynamicFrame = glue_context.create_dynamic_frame.from_catalog(
database=catalog_database,
table_name=catalog_table_name,
additional_options={
"dynamodb.export": "ddb",
"dynamodb.s3.bucket": s3_bucket,
"dynamodb.s3.prefix": s3_bucket_prefix
}
)
print(dynamicFrame.getNumPartitions())
job.commit()
```
------
#### [ Scala ]
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.DynamoDbDataSink
import org.apache.spark.SparkContext
import scala.collection.JavaConverters._
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val glueContext = new GlueContext(SparkContext.getOrCreate())
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
val dynamicFrame = glueContext.getCatalogSource(
database = catalog_database,
tableName = catalog_table_name,
additionalOptions = JsonOptions(Map(
"dynamodb.export" -> "ddb",
"dynamodb.s3.bucket" -> s3_bucket,
"dynamodb.s3.prefix" -> s3_bucket_prefix
))
).getDynamicFrame()
print(dynamicFrame.getNumPartitions())
)
```
------
## Simplification de l’utilisation de l’exportation DynamoDB au format JSON
Les exportations DynamoDB avec le connecteur d’exportation AWS Glue DynamoDB donnent lieu à des fichiers JSON de structures imbriquées spécifiques. Pour plus d'informations, consultez la section [Objets de données](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/S3DataExport.Output.html). AWS Gluefournit une DynamicFrame transformation qui peut transformer ces structures en une easier-to-use forme destinée à des applications en aval.
La transformation peut être appelée de deux manières. Vous pouvez définir l’option de connexion `"dynamodb.simplifyDDBJson"` avec la valeur `"true"` lorsque vous appelez une méthode pour lire à partir de DynamoDB. Vous pouvez également appeler la transformation en tant que méthode disponible indépendamment dans la bibliothèque AWS Glue.
Tenez compte du schéma suivant généré par une exportation DynamoDB :
```
root
|-- Item: struct
| |-- parentMap: struct
| | |-- M: struct
| | | |-- childMap: struct
| | | | |-- M: struct
| | | | | |-- appName: struct
| | | | | | |-- S: string
| | | | | |-- packageName: struct
| | | | | | |-- S: string
| | | | | |-- updatedAt: struct
| | | | | | |-- N: string
| |-- strings: struct
| | |-- SS: array
| | | |-- element: string
| |-- numbers: struct
| | |-- NS: array
| | | |-- element: string
| |-- binaries: struct
| | |-- BS: array
| | | |-- element: string
| |-- isDDBJson: struct
| | |-- BOOL: boolean
| |-- nullValue: struct
| | |-- NULL: boolean
```
La transformation `simplifyDDBJson` simplifie cette exportation ainsi :
```
root
|-- parentMap: struct
| |-- childMap: struct
| | |-- appName: string
| | |-- packageName: string
| | |-- updatedAt: string
|-- strings: array
| |-- element: string
|-- numbers: array
| |-- element: string
|-- binaries: array
| |-- element: string
|-- isDDBJson: boolean
|-- nullValue: null
```
**Note**
`simplifyDDBJson`est disponible dans AWS Glue 3.0 et versions ultérieures. La transformation `unnestDDBJson` est également disponible pour simplifier l’exportation DynamoDB au format JSON. Nous encourageons les utilisateurs à passer de `simplifyDDBJson` à `unnestDDBJson`.
## Configuration du parallélisme des opérations de DynamoDB
Pour améliorer les performances, vous pouvez régler certains paramètres disponibles pour le connecteur DynamoDB. Lorsque vous ajustez les paramètres de parallélisme, votre objectif est de maximiser l'utilisation des AWS Glue workers provisionnés. Ensuite, si vous avez besoin de plus de performances, nous vous recommandons d'étendre votre travail en augmentant le nombre de DPUs.
Vous pouvez modifier le parallélisme dans une opération de lecture de DynamoDB à l’aide du paramètre `dynamodb.splits` lorsque vous utilisez le connecteur ETL. Lors d’une tâche de lecture avec le connecteur d’exportation, vous n’avez pas besoin de configurer le nombre de fractionnements pour le parallélisme de l’exécuteur Spark. Vous pouvez modifier le parallélisme dans une opération d’écriture de DynamoDB avec `dynamodb.output.numParallelTasks`.
**Lecture avec le connecteur ETL DynamoDB**
Nous vous recommandons de calculer `dynamodb.splits` en fonction du nombre maximum d’employés défini dans la configuration de votre tâche et du calcul `numSlots` suivant. En cas de mise à l’échelle automatique, le nombre réel d’employés disponibles peut changer et passer en dessous de ce plafond. Pour plus d’informations sur la définition du nombre maximum d’employés, consultez **Nombre d’employés** (`NumberOfWorkers`) dans [Configuration des propriétés des tâches pour les tâches Spark dans AWS Glue](add-job.md).
+ `numExecutors = NumberOfWorkers - 1`
À des fins de contexte, un exécuteur est réservé au pilote Spark ; d'autres exécuteurs sont utilisés pour traiter les données.
+ `numSlotsPerExecutor =`
------
#### [ AWS Glue 3.0 and later versions ]
+ `4` si `WorkerType` a la valeur `G.1X`
+ `8` si `WorkerType` a la valeur `G.2X`
+ `16` si `WorkerType` a la valeur `G.4X`
+ `32` si `WorkerType` a la valeur `G.8X`
------
#### [ AWS Glue 2.0 and legacy versions ]
+ `8` si `WorkerType` a la valeur `G.1X`
+ `16` si `WorkerType` a la valeur `G.2X`
------
+ `numSlots = numSlotsPerExecutor * numExecutors`
Nous vous recommandons de définir `dynamodb.splits` sur le nombre d’emplacements disponibles, `numSlots`.
**Écriture dans DynamoDB**
Le paramètre `dynamodb.output.numParallelTasks` est utilisé pour déterminer le WCU par tâche Spark, à l’aide du calcul suivant :
`permittedWcuPerTask = ( TableWCU * dynamodb.throughput.write.percent ) / dynamodb.output.numParallelTasks`
Le dispositif d’écriture DynamoDB fonctionne de manière optimale si la configuration représente avec précision le nombre de tâches Spark écrites dans DynamoDB. Dans certains cas, il se peut que vous ayez besoin de remplacer le calcul par défaut afin d’améliorer les performances d’écriture. Si vous ne spécifiez pas ce paramètre, le WCU autorisé pour chaque tâche Spark est automatiquement calculé par la formule suivante :
+
+ `numPartitions = dynamicframe.getNumPartitions()`
+ `numSlots` (tel que défini précédemment dans cette section)
+ `numParallelTasks = min(numPartitions, numSlots)`
+ Exemple 1. DPU = 10, = Norme. WorkerType L'entrée DynamicFrame comporte 100 partitions RDD.
+ `numPartitions = 100`
+ `numExecutors = (10 - 1) * 2 - 1 = 17`
+ `numSlots = 4 * 17 = 68`
+ `numParallelTasks = min(100, 68) = 68`
+ Exemple 2. DPU = 10, = Norme. WorkerType L'entrée DynamicFrame comporte 20 partitions RDD.
+ `numPartitions = 20`
+ `numExecutors = (10 - 1) * 2 - 1 = 17`
+ `numSlots = 4 * 17 = 68`
+ `numParallelTasks = min(20, 68) = 20`
**Note**
Les jobs sur les anciennes versions de AWS Glue et ceux utilisant des outils Standard Workers nécessitent des méthodes différentes pour calculer le nombre d'emplacements. Si vous avez besoin d'optimiser les performances de ces tâches, nous vous recommandons de passer aux versions compatibles de AWS Glue.
## Référence des options de connexion DynamoDB
Désigne une connexion à Amazon DynamoDB.
Les options de connexion sont différentes pour une connexion source et une connexion collecteur.
### « connectionType » : « dynamodb » avec le connecteur ETL comme source
Utilisez les options de connexion suivantes en `"connectionType": "dynamodb"` tant que source, lorsque vous utilisez le connecteur ETL AWS Glue DynamoDB :
+ `"dynamodb.input.tableName"` : (obligatoire) table DynamoDB à lire.
+ `"dynamodb.throughput.read.percent"` : (Facultatif) Le pourcentage d'unités de capacité de lecture à utiliser. La valeur définie par défaut est « 0,5 ». Valeurs acceptées : de 0,1 à 1,5 inclus.
+ `0.5` représente la vitesse de lecture par défaut, ce qui signifie que AWS Glue tente de consommer la moitié de la capacité de lecture de la table. Si vous augmentez la valeur au-delà de `0.5`, AWS Glue augmente le débit de demandes. Si vous réduisez la valeur en dessous de `0.5`, le débit de demandes de lecture baisse. (La vitesse de lecture réelle dépend de facteurs tels que l'existence d'une distribution uniforme des clés dans la table DynamoDB.)
+ Lorsque la table DynamoDB est en mode à la demande, AWS Glue gère la capacité de lecture de la table à 40 000. Pour exporter une table volumineuse, nous vous recommandons de basculer votre table DynamoDB en mode à la demande.
+ `"dynamodb.splits"` : (facultatif) définit en combien de fractionnements nous partitionnons cette table DynamoDB lors de la lecture. La valeur définie par défaut est « 1 ». Valeurs acceptées : de 1 à 1 000 000 inclus.
`1` montre qu'il n'y a pas de parallélisme. Nous vous recommandons fortement de spécifier une valeur plus élevée pour de meilleures performances en utilisant la formule ci-dessous. Pour plus d’informations sur la définition appropriée d’une valeur, consultez [Configuration du parallélisme des opérations de DynamoDB](#aws-glue-programming-etl-connect-dynamodb-parallelism).
+ `"dynamodb.sts.roleArn"` : (facultatif) l'ARN du rôle IAM à endosser pour l'accès entre comptes. Ce paramètre est disponible dans AWS Glue 1.0 ou une version ultérieure.
+ `"dynamodb.sts.roleSessionName"` : (facultatif) nom de séance STS. La valeur par défaut est définie sur « glue-dynamodb-read-sts -session ». Ce paramètre est disponible dans AWS Glue 1.0 ou une version ultérieure.
### « connectionType » : « dynamodb » avec le connecteur d'exportation DynamoDB AWS Glue comme source
Utilisez les options de connexion suivantes avec « connectionType » : « dynamodb » en tant que source, lorsque vous utilisez le connecteur d'exportation DynamoDB AWS Glue, disponible uniquement pour AWS Glue version 2.0 et au-delà :
+ `"dynamodb.export"` : (Obligatoire) Une valeur de chaîne :
+ Si la valeur est définie sur `ddb`, le connecteur d'exportation DynamoDB AWS Glue est activé où un nouveau paramètre `ExportTableToPointInTimeRequest` sera invoqué pendant la tâche AWS Glue. Une nouvelle exportation sera générée avec l'emplacement transmis depuis `dynamodb.s3.bucket` et `dynamodb.s3.prefix`.
+ Si la valeur est définie sur `s3`, le connecteur d'exportation DynamoDB AWS Glue est activé, mais ignore la création d'une nouvelle exportation DynamoDB et utilise plutôt les paramètres `dynamodb.s3.bucket` et `dynamodb.s3.prefix` en tant qu'emplacement Amazon S3 d'une exportation antérieure de cette table.
+ `"dynamodb.tableArn"` : (obligatoire) table DynamoDB à lire.
+ `"dynamodb.unnestDDBJson"` : (Facultatif) Par défaut : false. Valeurs valides : booléen. S'il est paramétré sur true, il effectue une transformation irréprochable de la structure JSON DynamoDB présente dans les exportations. Définir `"dynamodb.unnestDDBJson"` et `"dynamodb.simplifyDDBJson"` sur true en même temps constitue une erreur. Dans les AWS versions 3.0 et ultérieures, nous vous recommandons de l'utiliser `"dynamodb.simplifyDDBJson"` pour un meilleur comportement lors de la simplification des types de cartes DynamoDB. Pour de plus amples informations, veuillez consulter [Simplification de l’utilisation de l’exportation DynamoDB au format JSON](#etl-connect-dynamodb-traversing-structure).
+ `"dynamodb.simplifyDDBJson"` : (Facultatif) Par défaut : false. Valeurs valides : booléen. S’il est paramétré sur true, il effectue une transformation pour simplifier le schéma de la structure JSON DynamoDB présente dans les exportations. Cela a le même objectif que l’option `"dynamodb.unnestDDBJson"`, mais fournit une meilleure prise en charge des types de cartes DynamoDB ou même des types de cartes imbriqués dans votre table DynamoDB. Cette option est disponible dans AWS Glue 3.0 et versions ultérieures. Définir `"dynamodb.unnestDDBJson"` et `"dynamodb.simplifyDDBJson"` sur true en même temps constitue une erreur. Pour de plus amples informations, veuillez consulter [Simplification de l’utilisation de l’exportation DynamoDB au format JSON](#etl-connect-dynamodb-traversing-structure).
+ `"dynamodb.s3.bucket"` : (facultatif) Indique l'emplacement du compartiment Amazon S3 dans lequel le processus DynamoDB `ExportTableToPointInTime` doit être mené. Le format de fichier de l'exportation est DynamoDB JSON.
+ `"dynamodb.s3.prefix"` : (Facultatif) Indique l'emplacement du préfixe Amazon S3 dans le compartiment Amazon S3 dans lequel les charges `ExportTableToPointInTime` de DynamoDB doivent être stockées. Si `dynamodb.s3.prefix` ni `dynamodb.s3.bucket` ne sont indiqués, ces valeurs seront par défaut à l'emplacement du répertoire temporaire indiqué dans la configuration de la tâche AWS Glue. Pour plus d'informations, consultez la section [Paramètres spéciaux utilisés par AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html).
+ `"dynamodb.s3.bucketOwner"` : indique le propriétaire du compartiment nécessaire à l'accès Amazon S3 entre comptes.
+ `"dynamodb.sts.roleArn"`: (Facultatif) L'ARN du rôle IAM à utiliser pour l'accès entre comptes L'accès and/or interrégional à la table DynamoDB. Remarque : Le même ARN de rôle IAM sera utilisé pour accéder à l'emplacement Amazon S3 spécifié pour la demande de `ExportTableToPointInTime`.
+ `"dynamodb.sts.roleSessionName"` : (facultatif) nom de séance STS. La valeur par défaut est définie sur « glue-dynamodb-read-sts -session ».
+ `"dynamodb.exportTime"` (Facultatif) Valeurs valides : chaînes représentant des instants ISO-8601. point-in-timeA où l'exportation doit être effectuée.
+ `"dynamodb.sts.region"` : (Obligatoire si vous passez un appel entre régions à l’aide d’un point de terminaison régional) Région hébergeant la table DynamoDB que vous souhaitez lire.
### « connectionType » : « dynamodb » avec le connecteur ETL comme récepteur
Utilisez les options de connexion suivantes avec `"connectionType": "dynamodb"` comme collecteur :
+ `"dynamodb.output.tableName"` : (obligatoire) table DynamoDB où écrire.
+ `"dynamodb.throughput.write.percent"` : (facultatif) pourcentage d'unités de capacité de lecture (WCU) à utiliser. La valeur définie par défaut est « 0,5 ». Valeurs acceptées : de 0,1 à 1,5 inclus.
+ `0.5` représente la vitesse d'écriture par défaut, ce qui signifie que AWS Glue tente de consommer la moitié de la capacité d'écriture de la table. Si vous augmentez la valeur au-delà de 0,5, AWS Glue augmente le débit de demandes. Si vous réduisez la valeur en dessous de 0,5, le débit de demandes d'écriture baisse. (La vitesse d'écriture réelle dépend de facteurs tels que l'existence d'une distribution uniforme des clés dans la table DynamoDB.)
+ Lorsque la table DynamoDB est en mode à la demande, AWS Glue gère la capacité d'écriture de la table à `40000`. Pour importer une table volumineuse, nous vous recommandons de basculer votre table DynamoDB en mode à la demande.
+ `"dynamodb.output.numParallelTasks"` : (facultatif) définit le nombre de tâches parallèles qui écrivent dans DynamoDB simultanément. Utilisé pour calculer le WCU permissif par tâche Spark. Dans la plupart des cas, AWS Glue calcule une valeur par défaut raisonnable pour cette valeur. Pour de plus amples informations, veuillez consulter [Configuration du parallélisme des opérations de DynamoDB](#aws-glue-programming-etl-connect-dynamodb-parallelism).
+ `"dynamodb.output.retry"` : (facultatif) définit le nombre de tentatives que nous effectuons lorsqu'il y a un `ProvisionedThroughputExceededException` de DynamoDB. La valeur définie par défaut est « 10 ».
+ `"dynamodb.sts.roleArn"` : (facultatif) l'ARN du rôle IAM à endosser pour l'accès entre comptes.
+ `"dynamodb.sts.roleSessionName"` : (facultatif) nom de séance STS. La valeur par défaut est définie sur « glue-dynamodb-write-sts -session ».
# Accès entre régions et entre comptes aux tables DynamoDB
AWS Glue Les tâches ETL prennent en charge l'accès entre régions et entre comptes aux tables DynamoDB. AWS Glue Les tâches ETL permettent à la fois de lire les données de la table DynamoDB d'un autre AWS compte et d'écrire des données dans la table DynamoDB d'un autre AWS compte. AWS Gluepermet également de lire à partir d'une table DynamoDB d'une autre région et d'écrire dans une table DynamoDB d'une autre région. Cette section donne des instructions sur la configuration de l'accès et fournit un exemple de script.
Les procédures de cette section font référence à un didacticiel IAM pour créer un rôle IAM et accorder l'accès au rôle. Le didacticiel traite également de la prise en charge d'un rôle, mais ici, vous utiliserez plutôt un script de tâche pour endosser le rôle dans AWS Glue. Ce didacticiel contient également des informations sur les pratiques générales entre comptes. Pour plus d'informations, voir [Tutoriel : Déléguer l'accès entre AWS comptes à l'aide de rôles IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html) dans le Guide de l'*utilisateur IAM*.
## Créer un rôle
Suivez l'[étape 1 du didacticiel](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html#tutorial_cross-account-with-roles-1) pour créer un rôle IAM dans le compte A. Lorsque vous définissez les autorisations du rôle, vous pouvez choisir d'associer des politiques existantes telles que `AmazonDynamoDBReadOnlyAccess` ou d'autoriser le rôle `AmazonDynamoDBFullAccess` à read/write DynamoDB. L'exemple suivant illustre la création d'un rôle nommé `DynamoDBCrossAccessRole`, avec la politique d'autorisation `AmazonDynamoDBFullAccess`.
## Accorder l'accès au rôle
Suivez l'[étape 2 du didacticiel](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html#tutorial_cross-account-with-roles-2) du *Guide de l'utilisateur IAM* pour permettre au compte B de basculer vers le rôle qui vient d'être créé. L'exemple suivant crée une politique avec l'instruction suivante :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam::111122223333:role/DynamoDBCrossAccessRole"
}
}
```
------
Vous pouvez ensuite associer cette politique à celle group/role/user que vous souhaitez utiliser pour accéder à DynamoDB.
## Endosser le rôle dans le script de tâche AWS Glue
Maintenant, vous pouvez vous connecter au compte B et créer une tâche AWS Glue. Pour créer une tâche, reportez-vous aux instructions de la page [Configuration des propriétés des tâches pour les tâches Spark dans AWS Glue](add-job.md).
Dans le script de tâche, vous devez utiliser le paramètre `dynamodb.sts.roleArn` pour endosser le rôle `DynamoDBCrossAccessRole`. En supposant que ce rôle vous permet d'obtenir les informations d'identification temporaires, qui doivent être utilisées pour accéder à DynamoDB dans le compte B. Consultez ces exemples de scripts.
Pour une lecture entre comptes dans toutes les régions (connecteur ETL) :
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions
args = getResolvedOptions(sys.argv, ["JOB_NAME"])
glue_context= GlueContext(SparkContext.getOrCreate())
job = Job(glue_context)
job.init(args["JOB_NAME"], args)
dyf = glue_context.create_dynamic_frame_from_options(
connection_type="dynamodb",
connection_options={
"dynamodb.region": "us-east-1",
"dynamodb.input.tableName": "test_source",
"dynamodb.sts.roleArn": ""
}
)
dyf.show()
job.commit()
```
Pour une lecture entre comptes dans toutes les régions (connecteur ETL) :
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions
args = getResolvedOptions(sys.argv, ["JOB_NAME"])
glue_context= GlueContext(SparkContext.getOrCreate())
job = Job(glue_context)
job.init(args["JOB_NAME"], args)
dyf = glue_context.create_dynamic_frame_from_options(
connection_type="dynamodb",
connection_options={
"dynamodb.export": "ddb",
"dynamodb.tableArn": "",
"dynamodb.sts.roleArn": ""
}
)
dyf.show()
job.commit()
```
Pour une lecture et une écriture entre comptes dans toutes les régions :
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions
args = getResolvedOptions(sys.argv, ["JOB_NAME"])
glue_context= GlueContext(SparkContext.getOrCreate())
job = Job(glue_context)
job.init(args["JOB_NAME"], args)
dyf = glue_context.create_dynamic_frame_from_options(
connection_type="dynamodb",
connection_options={
"dynamodb.region": "us-east-1",
"dynamodb.input.tableName": "test_source"
}
)
dyf.show()
glue_context.write_dynamic_frame_from_options(
frame=dyf,
connection_type="dynamodb",
connection_options={
"dynamodb.region": "us-west-2",
"dynamodb.output.tableName": "test_sink",
"dynamodb.sts.roleArn": ""
}
)
job.commit()
```
# Connecteur DynamoDB avec prise en charge de Spark DataFrame
Le connecteur DynamoDB compatible avec DataFrame Spark vous permet de lire et d'écrire dans des tables de DynamoDB à l'aide de Spark. DataFrame APIs Les étapes de configuration du connecteur sont les mêmes que pour le connecteur DynamicFrame basé et peuvent être consultées [ici](aws-glue-programming-etl-connect-dynamodb-home.md#aws-glue-programming-etl-connect-dynamodb-configure).
Pour charger dans la bibliothèque de connecteurs DataFrame basée, veillez à associer une connexion DynamoDB à la tâche Glue.
**Note**
L'interface utilisateur de la console Glue ne prend actuellement pas en charge la création d'une connexion DynamoDB. Vous pouvez utiliser Glue CLI ([CreateConnection](https://docs.aws.amazon.com/cli/latest/reference/glue/create-connection.html)) pour créer une connexion DynamoDB :
```
aws glue create-connection \
--connection-input '{ \
"Name": "my-dynamodb-connection", \
"ConnectionType": "DYNAMODB", \
"ConnectionProperties": {}, \
"ValidateCredentials": false, \
"ValidateForComputeEnvironments": ["SPARK"] \
}'
```
Lors de la création de la connexion DynamoDB, vous pouvez l'associer à votre tâche Glue via CLI [CreateJob](https://docs.aws.amazon.com/cli/latest/reference/glue/create-job.html)([UpdateJob](https://docs.aws.amazon.com/cli/latest/reference/glue/update-job.html),) ou directement sur la page « Détails de la tâche » :
![\[alt text not found\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/dynamodb-dataframe-connector.png)
Après avoir vérifié qu'une connexion avec DYNAMODB Type est attachée à votre tâche Glue, vous pouvez utiliser les opérations de lecture, d'écriture et d'exportation suivantes à partir du connecteur DataFrame basé.
## Lecture et écriture dans DynamoDB à l'aide du connecteur basé DataFrame
Les exemples de code suivants montrent comment lire et écrire dans des tables DynamoDB via DataFrame le connecteur basé. Ils montrent la lecture d'une table et l'écriture dans une autre table.
------
#### [ Python ]
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions
args = getResolvedOptions(sys.argv, ["JOB_NAME"])
glue_context= GlueContext(SparkContext.getOrCreate())
spark = glueContext.spark_session
job = Job(glue_context)
job.init(args["JOB_NAME"], args)
# Read from DynamoDB
df = spark.read.format("dynamodb") \
.option("dynamodb.input.tableName", "test-source") \
.option("dynamodb.throughput.read.ratio", "0.5") \
.option("dynamodb.consistentRead", "false") \
.load()
print(df.rdd.getNumPartitions())
# Write to DynamoDB
df.write \
.format("dynamodb") \
.option("dynamodb.output.tableName", "test-sink") \
.option("dynamodb.throughput.write.ratio", "0.5") \
.option("dynamodb.item.size.check.enabled", "true") \
.save()
job.commit()
```
------
#### [ Scala ]
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import org.apache.spark.SparkContext
import scala.collection.JavaConverters._
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val glueContext = new GlueContext(SparkContext.getOrCreate())
val spark = glueContext.getSparkSession
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
val df = spark.read
.format("dynamodb")
.option("dynamodb.input.tableName", "test-source")
.option("dynamodb.throughput.read.ratio", "0.5")
.option("dynamodb.consistentRead", "false")
.load()
print(df.rdd.getNumPartitions)
df.write
.format("dynamodb")
.option("dynamodb.output.tableName", "test-sink")
.option("dynamodb.throughput.write.ratio", "0.5")
.option("dynamodb.item.size.check.enabled", "true")
.save()
job.commit()
}
}
```
------
## Utilisation de l'exportation DynamoDB via le connecteur basé DataFrame
L'opération d'exportation est préférable à l'opération de lecture pour les tables DynamoDB de plus de 80 Go. Les exemples de code suivants montrent comment lire depuis une table, exporter vers S3 et imprimer le nombre de partitions via le connecteur DataFrame basé.
**Note**
La fonctionnalité d'exportation DynamoDB est disponible via l'objet Scala. `DynamoDBExport` Les utilisateurs de Python peuvent y accéder via l'interopérabilité JVM de Spark ou utiliser le SDK AWS pour Python (boto3) avec l'API DynamoDB. `ExportTableToPointInTime`
------
#### [ Scala ]
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.util.{GlueArgParser, Job}
import org.apache.spark.SparkContext
import glue.spark.dynamodb.DynamoDBExport
import scala.collection.JavaConverters._
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val glueContext = new GlueContext(SparkContext.getOrCreate())
val spark = glueContext.getSparkSession
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
val options = Map(
"dynamodb.export" -> "ddb",
"dynamodb.tableArn" -> "arn:aws:dynamodb:us-east-1:123456789012:table/my-table",
"dynamodb.s3.bucket" -> "my-s3-bucket",
"dynamodb.s3.prefix" -> "my-s3-prefix",
"dynamodb.simplifyDDBJson" -> "true"
)
val df = DynamoDBExport.fullExport(spark, options)
print(df.rdd.getNumPartitions)
df.count()
Job.commit()
}
}
```
------
## Options de configuration
### Options de lecture
| Option | Description | Par défaut |
| --- | --- | --- |
| dynamodb.input.tableName | Nom de la table DynamoDB (obligatoire) | - |
| dynamodb.throughput.read | Les unités de capacité de lecture (RCU) à utiliser. S'il n'est pas spécifié, dynamodb.throughput.read.ratio il est utilisé pour le calcul. | - |
| dynamodb.throughput.read.ratio | Le ratio d'unités de capacité de lecture (RCU) à utiliser | 0.5 |
| dynamodb.table.read.capacity | Capacité de lecture de la table à la demande utilisée pour calculer le débit. Ce paramètre n'est efficace que dans les tables de capacité à la demande. Par défaut, ce sont les unités de lecture à débit chaud. | - |
| dynamodb.splits | Définit le nombre de segments utilisés dans les opérations de scan en parallèle. S'il n'est pas fourni, le connecteur calculera une valeur par défaut raisonnable. | - |
| dynamodb.consistentRead | S'il faut utiliser des lectures très cohérentes | FALSE |
| dynamodb.input.retry | Définit le nombre de tentatives que nous effectuons en cas d'exception réessayable. | 10 |
### Options d'écriture
| Option | Description | Par défaut |
| --- | --- | --- |
| dynamodb.output.tableName | Nom de la table DynamoDB (obligatoire) | - |
| dynamodb.throughput.write | Les unités de capacité d'écriture (WCU) à utiliser. S'il n'est pas spécifié, dynamodb.throughput.write.ratio il est utilisé pour le calcul. | - |
| dynamodb.throughput.write.ratio | Le ratio d'unités de capacité d'écriture (WCU) à utiliser | 0.5 |
| dynamodb.table.write.capacity | Capacité d'écriture de la table à la demande utilisée pour calculer le débit. Ce paramètre n'est efficace que dans les tables de capacité à la demande. Par défaut, ce sont les unités d'écriture à débit chaud. | - |
| dynamodb.item.size.check.enabled | Si c'est vrai, le connecteur calcule la taille de l'élément et abandonne si la taille dépasse la taille maximale, avant d'écrire dans la table DynamoDB. | TRUE |
| dynamodb.output.retry | Définit le nombre de tentatives que nous effectuons en cas d'exception réessayable. | 10 |
### Options d'exportation
| Option | Description | Par défaut |
| --- | --- | --- |
| dynamodb.export | S'il est défini sur, ddb active le connecteur d'exportation AWS Glue DynamoDB dans lequel un ExportTableToPointInTimeRequet nouveau connecteur sera invoqué pendant la AWS tâche Glue. Une nouvelle exportation sera générée avec l'emplacement transmis depuis dynamodb.s3.bucket et dynamodb.s3.prefix. S'il est défini sur, s3 active le connecteur d'exportation AWS Glue DynamoDB mais ignore la création d'une nouvelle exportation DynamoDB et utilise à la place le et dynamodb.s3.bucket comme emplacement Amazon S3 de dynamodb.s3.prefix l'ancienne exportation de cette table. | ddb |
| dynamodb.tableArn | La table DynamoDB à partir de laquelle lire. Obligatoire si dynamodb.export est défini sur ddb. | |
| dynamodb.simplifyDDBJson | S'il est défini surtrue, exécute une transformation pour simplifier le schéma de la structure JSON DynamoDB présente dans les exportations. | FALSE |
| dynamodb.s3.bucket | Le compartiment S3 pour stocker les données temporaires lors de l'exportation DynamoDB (obligatoire) | |
| dynamodb.s3.prefix | Le préfixe S3 pour stocker les données temporaires lors de l'exportation DynamoDB | |
| dynamodb.s3.bucketOwner | Indiquez le propriétaire du compartiment requis pour l'accès entre comptes Amazon S3 | |
| dynamodb.s3.sse.algorithm | Type de chiffrement utilisé sur le compartiment dans lequel les données temporaires seront stockées. Les valeurs valides sont AES256 et KMS. | |
| dynamodb.s3.sse.kmsKeyId | ID de la clé AWS KMS gérée utilisée pour chiffrer le compartiment S3 dans lequel les données temporaires seront stockées (le cas échéant). | |
| dynamodb.exportTime | point-in-timeA où l'exportation doit être effectuée. Valeurs valides : chaînes représentant des instants ISO-8601. | |
### Options générales
| Option | Description | Par défaut |
| --- | --- | --- |
| dynamodb.sts.roleArn | L'ARN du rôle IAM à assumer pour l'accès entre comptes | - |
| dynamodb.sts.roleSessionName | Nom de session STS | glue-dynamodb-sts-session |
| dynamodb.sts.region | Région pour le client STS (pour l'hypothèse d'un rôle interrégional) | Identique à l'regionoption |
# Connexions Kinesis
Vous pouvez utiliser une connexion Kinesis pour lire et écrire dans Amazon Kinesis Data Streams à l’aide d’informations stockées dans une table de catalogue de données ou en fournissant des informations permettant d’accéder directement au flux de données. Vous pouvez lire les informations de Kinesis dans un Spark DataFrame, puis les convertir en Glue AWS . DynamicFrame Vous pouvez DynamicFrames écrire dans Kinesis au format JSON. Si vous accédez directement au flux de données, utilisez ces options pour fournir des informations sur la façon d'accéder au flux de données.
Si vous utilisez `getCatalogSource` ou `create_data_frame_from_catalog` pour consommer des enregistrements à partir d'une source de streaming Kinesis, la tâche dispose des informations relatives à la base de données Data Catalog et au nom de la table, et peut les utiliser pour obtenir certains paramètres de base pour la lecture à partir de la source de streaming Kinesis. Si vous utilisez `getSource`, `getSourceWithFormat`, `createDataFrameFromOptions` ou `create_data_frame_from_options`, vous devez spécifier ces paramètres de base à l'aide des options de connexion décrites ici.
Vous pouvez spécifier les options de connexion pour Kinesis à l'aide des arguments suivants pour les méthodes spécifiées dans la classe `GlueContext`.
+ Scala
+ `connectionOptions` : utiliser avec `getSource`, `createDataFrameFromOptions`, `getSink`
+ `additionalOptions` : utiliser avec `getCatalogSource`, `getCatalogSink`
+ `options` : utiliser avec `getSourceWithFormat`, `getSinkWithFormat`
+ Python
+ `connection_options` : utiliser avec `create_data_frame_from_options`, `write_dynamic_frame_from_options`
+ `additional_options` : utiliser avec `create_data_frame_from_catalog`, `write_dynamic_frame_from_catalog`
+ `options` : utiliser avec `getSource`, `getSink`
Pour les remarques et les restrictions concernant les tâches ETL de streaming, consultez [Restrictions et notes sur ETL en streaming](add-job-streaming.md#create-job-streaming-restrictions).
## Configurer Kinesis
Pour vous connecter à un flux de données Kinesis dans le cadre d'une tâche AWS Glue Spark, vous aurez besoin de certaines conditions préalables :
+ En cas de lecture, la tâche AWS Glue doit disposer d'autorisations IAM de niveau d'accès en lecture pour le flux de données Kinesis.
+ En cas d'écriture, la tâche AWS Glue doit disposer d'autorisations IAM de niveau d'accès Write pour le flux de données Kinesis.
Dans certains cas, vous devrez configurer des prérequis supplémentaires :
+ Si votre tâche AWS Glue est configurée avec **des connexions réseau supplémentaires** (généralement pour se connecter à d'autres ensembles de données) et que l'une de ces connexions fournit des options de **réseau Amazon VPC**, cela indiquera à votre tâche de communiquer via Amazon VPC. Dans ce cas, vous devrez également configurer votre flux de données Kinesis pour qu'il communique via Amazon VPC. Vous pouvez le faire en créant un point de terminaison d'un VPC d'interface entre votre Amazon VPC et votre flux de données Kinesis. Pour plus d'informations, consultez [Using Kinesis Data Streams with Interface VPC Endpoints](https://docs.aws.amazon.com//streams/latest/dev/vpc.html).
+ Lorsque vous spécifiez Amazon Kinesis Data Streams dans un autre compte, vous devez configurer les rôles et les stratégies pour autoriser l'accès intercompte. Pour de plus amples informations, veuillez consulter la rubrique [Exemple : Lire à partir d’un flux Kinesis dans un autre compte](https://docs.aws.amazon.com/kinesisanalytics/latest/java/examples-cross.html).
Pour plus d'informations sur les prérequis de la tâche ETL de streaming, consultez [Tâches ETL en streaming dans AWS Glue](add-job-streaming.md).
## Exemple : lecture à partir de flux Kinesis
### Exemple : lecture à partir de flux Kinesis
Utilisez conjointement avec [forEachBatch](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-forEachBatch).
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 : écriture dans Kinesis Streams
### Exemple : lecture à partir de flux Kinesis
Utilisez conjointement avec [forEachBatch](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-forEachBatch).
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)
```
## Référence des options de connexion Kinesis
Désigne des options de connexion à Amazon Kinesis Data Streams.
Utilisez les options de connexion suivantes pour les sources de données en streaming Kinesis :
+ `"streamARN"` (Obligatoire) Utilisé pour la lecture/l'écriture. ARN du flux de données Kinesis.
+ `"classification"` (Obligatoire pour la lecture) Utilisé pour la lecture. Format de fichier utilisé par les données de l'enregistrement. Obligatoire, sauf s’il est fourni par le catalogue de données.
+ `"streamName"` : (facultatif) utilisé pour la lecture. Nom du flux de données Kinesis à partir duquel lire. Utilisé avec `endpointUrl`.
+ `"endpointUrl"` : (facultatif) utilisé pour la lecture. Par défaut : « https://kinesis.us-east-1.amazonaws.com ». AWS Point de terminaison du flux Kinesis. Vous n'avez pas besoin de modifier ce paramètre, sauf si vous vous connectez à une région spéciale.
+ `"partitionKey"` : (facultatif) utilisé pour l'écriture. Clé de partition Kinesis utilisée lors de la production d'enregistrements.
+ `"delimiter"` : (facultatif) utilisé pour la lecture. Séparateur de valeurs utilisé lorsque `classification` est CSV. La valeur par défaut est « `,` ».
+ `"startingPosition"` : (facultatif) utilisé pour la lecture. La position de départ dans le flux de données Kinesis à partir duquel lire les données. Les valeurs possibles sont `"latest"`, `"trim_horizon"`, `"earliest"`, ou une chaîne d'horodatage au format UTC dans le modèle `yyyy-mm-ddTHH:MM:SSZ` (où `Z` représente un décalage de fuseau horaire UTC avec un \$1/-. Par exemple : « 2023-04-04T08:00:00-04:00 »). La valeur par défaut est `"latest"`. Remarque : la chaîne d'horodatage au format UTC pour n'`"startingPosition"`est prise en charge que pour la version 4.0 ou ultérieure de AWS Glue.
+ `"failOnDataLoss"` : (facultatif) échec de la tâche si une partition active est manquante ou a expiré. La valeur par défaut est `"false"`.
+ `"awsSTSRoleARN"` : (facultatif) utilisé pour la lecture/l'écriture. Le nom de ressource Amazon (ARN) du rôle à assumer en utilisant AWS Security Token Service (AWS STS). Ce rôle doit disposer des autorisations nécessaires pour décrire ou lire des registres pour le flux de données Kinesis. Vous devez utiliser ce paramètre lorsque vous accédez à un flux de données dans un autre compte. Utilisez conjointement avec `"awsSTSSessionName"`.
+ `"awsSTSSessionName"` : (facultatif) utilisé pour la lecture/l'écriture. Un identifiant de la séance assumant le rôle à l'aide d' AWS STS. Vous devez utiliser ce paramètre lorsque vous accédez à un flux de données dans un autre compte. Utilisez conjointement avec `"awsSTSRoleARN"`.
+ `"awsSTSEndpoint"`: (Facultatif) Le AWS STS point de terminaison à utiliser lors de la connexion à Kinesis avec un rôle assumé. Cela permet d'utiliser le point de AWS STS terminaison régional dans un VPC, ce qui n'est pas possible avec le point de terminaison global par défaut.
+ `"maxFetchTimeInMs"` : (facultatif) utilisé pour la lecture. Le temps maximal passé dans l’exécuteur de tâches pour lire des enregistrements du lot actuel à partir du flux de données Kinesis, exprimé en millisecondes (ms). Plusieurs appels d’API `GetRecords` peuvent être effectués pendant cette période. La valeur par défaut est `1000`.
+ `"maxFetchRecordsPerShard"` : (facultatif) utilisé pour la lecture. Nombre maximal d’enregistrements à récupérer par partition dans le flux de données Kinesis par microlot. Remarque : Le client peut dépasser cette limite si la tâche de streaming a déjà lu des enregistrements supplémentaires provenant de Kinesis (dans le même appel get-records). Si `maxFetchRecordsPerShard` doit être strict, il doit être un multiple de `maxRecordPerRead`. La valeur par défaut est `100000`.
+ `"maxRecordPerRead"` : (facultatif) utilisé pour la lecture. Nombre maximal d'enregistrements à extraire du flux de données Kinesis dans chaque opération `getRecords`. La valeur par défaut est `10000`.
+ `"addIdleTimeBetweenReads"` : (facultatif) utilisé pour la lecture. Ajoute un délai entre deux opérations `getRecords` consécutives. La valeur par défaut est `"False"`. Cette option n’est configurable que pour Glue version 2.0 et ultérieure.
+ `"idleTimeBetweenReadsInMs"` : (facultatif) utilisé pour la lecture. Délai minimum entre deux opérations `getRecords`, en ms. La valeur par défaut est `1000`. Cette option n’est configurable que pour Glue version 2.0 et ultérieure.
+ `"describeShardInterval"` : (facultatif) utilisé pour la lecture. Intervalle de temps minimum entre deux appels d'API `ListShards` pour que votre script envisage le repartitionnement. Pour plus d'informations, consultez [Politiques de repartitionnement](https://docs.aws.amazon.com//streams/latest/dev/kinesis-using-sdk-java-resharding-strategies.html) dans le *Guide du développeur Amazon Kinesis Data Streams*. La valeur par défaut est `1s`.
+ `"numRetries"` : (facultatif) utilisé pour la lecture. Le nombre maximal de nouvelles tentatives pour les demandes d'API Kinesis Data Streams. La valeur par défaut est `3`.
+ `"retryIntervalMs"` : (facultatif) utilisé pour la lecture. Le délai de réflexion (spécifié en ms) avant de réessayer l'appel d'API Kinesis Data Streams. La valeur par défaut est `1000`.
+ `"maxRetryIntervalMs"` : (facultatif) utilisé pour la lecture. Le délai d'attente maximal (spécifié en ms) entre deux tentatives d'appel d'API Kinesis Data Streams. La valeur par défaut est `10000`.
+ `"avoidEmptyBatches"` : (facultatif) utilisé pour la lecture. Évite de créer une tâche de micro-lot vide en vérifiant les données non lues dans le flux de données Kinesis avant le démarrage du lot. La valeur par défaut est `"False"`.
+ `"schema"` : (obligatoire lorsque inferSchema est défini sur false) utilisé pour la lecture. Schéma à utiliser pour traiter la charge utile. Si la classification est `avro`, le schéma fourni doit être au format de schéma Avro. Si la classification n'est pas `avro`, le schéma fourni doit être au format de schéma DDL.
Voici quelques exemples de schémas.
------
#### [ Example in DDL schema format ]
```
`column1` INT, `column2` STRING , `column3` FLOAT
```
------
#### [ Example in Avro schema format ]
```
{
"type":"array",
"items":
{
"type":"record",
"name":"test",
"fields":
[
{
"name":"_id",
"type":"string"
},
{
"name":"index",
"type":
[
"int",
"string",
"float"
]
}
]
}
}
```
------
+ `"inferSchema"` : (facultatif) utilisé pour la lecture. La valeur par défaut est « false ». S’il est défini sur « true », le schéma sera détecté lors de l’exécution à partir de la charge utile dans `foreachbatch`.
+ `"avroSchema"` : (obsolète) utilisé pour la lecture. Paramètre utilisé pour spécifier un schéma de données Avro lorsque le format Avro est utilisé. Ce paramètre est désormais obsolète. Utilisez le paramètre `schema`.
+ `"addRecordTimestamp"` : (facultatif) utilisé pour la lecture. Lorsque cette option est définie sur « true », la sortie de données contient une colonne supplémentaire nommée « \$1\$1src\$1timestamp » qui indique l'heure à laquelle l'enregistrement correspondant est reçu par le flux. La valeur par défaut est « false ». Cette option est prise en charge dans AWS Glue version 4.0 ou ultérieure.
+ `"emitConsumerLagMetrics"` : (facultatif) utilisé pour la lecture. Lorsque l'option est définie sur « vrai », pour chaque lot, elle émet les métriques correspondant à la durée comprise entre le plus ancien enregistrement reçu par le flux et l'heure AWS Glue à laquelle il arrive CloudWatch. Le nom de la métrique est « glue.driver.streaming ». maxConsumerLagInMs». La valeur par défaut est « false ». Cette option est prise en charge dans AWS Glue version 4.0 ou ultérieure.
+ `"fanoutConsumerARN"` : (facultatif) utilisé pour la lecture. ARN d'un consommateur de flux Kinesis pour le flux spécifié dans `streamARN`. Utilisé pour activer le mode diffusion améliorée pour votre connexion Kinesis. Pour plus d'informations sur la consommation d'un flux Kinesis avec diffusion améliorée, consultez [Utilisation de la diffusion améliorée dans les tâches de streaming Kinesis](aws-glue-programming-etl-connect-kinesis-efo.md).
+ `"recordMaxBufferedTime"` : (facultatif) utilisé pour l'écriture. Par défaut : 1 000 (ms). Durée maximale pendant laquelle un enregistrement est mis en mémoire tampon en attendant d'être écrit.
+ `"aggregationEnabled"` : (facultatif) utilisé pour l'écriture. Valeur par défaut : vraie. Spécifie si les enregistrements doivent être agrégés avant de les envoyer à Kinesis.
+ `"aggregationMaxSize"` : (facultatif) utilisé pour l'écriture. Par défaut : 51 200 (octets). Si un enregistrement est supérieur à cette limite, il contourne l'agrégateur. Remarque Kinesis impose une limite de 50 Ko à la taille des enregistrements. Si vous définissez ce paramètre au-delà de 50 Ko, les enregistrements surdimensionnés seront rejetés par Kinesis.
+ `"aggregationMaxCount"` : (facultatif) utilisé pour l'écriture. Par défaut : 4294967295. Nombre maximum de résultats à regrouper dans un enregistrement agrégé.
+ `"producerRateLimit"` : (facultatif) utilisé pour l'écriture. Par défaut : 150 (%). Limite le débit par partition envoyée par un seul producteur (votre tâche, par exemple), sous forme de pourcentage de la limite du backend.
+ `"collectionMaxCount"` : (facultatif) utilisé pour l'écriture. Par défaut : 500. Nombre maximum d'articles à inclure dans une PutRecords demande.
+ `"collectionMaxSize"` : (facultatif) utilisé pour l'écriture. Par défaut : 5242880 (octets). Quantité maximale de données à envoyer avec une PutRecords demande.
# Utilisation de la diffusion améliorée dans les tâches de streaming Kinesis
Un client bénéficiant de la diffusion améliorée est capable de recevoir des enregistrements provenant d'un flux Kinesis avec un débit dédié qui peut être supérieur à celui des consommateurs classiques. Cela se fait en optimisant le protocole de transfert utilisé pour fournir des données à un client Kinesis, tel que votre tâche. Pour plus d'informations sur la diffusion améliorée de Kinesis, consultez la [documentation Kinesis](https://docs.aws.amazon.com//streams/latest/dev/enhanced-consumers.html).
En mode de diffusion améliorée, les options de connexion `maxRecordPerRead` et `idleTimeBetweenReadsInMs` ne s'appliquent plus, car ces paramètres ne sont pas configurables lors de la diffusion améliorée. Les options de configuration pour les nouvelles tentatives fonctionnent comme décrit.
Utilisez les procédures suivantes pour activer et désactiver la diffusion améliorée pour votre tâche de streaming. Vous devez enregistrer un consommateur de flux pour chaque tâche qui consommera des données de votre flux.
**Pour activer la consommation de diffusion améliorée sur votre tâche :**
1. Enregistrez un consommateur de flux pour votre tâche à l'aide de l'API Kinesis. Suivez les instructions de la [documentation Kinesis](https://docs.aws.amazon.com//streams/latest/dev/building-enhanced-consumers-api) pour *enregistrer un consommateur avec une diffusion améliorée en utilisant à l'aide de l'API Kinesis Data Streams*. Il vous suffira de suivre la première étape : appeler [RegisterStreamConsumer](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_RegisterStreamConsumer.html). Votre demande doit renvoyer un ARN,*consumerARN*.
1. Définissez l'option de connexion `fanoutConsumerARN` sur *consumerARN* dans les arguments de votre méthode de connexion.
1. Redémarrez votre tâche.
**Pour désactiver la consommation de diffusion améliorée sur votre tâche :**
1. Supprimez l'option de connexion `fanoutConsumerARN` de votre appel de méthode.
1. Redémarrez votre tâche.
1. Suivez les instructions de la [documentation Kinesis](https://docs.aws.amazon.com/streams/latest/dev/building-enhanced-consumers-console.html) pour *annuler l'enregistrement d'un consommateur*. Ces instructions s'appliquent à la console, mais peuvent également être obtenues via l'API Kinesis. Pour plus d'informations sur la désinscription des utilisateurs de streaming via l'API Kinesis, consultez la documentation Kinesis. [DeregisterStreamConsumer](https://docs.aws.amazon.com//kinesis/latest/APIReference/API_DeregisterStreamConsumer.html)
# Connexions Amazon S3
Vous pouvez utiliser AWS Glue for Spark pour lire et écrire des fichiers dans Amazon S3. AWS Glue for Spark prend en charge de nombreux formats de données courants stockés dans Amazon S3 prêts à l'emploi, notamment CSV, Avro, JSON, Orc et Parquet. Pour de plus amples informations sur les formats de données pris en charge, consultez [Options de format pour les entrées et sorties dans AWS Glue pour Spark](aws-glue-programming-etl-format.md). Chaque format de données peut prendre en charge un ensemble différent de fonctionnalités de AWS Glue. Consultez la page de votre format de données pour connaître les spécificités de la prise en charge des fonctionnalités. En outre, vous pouvez lire et écrire des fichiers versionnés stockés dans les cadres de lacs de données Hudi, Iceberg et Delta Lake. Pour plus d'informations sur les cadres de lac de données, consultez [Utilisation de frameworks de lacs de données avec des tâches AWS Glue ETL](aws-glue-programming-etl-datalake-native-frameworks.md).
Avec AWS Glue, vous pouvez partitionner vos objets Amazon S3 dans une structure de dossiers pendant l'écriture, puis les récupérer par partition pour améliorer les performances grâce à une configuration simple. Vous pouvez également définir la configuration pour regrouper les petits fichiers lors de la transformation de vos données afin d'améliorer les performances. Vous pouvez lire et écrire des archives `bzip2` et `gzip` dans Amazon S3.
**Topics**
+ [
## Configuration de connexions S3
](#aws-glue-programming-etl-connect-s3-configure)
+ [
## Référence des options de connexion Amazon S3
](#aws-glue-programming-etl-connect-s3)
+ [
## Syntaxes de connexion obsolètes pour les formats de données
](#aws-glue-programming-etl-connect-legacy-format)
+ [
# Exclusion des classes de stockage Amazon S3
](aws-glue-programming-etl-storage-classes.md)
+ [
# Gestion des partitions pour la sortie ETL dans AWS Glue
](aws-glue-programming-etl-partitions.md)
+ [
# Lecture des fichiers en entrée dans des groupes de plus grande taille
](grouping-input-files.md)
+ [
# Types de points de terminaison d'un VPC pour Amazon S3
](vpc-endpoints-s3.md)
## Configuration de connexions S3
Pour vous connecter à Amazon S3 dans le cadre d'une tâche AWS Glue with Spark, vous aurez besoin de certaines conditions préalables :
+ La tâche AWS Glue doit disposer d'autorisations IAM pour les buckets Amazon S3 concernés.
Dans certains cas, vous devrez configurer des prérequis supplémentaires :
+ Lorsque vous configurez un accès intercompte, il convient de mettre en place des contrôles d'accès appropriés sur le compartiment Amazon S3.
+ Pour des raisons de sécurité, vous pouvez choisir d'acheminer vos requêtes Amazon S3 via un Amazon VPC. Cette approche peut engendrer des problèmes en matière de bande passante et de disponibilité. Pour de plus amples informations, veuillez consulter [Types de points de terminaison d'un VPC pour Amazon S3](vpc-endpoints-s3.md).
## Référence des options de connexion Amazon S3
Désigne une connexion à Amazon S3.
Comme Amazon S3 gère des fichiers plutôt que des tables, en plus de spécifier les propriétés de connexion fournies dans ce document, vous devrez indiquer une configuration supplémentaire concernant votre type de fichier. Vous indiquez ces informations par le biais des options de format de données. Pour plus d'informations sur ces options de format, consultez [Options de format pour les entrées et sorties dans AWS Glue pour Spark](aws-glue-programming-etl-format.md). Vous pouvez également spécifier ces informations en les intégrant au catalogue de données AWS Glue.
Pour illustrer la distinction entre les options de connexion et les options de format, considérez comment la méthode [create\$1dynamic\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options) utilise `connection_type`, `connection_options`, `format` et `format_options`. Cette section traite spécifiquement des paramètres fournis à `connection_options`.
Utilisez les options de connexion suivantes avec `"connectionType": "s3"` :
+ `"paths"` : (obligatoire) une liste de chemins Amazon S3 à lire.
+ `"exclusions"` : (Facultatif) Chaîne contenant une liste JSON des modèles glob de style Unix à exclure. Par exemple, `"[\"**.pdf\"]"` permet d'exclure tous les fichiers PDF. Pour plus d'informations sur la syntaxe glob qui prend en charge AWS Glue, consultez [Inclure et Exclure les modèles](https://docs.aws.amazon.com/glue/latest/dg/define-crawler.html#crawler-data-stores-exclude).
+ `"compressionType"` : ou « `compression` » : (facultatif) spécifie la manière dont les données sont comprimées. Utilisez `"compressionType"` pour les sources Amazon S3 et `"compression"` pour les cibles Amazon S3. Ce n'est généralement pas nécessaire si le fichier de données a une extension standard. Les valeurs possibles sont `"gzip"` et `"bzip2"`). Des formats de compression supplémentaires peuvent être pris en charge pour des formats spécifiques. Pour connaître les spécificités de la prise en charge des fonctionnalités, consultez la page sur le format des données.
+ `"groupFiles"` : (facultatif) le groupement de fichiers est activé par défaut lorsque l'entrée contient plus de 50 000 fichiers. Pour activer le groupement lorsqu'il y a moins de 50 000 fichiers, définissez ce paramètre sur `"inPartition"`. Pour désactiver le groupement lorsqu'il y a plus de 50 000 fichiers, définissez ce paramètre sur `"none"`.
+ `"groupSize"` : (Facultatif) Taille du groupe cible, en octets. La valeur par défaut est calculée en fonction de la dimension des données en entrée et de la dimension de votre cluster. Lorsqu'il y a moins de 50 000 fichiers en entrée, `"groupFiles"` doit être défini sur `"inPartition"` pour que cela prenne effet.
+ `"recurse"` : (Facultatif) Si ce paramètre est défini sur « true », les fichiers sont lus de manière récursive dans tous les sous-répertoires des chemins spécifiés.
+ `"maxBand"` : (facultatif, avancé) cette option permet de contrôler la durée, en millisecondes, au delà de laquelle la liste `s3` est susceptible d'être cohérente. Les fichiers dont l'horodatage de modification se situe dans les dernières `maxBand` millisecondes sont suivis lorsque des `JobBookmarks` sont utilisés pour prendre en compte une cohérence éventuelle Amazon S3. La plupart des utilisateurs n'ont pas besoin de définir cette option. La valeur par défaut est 900 000 millisecondes, soit 15 minutes.
+ `"maxFilesInBand"` : (Facultatif, avancé) Cette option spécifie le nombre maximal de fichiers à enregistrer à partir des dernières `maxBand` secondes. Si ce nombre est dépassé, les fichiers supplémentaires sont ignorés et traités dans l'exécution de tâche suivante. La plupart des utilisateurs n'ont pas besoin de définir cette option.
+ `"isFailFast"` : (facultatif) cette option détermine si une tâche ETL AWS Glue Glue lance des exceptions d'analyse de lecteur. Si elle est définie sur `true`, les tâches échouent rapidement si quatre tentatives de la tâche Spark échouent à analyser correctement les données.
+ `"catalogPartitionPredicate"` : (facultatif) utilisé pour la lecture. Le contenu d'une clause `WHERE` SQL. Utilisé lors de la lecture de tables du catalogue de données comportant un très grand nombre de partitions. Récupère les partitions correspondantes à partir des index du catalogue de données. Utilisé avec `push_down_predicate`, une option sur la méthode [create\$1dynamic\$1frame\$1from\$1catalog](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_catalog) (et d'autres méthodes similaires). Pour de plus amples informations, veuillez consulter [Filtrage côté serveur à l'aide de prédicats de partition de catalogue](aws-glue-programming-etl-partitions.md#aws-glue-programming-etl-partitions-cat-predicates).
+ `"partitionKeys"` : (facultatif) utilisé pour l'écriture. Un tableau de chaînes d'étiquettes de colonnes. AWS Glue partitionnera vos données conformément à cette configuration. Pour de plus amples informations, veuillez consulter [Écriture des partitions](aws-glue-programming-etl-partitions.md#aws-glue-programming-etl-partitions-writing).
+ `"excludeStorageClasses"` : (facultatif) utilisé pour la lecture. Tableau de chaînes spécifiant les classes de stockage Amazon S3. AWS Glue exclura les objets Amazon S3 en fonction de cette configuration. Pour de plus amples informations, veuillez consulter [Exclusion des classes de stockage Amazon S3](aws-glue-programming-etl-storage-classes.md).
## Syntaxes de connexion obsolètes pour les formats de données
Certains formats de données sont accessibles à l'aide d'une syntaxe de type de connexion spécifique. Cette syntaxe est obsolète. Nous vous recommandons de spécifier vos formats en utilisant le type de connexion `s3` et les options de format fournies dans [Options de format pour les entrées et sorties dans AWS Glue pour Spark](aws-glue-programming-etl-format.md) à la place.
### « connectionType » : « orc »
Désigne une connexion à des fichiers stockés dans Amazon S3 au format de fichier [Apache Hive Optimized Row Columnar (ORC)](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+ORC).
Utilisez les options de connexion suivantes avec `"connectionType": "orc"` :
+ `paths` : (obligatoire) une liste de chemins Amazon S3 à lire.
+ *(Autres name/value paires d'options)* : Toutes les options supplémentaires, y compris les options de formatage, sont transmises directement au SparkSQL`DataSource`.
### « connectionType » : « parquet »
Désigne une connexion aux fichiers stockés dans Amazon S3 au format de fichier [Apache Parquet](https://parquet.apache.org/docs/).
Utilisez les options de connexion suivantes avec `"connectionType": "parquet"` :
+ `paths` : (obligatoire) une liste de chemins Amazon S3 à lire.
+ *(Autres name/value paires d'options)* : Toutes les options supplémentaires, y compris les options de formatage, sont transmises directement au SparkSQL`DataSource`.
# Exclusion des classes de stockage Amazon S3
Si vous exécutez des tâches ETL AWS Glue qui lisent des fichiers ou des partitions à partir d'Amazon Simple Storage Service (Amazon S3), vous pouvez exclure certains types de classe de stockage Amazon S3.
Les classes de stockage suivantes sont disponibles dans Amazon S3 :
+ `STANDARD` — pour le stockage à usage général des données fréquemment consultées.
+ `INTELLIGENT_TIERING` — pour les données ayant des modèles d'accès inconnus ou variables.
+ `STANDARD_IA` et `ONEZONE_IA` — pour les données à longue durée de vie, mais consultées moins fréquemment.
+ `GLACIER`, `DEEP_ARCHIVE` et `REDUCED_REDUNDANCY` — pour l'archivage à long terme et la conservation numérique.
Pour de plus amples informations, veuillez consulter [Classes de stockage Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage-class-intro.html) dans le *Guide du développeur Amazon S3*.
Les exemples de cette section montrent comment exclure les classes de stockage `GLACIER` et `DEEP_ARCHIVE`. Ces classes vous permettent de répertorier les fichiers, mais ne vous permettent pas de les lire, sauf s'ils sont restaurés. (Pour de plus amples informations, veuillez consulter [Restauration d'objets archivés](https://docs.aws.amazon.com/AmazonS3/latest/dev/restoring-objects.html) dans le *Guide du développeur Amazon S3*.)
En utilisant les exclusions de classe de stockage, vous pouvez garantir que vos tâches AWS Glue fonctionnent sur les tables ayant des partitions sur ces niveaux de classe de stockage. Sans exclusion, les tâches qui lisent les données de ces niveaux échouent avec l'erreur suivante : AmazonS3Exception: The operation is not valid for the object's storage class (AmazonS3Exception : l'opération n'est pas valide pour la classe de stockage de l'objet).
Vous pouvez filtrer les classes de stockage Amazon S3 de différentes façons dans AWS Glue.
**Topics**
+ [
## Exclusion des classes de stockage Amazon S3 lors de la création d'une image dynamique
](#aws-glue-programming-etl-storage-classes-dynamic-frame)
+ [
## Exclusion de classes de stockage Amazon S3 d'une table Data Catalog
](#aws-glue-programming-etl-storage-classes-table)
## Exclusion des classes de stockage Amazon S3 lors de la création d'une image dynamique
Pour exclure les classes de stockage Amazon S3 lors de la création d'une image dynamique, utilisez `excludeStorageClasses` dans `additionalOptions`. AWS Glue utilise automatiquement sa propre implémentation de `Lister` Amazon S3 pour répertorier et exclure les fichiers correspondant aux classes de stockage spécifiées.
Les exemples Python et Scala suivants montrent comment exclure les classes de stockage `GLACIER` et `DEEP_ARCHIVE` lors de la création d'une image dynamique.
Exemple Python :
```
glueContext.create_dynamic_frame.from_catalog(
database = "my_database",
tableName = "my_table_name",
redshift_tmp_dir = "",
transformation_ctx = "my_transformation_context",
additional_options = {
"excludeStorageClasses" : ["GLACIER", "DEEP_ARCHIVE"]
}
)
```
Exemple Scala :
```
val* *df = glueContext.getCatalogSource(
nameSpace, tableName, "", "my_transformation_context",
additionalOptions = JsonOptions(
Map("excludeStorageClasses" -> List("GLACIER", "DEEP_ARCHIVE"))
)
).getDynamicFrame()
```
## Exclusion de classes de stockage Amazon S3 d'une table Data Catalog
Vous pouvez spécifier les exclusions de classe de stockage à utiliser par une tâche AWS Glue ETL en tant que paramètre de table dans le catalogue de données AWS Glue. Vous pouvez inclure ce paramètre dans l'`CreateTable`opération à l'aide du AWS Command Line Interface (AWS CLI) ou par programmation à l'aide de l'API. Pour plus d'informations, voir [Structure du tableau](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-tables.html#aws-glue-api-catalog-tables-Table) et [CreateTable](https://docs.aws.amazon.com/glue/latest/webapi/API_CreateTable.html).
Vous pouvez également spécifier des classes de stockage exclues sur la console AWS Glue.
**Pour exclure des classes de stockage Amazon S3 (console)**
1. Connectez-vous à la AWS Glue console AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Dans le panneau de navigation de gauche, sélectionnez **Tables**.
1. Choisissez le nom de la table dans la liste, puis choisissez **Modifier la table**.
1. Dans **Propriétés de la table**, ajoutez **excludeStorageClasses** en tant que clé et **[\$1"GLACIER\$1",\$1"DEEP\$1ARCHIVE\$1"]** en tant que valeur.
1. Cliquez sur **Appliquer**.
# Gestion des partitions pour la sortie ETL dans AWS Glue
Le partitionnement est une technique importante technique pour organiser les ensembles de données afin qu'ils puissent être interrogés de manière efficace. Il organise les données en une structure de répertoires hiérarchique fondée sur les valeurs distinctes d'une ou de plusieurs colonnes.
Par exemple, vous pouvez décider de partitionner vos journaux d'application dans Amazon Simple Storage Service (Amazon S3) par date, réparties par année, par mois et par jour. Les fichiers qui correspondent à une seule journée de données sont ensuite placés sous un préfixe, tel que `s3://my_bucket/logs/year=2018/month=01/day=23/`. Les systèmes comme Amazon Athena, Amazon Redshift Spectrum, et maintenant AWS Glue peuvent utiliser ces partitions pour filtrer les données en fonction de la valeur de partition, sans avoir à lire toutes les données sous-jacentes depuis Amazon S3.
Les robots d'exploration ne se contentent pas de déduire les types de fichiers et les schémas, ils identifient également automatiquement la structure de partition de votre ensemble de données lorsqu'ils alimentent le catalogue de données AWS Glue. Les colonnes de partition résultantes sont disponibles pour l'interrogation dans les tâches ETL AWS Glue ou les moteurs de requête tels qu'Amazon Athena.
Après avoir analysé une table, vous pouvez afficher les partitions créées par l'crawler. Dans la console AWS Glue, dans le panneau de navigation de gauche, sélectionnez **Tables**. Sélectionnez la table créée par l'crawler, puis **View partitions** (Afficher les partitions).
Pour les chemins partitionnés de style Apache Hive de type `key=val`, les crawlers remplissent automatiquement le nom de la colonne à l'aide du nom de clé. Sinon, ils utilisent des noms par défaut comme `partition_0`, `partition_1`, etc. Vous pouvez modifier les noms par défaut sur la console. Pour ce faire, accédez à la table. Vérifiez si des index existent sous l'onglet **Index**. Si tel est le cas, vous devez les supprimer pour continuer (vous pourrez ensuite les recréer en utilisant les nouveaux noms de colonnes). Choisissez ensuite **Modifier le schéma** et modifiez les noms des colonnes de partition qui s'y trouvent.
Dans vos scripts ETL, vous pouvez ensuite filtrer sur les colonnes de partition. Étant donné que les informations de partition sont stockées dans le catalogue de données, utilisez les appels d'API `from_catalog` pour inclure les colonnes de partition dans le fichier `DynamicFrame`. Par exemple, utilisez `create_dynamic_frame.from_catalog` plutôt que `create_dynamic_frame.from_options`.
Le partitionnement est une technique d'optimisation qui réduit l'analyse des données. Pour plus d'informations sur le processus permettant d'identifier le moment où cette technique est appropriée, consultez la section [Réduire la quantité de données analysées dans le guide](https://docs.aws.amazon.com/prescriptive-guidance/latest/tuning-aws-glue-for-apache-spark/reduce-data-scan.html) des *meilleures pratiques pour le réglage des performances de AWS Glue pour les tâches Apache Spark* sur le guide AWS prescriptif.
## Préfiltrage à l'aide des prédicats pushdown
Dans de nombreux cas, vous pouvez utiliser un prédicat pushdown pour filtrer les partitions sans avoir à répertorier et à lire tous les fichiers de votre ensemble de données. Au lieu de lire l'ensemble de données et de filtrer ensuite un DynamicFrame fichier, vous pouvez appliquer le filtre directement sur les métadonnées de partition dans le catalogue de données. Ensuite, vous ne listez et ne lisez que ce dont vous avez réellement besoin dans un DynamicFrame.
Par exemple, en Python, vous pouvez écrire ce qui suit.
```
glue_context.create_dynamic_frame.from_catalog(
database = "my_S3_data_set",
table_name = "catalog_data_table",
push_down_predicate = my_partition_predicate)
```
Cela crée un DynamicFrame qui charge uniquement les partitions du catalogue de données qui répondent à l'expression de prédicat. En fonction de la taille d'un sous-ensemble de vos données de chargement, vous pouvez économiser beaucoup de temps de traitement.
L'expression de prédicat peut être n'importe quelle expression booléenne prise en charge par Spark SQL. Tout ce que vous pouvez placer dans une clause `WHERE` d'une requête SQL Spark fonctionne. Par exemple, l'expression de prédicat `pushDownPredicate = "(year=='2017' and month=='04')"` charge uniquement les partitions dans Data Catalog qui disposent à la fois d'une `year` égale à 2017 et un `month` égal à 04. Pour plus d'informations, consultez la documentation [Apache Spark SQL](https://spark.apache.org/docs/2.1.1/sql-programming-guide.html), en particulier le document [Référence des fonctions Scala SQL](https://spark.apache.org/docs/2.1.1/api/scala/index.html#org.apache.spark.sql.functions$).
## Filtrage côté serveur à l'aide de prédicats de partition de catalogue
L'option `push_down_predicate` est appliquée après avoir répertorié toutes les partitions du catalogue et avant de répertorier les fichiers d'Amazon S3 pour ces partitions. Si vous disposez d'un grand nombre de partitions pour une table, la liste des partitions du catalogue peut encore entraîner une surcharge de temps supplémentaire. Pour remédier à cette surcharge, vous pouvez utiliser l'élagage des partitions côté serveur avec l'`catalogPartitionPredicate`option qui utilise les [index de partition dans](https://docs.aws.amazon.com/glue/latest/dg/partition-indexes.html) le catalogue de données Glue AWS . Cela accélère considérablement le filtrage des partitions lorsque vous avez des millions de partitions dans une table. Vous pouvez utiliser à la fois `push_down_predicate` et `catalogPartitionPredicate` dans `additional_options` si votre `catalogPartitionPredicate` a besoin d'une syntaxe de prédicat qui n'est pas encore prise en charge avec les index de partition de catalogue.
Python :
```
dynamic_frame = glueContext.create_dynamic_frame.from_catalog(
database=dbname,
table_name=tablename,
transformation_ctx="datasource0",
push_down_predicate="day>=10 and customer_id like '10%'",
additional_options={"catalogPartitionPredicate":"year='2021' and month='06'"}
)
```
Scala :
```
val dynamicFrame = glueContext.getCatalogSource(
database = dbname,
tableName = tablename,
transformationContext = "datasource0",
pushDownPredicate="day>=10 and customer_id like '10%'",
additionalOptions = JsonOptions("""{
"catalogPartitionPredicate": "year='2021' and month='06'"}""")
).getDynamicFrame()
```
**Note**
`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.
## Écriture des partitions
Par défaut, a n' DynamicFrame est pas partitionné lors de son écriture. Tous les fichiers de sortie sont écrits au niveau supérieur du chemin de sortie spécifié. Jusqu'à récemment, le seul moyen d'écrire un DynamicFrame dans des partitions était de le convertir en SQL Spark DataFrame avant de l'écrire.
Cependant, vous pouvez DynamicFrames désormais prendre en charge le partitionnement natif à l'aide d'une séquence de clés, en utilisant l'`partitionKeys`option lorsque vous créez un récepteur. Par exemple, le code Python suivant écrit un ensemble de données sur Amazon S3 au format Parquet, dans les répertoires partitionnés par le type de champ. À partir de là, vous pouvez traiter ces partitions à l'aide d'autres systèmes, comme Amazon Athena.
```
glue_context.write_dynamic_frame.from_options(
frame = projectedEvents,
connection_type = "s3",
connection_options = {"path": "$outpath", "partitionKeys": ["type"]},
format = "parquet")
```
# Lecture des fichiers en entrée dans des groupes de plus grande taille
Vous pouvez définir les propriétés de vos tables pour activer une tâche ETL AWS Glue regroupant les fichiers lorsqu'ils sont lus à partir d'un magasin de données Amazon S3. Ces propriétés permettent à chaque tâche ETL de lire un groupe de fichiers d'entrée en une seule partition en mémoire, ce qui est particulièrement utile lorsqu'il y a un grand nombre de petits fichiers dans votre magasin de données Amazon S3. Lorsque vous définissez certaines propriétés, vous demandez à AWS Glue de regrouper les fichiers au sein d'une partition de données Amazon S3 et de définir la taille des groupes à lire. Vous pouvez également définir ces options lors de la lecture à partir d'un magasin de données Amazon S3 avec la méthode `create_dynamic_frame.from_options`.
Pour activer le regroupement de fichiers pour une table, vous définissez les paires clé-valeur dans le champ des paramètres de la structure de votre table. Utilisez la notation JSON pour définir une valeur pour le champ des paramètres de votre table. Pour plus d'informations sur la modification des propriétés d'une table, consultez [Affichage et gestion des détails d’une table](tables-described.md#console-tables-details).
Vous pouvez utiliser cette méthode pour activer le regroupement des tables dans Data Calalog avec les magasins de données Amazon S3.
**groupFiles**
Définissez **groupFiles** sur `inPartition` afin d'activer le regroupement de fichiers au sein d'une partition de données Amazon S3. AWS Glue active automatiquement le regroupement s'il y a plus de 50 000 fichiers d'entrée, comme dans l'exemple suivant.
```
'groupFiles': 'inPartition'
```
**groupSize**
Définissez **groupSize** sur la taille cible des groupes en octets. La propriété **groupSize** est facultative. Si aucune valeur n'est définie, AWS Glue calcule une taille pour utiliser tous les cœurs d'UC dans le cluster tout en réduisant le nombre total de tâches ETL et les partitions en mémoire.
Par exemple, ce qui suit définit une taille de groupe de 1 Mo.
```
'groupSize': '1048576'
```
Notez que le `groupsize` doit être défini avec le résultat d'un calcul. Par exemple, 1024 \$1 1024 = 1048576.
**recurse**
Définissez **recurse (récursif)** à `True` pour lire les fichiers de manière récursive dans tous les sous-répertoires lorsque vous spécifiez `paths` en tant que liste de chemins. Vous n'avez pas besoin de définir **recurse** si `paths` est un tableau de clés d'objet dans Amazon S3, ou si le format d'entrée est parquet/orc, comme dans l'exemple suivant.
```
'recurse':True
```
Si vous lisez à partir d'Amazon S3 directement à l'aide de la méthode `create_dynamic_frame.from_options`, ajoutez ces options de connexion. Par exemple, ce qui suit tente de placer les fichiers par groupes de 1 Mo.
```
df = glueContext.create_dynamic_frame.from_options("s3", {'paths': ["s3://s3path/"], 'recurse':True, 'groupFiles': 'inPartition', 'groupSize': '1048576'}, format="json")
```
**Note**
`groupFiles`est pris en charge pour les formats de données DynamicFrames créés à partir des formats de données suivants : csv, ion, GrokLog, json et xml. Cette option n'est pas prise en charge pour avro, parquet et orc.
# Types de points de terminaison d'un VPC pour Amazon S3
Pour des raisons de sécurité, de nombreux AWS clients exécutent leurs applications dans un environnement Amazon Virtual Private Cloud (Amazon VPC). Avec Amazon VPC, vous pouvez lancer des EC2 instances Amazon dans un cloud privé virtuel, qui est logiquement isolé des autres réseaux, y compris de l'Internet public. Avec un VPC Amazon, vous contrôlez sa plage d’adresses IP, ses sous-réseaux, ses tables de routage, ses passerelles réseau et ses paramètres de sécurité.
**Note**
Si vous avez créé votre AWS compte après le 04/12/2013, vous disposez déjà d'un VPC par défaut dans chaque région. AWS Vous pouvez commencer immédiatement à utiliser votre VPC par défaut sans configuration supplémentaire.
Pour plus d'informations, veuillez consulter [Vos VPC et sous-réseaux par défaut](https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html) dans le Guide de l'utilisateur Amazon VPC.
De nombreux clients ont des préoccupations légitimes liées à la confidentialité et la sécurité lors de l’envoi et de la réception de données via le réseau Internet public. Les clients peuvent faire face à ces préoccupations en utilisant un réseau VPN pour acheminer l'ensemble du trafic réseau d'Amazon S3 via leur propre infrastructure réseau d'entreprise. Toutefois, cette approche peut engendrer des problèmes en matière de bande passante et de disponibilité.
Les points de terminaison d'un VPC pour Amazon S3 peuvent atténuer ces problèmes. Un point de terminaison d'un VPC pour Amazon S3 permet à AWS Glue d'utiliser des adresses IP privées pour accéder à Amazon S3 sans exposition au réseau Internet public. AWS Glue ne nécessite pas d'adresses IP publiques et vous n'avez pas besoin de passerelle Internet, de périphérique NAT ou de passerelle réseau privé virtuel dans votre VPC. Vous utilisez des politiques de point de terminaison pour contrôler l'accès à Amazon S3. Le trafic entre votre VPC et le AWS service ne quitte pas le réseau Amazon.
Lorsque vous créez un point de terminaison d'un VPC pour Amazon S3, toutes les demandes envoyées à un point de terminaison Amazon S3 au sein de la région (par exemple, *s3.us-west-2.amazonaws.com*) sont acheminées vers un point de terminaison Amazon S3 privé dans le réseau Amazon. Vous n'avez pas besoin de modifier vos applications exécutées sur les EC2 instances Amazon de votre VPC : le nom du point de terminaison reste le même, mais le chemin vers Amazon S3 reste entièrement au sein du réseau Amazon et n'accède pas à l'Internet public.
Pour plus d'informations sur les points de terminaison d'un VPC, veuillez consulter [Points de terminaison d'un VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints.html) dans le Guide de l'utilisateur Amazon VPC.
Le diagramme suivant montre comment AWS Glue peut utiliser un point de terminaison d'un VPC pour accéder à Amazon S3.
![\[Flux de trafic réseau montrant une connexion VPC vers Amazon S3.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/PopulateCatalog-vpc-endpoint.png)
**Pour configurer l'accès à Amazon S3**
1. Connectez-vous à la console Amazon VPC AWS Management Console et ouvrez-la à l'adresse. [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/)
1. Dans le panneau de navigation de gauche, sélectionnez **Points de terminaison**.
1. Sélectionnez **Create Endpoint (Créer un point de terminaison)** et suivez les étapes pour créer un point de terminaison d'un VPC Amazon S3 de type Passerelle.
# Connexions Amazon DocumentDB
Vous pouvez utiliser AWS Glue for Spark pour lire et écrire dans des tables d'Amazon DocumentDB. Vous pouvez vous connecter à Amazon DocumentDB à l'aide des informations d'identification enregistrées AWS Secrets Manager via une connexion AWS Glue.
Pour plus d’informations sur Amazon DocumentDB, consultez la [documentation Amazon DocumentDB](https://docs.aws.amazon.com/documentdb/latest/developerguide/what-is.html).
**Note**
Les clusters élastiques Amazon DocumentDB ne sont actuellement pas pris en charge lors de l'utilisation du connecteur AWS Glue. Pour plus d'informations sur les clusters élastiques, consultez [Using Amazon DocumentDB elastic clusters](https://docs.aws.amazon.com/documentdb/latest/developerguide/docdb-using-elastic-clusters.html).
## Lecture et écriture dans les collections Amazon DocumentDB
**Note**
Lorsque vous créez une tâche ETL qui se connecte à Amazon DocumentDB pour la propriété de tâche `Connections`, vous devez désigner un objet de connexion qui spécifie le virtual private cloud (VPC) dans lequel Amazon DocumentDB est exécuté. Pour l'objet de connexion, le type de connexion doit être `JDBC` et le `JDBC URL` doit être `mongo://:27017`.
**Note**
Ces exemples de code ont été développés pour AWS Glue 3.0. Pour migrer vers AWS Glue 4.0, consultez[MongoDB](migrating-version-40.md#migrating-version-40-connector-driver-migration-mongodb). Le paramètre `uri` a été modifié.
**Note**
Lorsque vous utilisez Amazon DocumentDB, le paramètre `retryWrites` doit être défini sur false dans certaines situations, par exemple lorsque le document écrit spécifie `_id`. Pour plus d’informations, consultez [Différences fonctionnelles avec MongoDB](https://docs.aws.amazon.com/documentdb/latest/developerguide/functional-differences.html#functional-differences.retryable-writes) dans la documentation Amazon DocumentDB.
Le script Python suivant illustre l’utilisation des types et des options de connexion pour la lecture et l’écriture dans Amazon DocumentDB.
```
import sys
from awsglue.transforms import *
from awsglue.utils import getResolvedOptions
from pyspark.context import SparkContext, SparkConf
from awsglue.context import GlueContext
from awsglue.job import Job
import time
## @params: [JOB_NAME]
args = getResolvedOptions(sys.argv, ['JOB_NAME'])
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
job = Job(glueContext)
job.init(args['JOB_NAME'], args)
output_path = "s3://some_bucket/output/" + str(time.time()) + "/"
documentdb_uri = "mongodb://:27017"
documentdb_write_uri = "mongodb://:27017"
read_docdb_options = {
"uri": documentdb_uri,
"database": "test",
"collection": "coll",
"username": "username",
"password": "1234567890",
"ssl": "true",
"ssl.domain_match": "false",
"partitioner": "MongoSamplePartitioner",
"partitionerOptions.partitionSizeMB": "10",
"partitionerOptions.partitionKey": "_id"
}
write_documentdb_options = {
"retryWrites": "false",
"uri": documentdb_write_uri,
"database": "test",
"collection": "coll",
"username": "username",
"password": "pwd"
}
# Get DynamicFrame from DocumentDB
dynamic_frame2 = glueContext.create_dynamic_frame.from_options(connection_type="documentdb",
connection_options=read_docdb_options)
# Write DynamicFrame to MongoDB and DocumentDB
glueContext.write_dynamic_frame.from_options(dynamic_frame2, connection_type="documentdb",
connection_options=write_documentdb_options)
job.commit()
```
Le script Scala suivant illustre l’utilisation des types et des options de connexion pour la lecture et l’écriture dans Amazon DocumentDB.
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.MappingSpec
import com.amazonaws.services.glue.errors.CallSite
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.DynamicFrame
import org.apache.spark.SparkContext
import scala.collection.JavaConverters._
object GlueApp {
val DOC_URI: String = "mongodb://:27017"
val DOC_WRITE_URI: String = "mongodb://:27017"
lazy val documentDBJsonOption = jsonOptions(DOC_URI)
lazy val writeDocumentDBJsonOption = jsonOptions(DOC_WRITE_URI)
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
// Get DynamicFrame from DocumentDB
val resultFrame2: DynamicFrame = glueContext.getSource("documentdb", documentDBJsonOption).getDynamicFrame()
// Write DynamicFrame to DocumentDB
glueContext.getSink("documentdb", writeJsonOption).writeDynamicFrame(resultFrame2)
Job.commit()
}
private def jsonOptions(uri: String): JsonOptions = {
new JsonOptions(
s"""{"uri": "${uri}",
|"database":"test",
|"collection":"coll",
|"username": "username",
|"password": "pwd",
|"ssl":"true",
|"ssl.domain_match":"false",
|"partitioner": "MongoSamplePartitioner",
|"partitionerOptions.partitionSizeMB": "10",
|"partitionerOptions.partitionKey": "_id"}""".stripMargin)
}
}
```
## Référence des options de connexion Amazon DocumentDB
Désigne une connexion à Amazon DocumentDB (compatible avec MongoDB).
Les options de connexion sont différentes pour une connexion source et une connexion collecteur.
### « connectionType »: « documentdb » comme cource
Utilisez les options de connexion suivantes avec `"connectionType": "documentdb"` comme source :
+ `"uri"` : (obligatoire) hôte Amazon DocumentDB à lire, dans le format `mongodb://:`.
+ `"database"` : (obligatoire) base de données Amazon DocumentDB à lire.
+ `"collection"` : (obligatoire) collection Amazon DocumentDB à lire.
+ `"username"` : (obligatoire) nom d'utilisateur Amazon DocumentDB.
+ `"password"` : (obligatoire) mot de passe Amazon DocumentDB.
+ `"ssl"` : (obligatoire si vous utilisez SSL) si votre connexion utilise SSL, vous devez inclure cette option avec la valeur `"true"`.
+ `"ssl.domain_match"` : (obligatoire si vous utilisez SSL) si votre connexion utilise SSL, vous devez inclure cette option avec la valeur `"false"`.
+ `"batchSize"` : (Facultatif) : Nombre de documents à renvoyer par lot, utilisé dans le curseur des lots internes.
+ `"partitioner"` : (facultatif) : nom de classe de l'outil du partitionneur pour lire les données d'entrée à partir d'Amazon DocumentDB. Le connecteur fournit les partitionneurs suivants :
+ `MongoDefaultPartitioner`(par défaut) (Non pris en charge dans AWS Glue 4.0)
+ `MongoSamplePartitioner`(Non pris en charge dans AWS Glue 4.0)
+ `MongoShardedPartitioner`
+ `MongoSplitVectorPartitioner`
+ `MongoPaginateByCountPartitioner`
+ `MongoPaginateBySizePartitioner`(Non pris en charge dans AWS Glue 4.0)
+ `"partitionerOptions"` ( Facultatif) : Options pour le partitionneur désigné. Les options suivantes sont prises en charge pour chaque partitionneur :
+ `MongoSamplePartitioner`: `partitionKey`, `partitionSizeMB`, `samplesPerPartition`
+ `MongoShardedPartitioner`: `shardkey`
+ `MongoSplitVectorPartitioner` : `partitionKey`, partitionSizeMB
+ `MongoPaginateByCountPartitioner`: `partitionKey`, `numberOfPartitions`
+ `MongoPaginateBySizePartitioner` : `partitionKey`, partitionSizeMB
Pour plus d'informations sur ces options, consultez [Configuration du partitionneur](https://docs.mongodb.com/spark-connector/master/configuration/#partitioner-conf) dans la documentation MongoDB.
### « connectionType »: « documentdb » comme collecteur
Utilisez les options de connexion suivantes avec `"connectionType": "documentdb"` comme collecteur :
+ `"uri"` : (obligatoire) hôte Amazon DocumentDB où écrire, dans le format `mongodb://:`.
+ `"database"` : (obligatoire) base de données Amazon DocumentDB où écrire.
+ `"collection"` : (obligatoire) collection Amazon DocumentDB où écrire.
+ `"username"` : (obligatoire) nom d'utilisateur Amazon DocumentDB.
+ `"password"` : (obligatoire) mot de passe Amazon DocumentDB.
+ `"extendedBsonTypes"` : (facultatif) si la valeur est `true`, cela autorise les types BSON étendus lors de l'écriture de données dans Amazon DocumentDB. La valeur par défaut est `true`.
+ `"replaceDocument"` : (Facultatif) Si `true`, remplace l'ensemble du document lors de l'enregistrement de jeux de données contenant un champ `_id`. Si `false`, seuls les champs du document qui correspondent aux champs du jeu de données sont mis à jour. La valeur par défaut est `true`.
+ `"maxBatchSize"` : (Facultatif) : Taille maximale du lot pour les opérations en bloc lors de l'enregistrement des données. La valeur par défaut est 512.
+ `"retryWrites"`: (Facultatif) : Réessayez automatiquement certaines opérations d'écriture une seule fois si AWS Glue rencontre une erreur réseau.
# OpenSearch Connexions de service
Vous pouvez utiliser AWS Glue for Spark pour lire et écrire dans des tables dans OpenSearch Service in AWS Glue 4.0 et versions ultérieures. Vous pouvez définir ce qu'il faut lire dans OpenSearch Service à l'aide d'une OpenSearch requête. Vous vous connectez au OpenSearch Service à l'aide des informations d'authentification HTTP de base stockées AWS Secrets Manager via une connexion AWS Glue. Cette fonctionnalité n'est pas compatible avec le OpenSearch Service serverless.
Pour plus d'informations sur Amazon OpenSearch Service, consultez la [documentation Amazon OpenSearch Service](https://docs.aws.amazon.com/opensearch-service/).
## Configuration des connexions OpenSearch de service
Pour vous connecter à OpenSearch Service from AWS Glue, vous devez créer et stocker vos identifiants de OpenSearch service dans un AWS Secrets Manager secret, puis associer ce secret à une connexion OpenSearch Service AWS Glue.
**Prérequis :**
+ Identifiez le point de terminaison *aosEndpoint* et le port du domaine que *aosPort* vous souhaitez consulter, ou créez la ressource en suivant les instructions de la documentation Amazon OpenSearch Service. Pour plus d'informations sur la création d'un domaine, consultez [la section Création et gestion OpenSearch de domaines Amazon Service](https://docs.aws.amazon.com//opensearch-service/latest/developerguide/createupdatedomains.html) dans la documentation Amazon OpenSearch Service.
Un point de terminaison de domaine Amazon OpenSearch Service aura le formulaire par défaut suivant, https://search - *domainName* -*unstructuredIdContent*. *region*.es.amazonaws.com. Pour plus d'informations sur l'identification du point de terminaison de votre domaine, consultez la section [Création et gestion des domaines Amazon OpenSearch Service](https://docs.aws.amazon.com//opensearch-service/latest/developerguide/createupdatedomains.html) dans la documentation Amazon OpenSearch Service.
Identifiez ou générez des informations d'authentification HTTP de base, *aosUser* et *aosPassword* pour votre domaine.
**Pour configurer une connexion au OpenSearch service :**
1. Dans AWS Secrets Manager, créez un secret à l'aide de vos informations d'identification OpenSearch de service. Pour créer un secret dans Secrets Manager, suivez le didacticiel disponible dans la [section Créer un AWS Secrets Manager secret](https://docs.aws.amazon.com//secretsmanager/latest/userguide/create_secret.html) dans la AWS Secrets Manager documentation. Après avoir créé le secret, conservez le nom du secret *secretName* pour l'étape suivante.
+ Lorsque vous sélectionnez des **paires clé/valeur**, créez une paire pour la clé `USERNAME` contenant la valeur. *aosUser*
+ Lorsque vous sélectionnez des **paires clé/valeur**, créez une paire pour la clé `PASSWORD` contenant la valeur. *aosPassword*
1. Dans la console AWS Glue, créez une connexion en suivant les étapes décrites dans[Ajouter une AWS Glue connexion](console-connections.md). Après avoir créé la connexion, conservez le nom de la connexion pour une utilisation future dans AWS Glue. *connectionName*
+ Lorsque vous sélectionnez un **type de connexion**, sélectionnez OpenSearch Service.
+ Lorsque vous sélectionnez un point de terminaison de domaine, fournissez*aosEndpoint*.
+ Lorsque vous sélectionnez un port, indiquez*aosPort*.
+ Lorsque vous sélectionnez un **AWS secret**, fournissez*secretName*.
Après avoir créé une connexion AWS Glue OpenSearch Service, vous devez suivre les étapes suivantes avant d'exécuter votre tâche AWS Glue :
+ Accordez au rôle IAM associé à votre tâche AWS Glue l'autorisation de lire*secretName*.
+ Dans la configuration de votre tâche AWS Glue*connectionName*, fournissez une **connexion réseau supplémentaire**.
## Lecture à partir des index OpenSearch de service
**Prérequis :**
+ Un index des OpenSearch services que vous aimeriez lire,*aosIndex*.
+ Une connexion AWS Glue OpenSearch Service configurée pour fournir des informations d'authentification et de localisation réseau. Pour cela, suivez les étapes de la procédure précédente, *Pour configurer une connexion au OpenSearch service*. Vous aurez besoin du nom de la connexion AWS Glue,*connectionName*.
Cet exemple lit un index provenant d'Amazon OpenSearch Service. Vous devrez fournir le paramètre `pushdown`.
Par exemple :
```
opensearch_read = glueContext.create_dynamic_frame.from_options(
connection_type="opensearch",
connection_options={
"connectionName": "connectionName",
"opensearch.resource": "aosIndex",
"pushdown": "true",
}
)
```
Vous pouvez également fournir une chaîne de requête pour filtrer les résultats renvoyés dans votre DynamicFrame. Vous devrez configurer `opensearch.query`.
`opensearch.query`peut prendre une chaîne de paramètres de requête URL *queryString* ou un objet *queryObject* JSON DSL de requête. Pour plus d'informations sur la requête DSL, consultez la section [Requête DSL](https://opensearch.org/docs/latest/query-dsl/index/) dans la OpenSearch documentation. Pour fournir une chaîne de paramètres de requête URL, ajoutez `?q=` à votre requête, comme vous le feriez pour une URL complète. Pour fournir un objet de requête DSL, échapper une chaîne objet JSON avant de le fournir.
Par exemple :
```
queryObject = "{ "query": { "multi_match": { "query": "Sample", "fields": [ "sample" ] } } }"
queryString = "?q=queryString"
opensearch_read_query = glueContext.create_dynamic_frame.from_options(
connection_type="opensearch",
connection_options={
"connectionName": "connectionName",
"opensearch.resource": "aosIndex",
"opensearch.query": queryString,
"pushdown": "true",
}
)
```
Pour plus d'informations sur la façon de créer une requête en dehors de sa syntaxe spécifique, consultez la section [Syntaxe des chaînes de requête](https://opensearch.org/docs/latest/query-dsl/full-text/query-string/#query-string-syntax) dans la OpenSearch documentation.
Lorsque vous lisez des OpenSearch collections contenant des données de type tableau, vous devez spécifier quels champs sont de type tableau dans votre appel de méthode à l'aide du `opensearch.read.field.as.array.include` paramètre.
Par exemple, en lisant le document suivant, vous rencontrerez les champs `genre` et `actor` du tableau :
```
{
"_index": "movies",
"_id": "2",
"_version": 1,
"_seq_no": 0,
"_primary_term": 1,
"found": true,
"_source": {
"director": "Frankenheimer, John",
"genre": [
"Drama",
"Mystery",
"Thriller",
"Crime"
],
"year": 1962,
"actor": [
"Lansbury, Angela",
"Sinatra, Frank",
"Leigh, Janet",
"Harvey, Laurence",
"Silva, Henry",
"Frees, Paul",
"Gregory, James",
"Bissell, Whit",
"McGiver, John",
"Parrish, Leslie",
"Edwards, James",
"Flowers, Bess",
"Dhiegh, Khigh",
"Payne, Julie",
"Kleeb, Helen",
"Gray, Joe",
"Nalder, Reggie",
"Stevens, Bert",
"Masters, Michael",
"Lowell, Tom"
],
"title": "The Manchurian Candidate"
}
}
```
Dans ce cas, vous devez inclure les noms de ces champs dans votre appel de méthode. Par exemple :
```
"opensearch.read.field.as.array.include": "genre,actor"
```
Si votre champ de tableau est imbriqué dans la structure de votre document, faites-y référence en utilisant la notation par points : `"genre,actor,foo.bar.baz"`. Cela permet de spécifier un tableau `baz` inclus dans votre document source par le biais du document intégré `foo` contenant le document intégré `bar`.
## Écrire dans les tables OpenSearch de service
Cet exemple écrit les informations d'un fichier existant DynamicFrame *dynamicFrame* dans le OpenSearch Service. Si l'index contient déjà des informations, AWS Glue ajoutera les données de votre DynamicFrame. Vous devrez fournir le paramètre `pushdown`.
**Prérequis :**
+ Une table de OpenSearch service à laquelle vous souhaitez écrire. Vous aurez besoin des informations d'identification de la table. Appelons ça*tableName*.
+ Une connexion AWS Glue OpenSearch Service configurée pour fournir des informations d'authentification et de localisation réseau. Pour cela, suivez les étapes de la procédure précédente, *Pour configurer une connexion au OpenSearch service*. Vous aurez besoin du nom de la connexion AWS Glue,*connectionName*.
Par exemple :
```
glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type="opensearch",
connection_options={
"connectionName": "connectionName",
"opensearch.resource": "aosIndex",
},
)
```
## OpenSearch Référence des options de connexion au service
+ `connectionName` — Obligatoire. Utilisé pour la lecture/l'écriture. Nom d'une connexion AWS Glue OpenSearch Service configurée pour fournir des informations d'authentification et de localisation réseau à votre méthode de connexion.
+ `opensearch.resource` — Obligatoire. Utilisé pour la lecture/l'écriture. Valeurs valides : noms d' OpenSearch index. Le nom de l'index avec lequel votre méthode de connexion va interagir.
+ `opensearch.query` : utilisé pour la lecture. Valeurs valides : chaîne JSON échappée ou, lorsque cette chaîne commence par `?`, la partie de recherche d'une URL. Une OpenSearch requête qui filtre ce qui doit être récupéré lors de la lecture. Pour plus d'informations sur l'utilisation de ce paramètre, consultez la section précédente [Lecture à partir des index OpenSearch de service](#aws-glue-programming-etl-connect-opensearch-read).
+ `pushdown` — Obligatoire si. Utilisé pour la lecture. Valeurs valides : booléen. Demande à Spark de transmettre les requêtes de lecture OpenSearch afin que la base de données ne renvoie que les documents pertinents.
+ `opensearch.read.field.as.array.include` : obligatoire en cas de lecture de données de type tableau. Utilisé pour la lecture. Valeurs valides : listes de noms de champs séparés par des virgules. Spécifie les champs à lire sous forme de tableaux à partir de OpenSearch documents. Pour plus d'informations sur l'utilisation de ce paramètre, consultez la section précédente [Lecture à partir des index OpenSearch de service](#aws-glue-programming-etl-connect-opensearch-read).
# Connexions Redshift
Vous pouvez utiliser AWS Glue for Spark pour lire et écrire dans les tables des bases de données Amazon Redshift. Lors de la connexion aux bases de données Amazon Redshift, AWS Glue déplace les données via Amazon S3 pour atteindre un débit maximal, en utilisant le code SQL et les commandes Amazon Redshift. `COPY` `UNLOAD` Dans AWS Glue 4.0 et versions ultérieures, vous pouvez utiliser l'[intégration Amazon Redshift pour Apache Spark pour](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html) lire et écrire avec des optimisations et des fonctionnalités spécifiques à Amazon Redshift, au-delà de celles disponibles lors de la connexion via les versions précédentes.
Découvrez comment AWS Glue facilite plus que jamais la migration des utilisateurs d'Amazon Redshift vers AWS Glue pour l'intégration des données sans serveur et l'ETL.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/ZapycBq8TKU)
## Configuration des connexions Redshift
Pour utiliser les clusters Amazon Redshift dans AWS Glue, vous devez remplir certaines conditions préalables :
+ Un répertoire Amazon S3 à utiliser pour le stockage temporaire lors de la lecture et de l'écriture dans la base de données.
+ Un Amazon VPC permettant la communication entre votre cluster Amazon Redshift, votre tâche AWS Glue et votre répertoire Amazon S3.
+ Autorisations IAM appropriées sur le job AWS Glue et le cluster Amazon Redshift.
### Configuration des rôles IAM
**Configurer le rôle pour le cluster Amazon Redshift**
Votre cluster Amazon Redshift doit être capable de lire et d'écrire sur Amazon S3 pour pouvoir s'intégrer aux tâches AWS Glue. Pour autoriser cela, vous pouvez associer des rôles IAM au cluster Amazon Redshift auquel vous souhaitez vous connecter. Votre rôle doit disposer d'une politique autorisant la lecture et l'écriture dans votre répertoire temporaire Amazon S3. Votre rôle doit avoir une relation de confiance permettant au service `redshift.amazonaws.com` de `AssumeRole`.
**Pour associer un rôle IAM à Amazon Redshift**
1. **Conditions préalables :** un compartiment ou un répertoire Amazon S3 utilisé pour le stockage temporaire de fichiers.
1. Identifiez les autorisations Amazon S3 dont votre cluster Amazon Redshift aura besoin. Lors du déplacement de données vers et depuis un cluster Amazon Redshift, les tâches AWS Glue émettent des instructions COPY et UNLOAD à l'encontre d'Amazon Redshift. Si votre tâche modifie une table dans Amazon Redshift, AWS Glue émettra également des instructions CREATE LIBRARY. Pour plus d'informations sur les autorisations Amazon S3 spécifiques requises pour qu'Amazon Redshift exécute ces instructions, consultez la documentation Amazon Redshift : [Amazon Redshift :](https://docs.aws.amazon.com/redshift/latest/dg/copy-usage_notes-access-permissions.html) Permissions to access other Resources. AWS
1. Dans la console IAM, créez une politique IAM avec les autorisations nécessaires. Pour plus d'informations sur la création de politiques, consultez [Création de politiques IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html).
1. Dans la console IAM, créez un rôle et une relation de confiance permettant à Amazon Redshift d'assumer ce rôle. Suivez les instructions de la documentation IAM [pour créer un rôle pour un AWS service (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html#roles-creatingrole-service-console)
+ Lorsqu'on vous demande de choisir un cas d'utilisation du AWS service, choisissez « Redshift - Personnalisable ».
+ Lorsque vous êtes invité à joindre une politique, choisissez celle que vous avez définie précédemment.
**Note**
Pour plus d'informations sur la configuration des rôles pour Amazon Redshift, consultez la section [Autoriser Amazon Redshift à accéder à d'autres AWS services en votre nom dans la](https://docs.aws.amazon.com/redshift/latest/mgmt/authorizing-redshift-service.html) documentation Amazon Redshift.
1. Dans la console Amazon Redshift, associez le rôle à votre cluster Amazon Redshift. Suivez les instructions de la [documentation Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/copy-unload-iam-role.html).
Sélectionnez l'option en surbrillance dans la console Amazon Redshift pour configurer ce paramètre :
![\[Un exemple de l'endroit où gérer les autorisations IAM dans la console Amazon Redshift.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/RS-role-config.png)
**Note**
Par défaut, les tâches AWS Glue transmettent les informations d'identification temporaires Amazon Redshift créées à l'aide du rôle que vous avez spécifié pour exécuter la tâche. Nous vous déconseillons d'utiliser ces informations d'identification. Pour des raisons de sécurité, ces informations d'identification expirent au bout d'une heure.
**Configuration du rôle pour la tâche AWS Glue**
La tâche AWS Glue a besoin d'un rôle pour accéder au compartiment Amazon S3. Vous n'avez pas besoin d'autorisations IAM pour le cluster Amazon Redshift. Votre accès est contrôlé par la connectivité dans Amazon VPC et par les informations d'identification de votre base de données.
### Configurer Amazon VPC
**Pour configurer l'accès pour les magasins de données Amazon Redshift**
1. Connectez-vous à la console Amazon Redshift AWS Management Console et ouvrez-la à l'adresse. [https://console.aws.amazon.com/redshiftv2/](https://console.aws.amazon.com/redshiftv2/)
1. Dans le volet de navigation de gauche, choisissez **Clusters**.
1. Choisissez le nom du cluster auquel vous souhaitez accéder à partir d'AWS Glue.
1. Dans la section **Cluster Properties (Propriétés du cluster)**, choisissez un groupe de sécurité dans **VPC security groups (Groupes de sécurité VPC)** afin de permettre à AWS Glue de l'utiliser. Enregistrez le nom du groupe de sécurité que vous avez choisi pour référence ultérieure. Lorsque vous choisissez le groupe de sécurité, la liste des **groupes de sécurité** de la console Amazon EC2 s'ouvre.
1. Choisissez le groupe de sécurité à modifier et accédez à l'onglet **Inbound** (Entrant).
1. Ajoutez une règle avec référence circulaire afin de permettre aux composants AWS Glue de communiquer. Plus spécifiquement, ajoutez ou confirmez qu'il existe une règle **Type** `All TCP`, que **Protocol** (Protocole) est `TCP`, que **Port Range** (Plage de ports) comprend tous les ports et que la valeur de **Source** est le même nom de groupe de sécurité que la valeur de **Group ID** (ID du groupe).
La règle entrante ressemble à ce qui suit :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/aws-glue-programming-etl-connect-redshift-home.html)
Par exemple :
![\[Exemple de règle de trafic entrant avec référence circulaire.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/SetupSecurityGroup-Start.png)
1. Ajoutez également une règle pour le trafic sortant. Ouvrez le trafic sortant pour tous les ports, par exemple :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/aws-glue-programming-etl-connect-redshift-home.html)
Ou créez une règle avec référence circulaire où **Type** est `All TCP`, **Protocol (Protocole)** est `TCP`, **Port Range (Plage de ports)** comprend tous les ports et dont la valeur de **Destination** est le même nom de groupe de sécurité que la valeur de **Group ID (ID du groupe)**. Si vous utilisez un point de terminaison d'un VPC Amazon S3, ajoutez également une règle HTTPS pour l'accès à Amazon S3. Le *s3-prefix-list-id* est requis dans la règle du groupe de sécurité pour autoriser le trafic entre le VPC et le point de terminaison Amazon S3 VPC.
Par exemple :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/aws-glue-programming-etl-connect-redshift-home.html)
### Configurer AWS Glue
Vous devez créer une connexion AWS Glue Data Catalog qui fournit les informations de connexion Amazon VPC.
**Pour configurer la connectivité Amazon Redshift entre Amazon VPC et Glue dans la console AWS**
1. Créez une connexion au catalogue de données en suivant les étapes décrites dans :[Ajouter une AWS Glue connexion](console-connections.md). Après avoir créé la connexion, conservez le nom de la connexion pour l'étape suivante. *connectionName*
+ Lorsque vous sélectionnez un **type de connexion**, sélectionnez **Amazon Redshift**.
+ Lorsque vous sélectionnez un **cluster Redshift**, sélectionnez le nom de votre cluster.
+ Fournissez les informations de connexion par défaut pour un utilisateur Amazon Redshift sur votre cluster.
+ Vos paramètres Amazon VPC seront automatiquement configurés.
**Note**
Vous devrez fournir `PhysicalConnectionRequirements` manuellement pour votre Amazon VPC lorsque vous créez une connexion **Amazon Redshift** via le kit AWS SDK.
1. Dans la configuration de votre tâche AWS Glue*connectionName*, fournissez une **connexion réseau supplémentaire**.
## Exemple : lecture à partir de tables Amazon Redshift
Vous pouvez lire à partir de clusters Amazon Redshift et des environnements Amazon Redshift sans serveur.
**Conditions préalables :** une table Amazon Redshift à partir de laquelle vous souhaitez lire. Suivez les étapes décrites dans la section précédente, [Configuration des connexions Redshift](#aws-glue-programming-etl-connect-redshift-configure) après quoi vous devriez avoir l'URI Amazon S3 pour un répertoire temporaire *temp-s3-dir* et un rôle IAM (dans le compte*role-account-id*). *rs-role-name*
------
#### [ Using the Data Catalog ]
**Conditions préalables supplémentaires :** une base de données et une table de catalogue de données pour la table Amazon Redshift à partir de laquelle vous souhaitez lire. Pour plus d'informations sur le catalogue de données, consultez [Découverte et catalogage des données dans AWS Glue](catalog-and-crawler.md). Après avoir créé une entrée pour votre table Amazon Redshift, vous identifierez votre connexion à l'aide d'un *redshift-dc-database-name* et. *redshift-table-name*
**Configuration :** dans les options de votre fonction, vous identifierez votre table de catalogue de données avec les paramètres `database` et `table_name`. Vous identifierez votre répertoire temporaire Amazon S3 avec `redshift_tmp_dir`. Vous fournirez également *rs-role-name* en utilisant la `aws_iam_role` clé dans le `additional_options` paramètre.
```
glueContext.create_dynamic_frame.from_catalog(
database = "redshift-dc-database-name",
table_name = "redshift-table-name",
redshift_tmp_dir = args["temp-s3-dir"],
additional_options = {"aws_iam_role": "arn:aws:iam::role-account-id:role/rs-role-name"})
```
------
#### [ Connecting directly ]
**Conditions préalables supplémentaires :** vous aurez besoin du nom de votre table Amazon Redshift (. *redshift-table-name* Vous aurez besoin des informations de connexion JDBC pour le cluster Amazon Redshift qui stocke cette table. Vous fournirez vos informations de connexion avec *host**port*,*redshift-database-name*, *username* et*password*.
Vous pouvez récupérer vos informations de connexion depuis la console Amazon Redshift lorsque vous travaillez avec des clusters Amazon Redshift. Pour l'utilisation d'Amazon Redshift sans serveur, consultez [Connexion à Amazon Redshift sans serveur](https://docs.aws.amazon.com//redshift/latest/mgmt/serverless-connecting.html) dans la documentation Amazon Redshift.
**Configuration :** dans les options de votre fonction, vous identifierez vos paramètres de connexions avec `url`, `dbtable`, `user` et `password`. Vous identifierez votre répertoire temporaire Amazon S3 avec `redshift_tmp_dir`. Vous pouvez spécifier votre rôle IAM en utilisant `aws_iam_role` lorsque vous utilisez `from_options`. La syntaxe est similaire à celle de la connexion via le catalogue de données, mais vous placez les paramètres sur la carte `connection_options`.
C'est une mauvaise pratique de coder en dur les mots de passe dans les scripts AWS Glue. Envisagez de stocker vos mots de passe AWS Secrets Manager et de les récupérer dans votre script avec le SDK for Python (Boto3).
```
my_conn_options = {
"url": "jdbc:redshift://host:port/redshift-database-name",
"dbtable": "redshift-table-name",
"user": "username",
"password": "password",
"redshiftTmpDir": args["temp-s3-dir"],
"aws_iam_role": "arn:aws:iam::account id:role/rs-role-name"
}
df = glueContext.create_dynamic_frame.from_options("redshift", my_conn_options)
```
------
## Exemple : écrire sur des tables Amazon Redshift
Vous pouvez sur des clusters Amazon Redshift et des environnements Amazon Redshift sans serveur.
**Conditions préalables :** un cluster Amazon Redshift et suivez les étapes de la [Configuration des connexions Redshift](#aws-glue-programming-etl-connect-redshift-configure) section précédente, après quoi vous devriez avoir l'URI Amazon S3 pour un répertoire temporaire et un rôle IAM*temp-s3-dir*,*rs-role-name*, (dans le compte). *role-account-id* Vous aurez également besoin d'un `DynamicFrame` dont vous souhaitez écrire le contenu dans la base de données.
------
#### [ Using the Data Catalog ]
**Conditions préalables supplémentaires :** une base de données de catalogue de données pour le cluster Amazon Redshift et la table sur laquelle vous souhaitez écrire. Pour plus d'informations sur le catalogue de données, consultez [Découverte et catalogage des données dans AWS Glue](catalog-and-crawler.md). Vous allez identifier votre connexion avec *redshift-dc-database-name* et la table cible avec*redshift-table-name*.
**Configuration :** dans les options de votre fonction, vous identifierez votre base de données de catalogue de données avec les paramètres `database`, puis vous fournirez votre table avec `table_name`. Vous identifierez votre répertoire temporaire Amazon S3 avec `redshift_tmp_dir`. Vous fournirez également *rs-role-name* en utilisant la `aws_iam_role` clé dans le `additional_options` paramètre.
```
glueContext.write_dynamic_frame.from_catalog(
frame = input dynamic frame,
database = "redshift-dc-database-name",
table_name = "redshift-table-name",
redshift_tmp_dir = args["temp-s3-dir"],
additional_options = {"aws_iam_role": "arn:aws:iam::account-id:role/rs-role-name"})
```
------
#### [ Connecting through a AWS Glue connection ]
Vous pouvez vous connecter directement à Amazon Redshift à l'aide de la méthode `write_dynamic_frame.from_options`. Toutefois, plutôt que d'insérer vos informations de connexion directement dans votre script, vous pouvez référencer les informations de connexion stockés dans une connexion au catalogue de données à l'aide de la méthode `from_jdbc_conf`. Vous pouvez le faire sans indexation de site web ou sans créer de tables de catalogue de données pour votre base de données. Pour plus d'informations sur les connexions au catalogue de données, consultez [Connexion aux données](glue-connections.md).
**Conditions préalables supplémentaires :** une base au catalogue de données pour votre base de données, une table Amazon Redshift à partir de laquelle vous souhaitez lire.
**Configuration :** vous allez identifier votre connexion au catalogue de données avec*dc-connection-name*. Vous identifierez votre base de données et votre table Amazon Redshift avec *redshift-table-name* et. *redshift-database-name* Vous fournirez les informations de connexion à votre catalogue de données avec `catalog_connection` et vos informations Amazon Redshift avec `dbtable` et `database`. La syntaxe est similaire à celle de la connexion via le catalogue de données, mais vous placez les paramètres sur la carte `connection_options`.
```
my_conn_options = {
"dbtable": "redshift-table-name",
"database": "redshift-database-name",
"aws_iam_role": "arn:aws:iam::role-account-id:role/rs-role-name"
}
glueContext.write_dynamic_frame.from_jdbc_conf(
frame = input dynamic frame,
catalog_connection = "dc-connection-name",
connection_options = my_conn_options,
redshift_tmp_dir = args["temp-s3-dir"])
```
------
## Référence des options de connexion Amazon Redshift
Les options de connexion de base utilisées pour toutes les connexions JDBC AWS Glue afin de configurer des informations telles que`url`, `user` et `password` sont cohérentes entre tous les types de JDBC. Pour plus d'informations sur les paramètres JDBC standards, consultez [Référence des options de connexion JDBC](aws-glue-programming-etl-connect-jdbc-home.md#aws-glue-programming-etl-connect-jdbc).
Le type de connexion Amazon Redshift propose des options de connexion supplémentaires :
+ `"redshiftTmpDir"` : (obligatoire) chemin Amazon S3 où les données temporaires peuvent être stockées lors de la copie à partir de la base de données.
+ `"aws_iam_role"` : (facultatif) ARN pour un rôle IAM. La tâche AWS Glue transmettra ce rôle au cluster Amazon Redshift pour accorder au cluster les autorisations nécessaires pour exécuter les instructions de la tâche.
### Options de connexion supplémentaires disponibles dans AWS Glue 4.0\$1
Vous pouvez également transmettre les options du nouveau connecteur Amazon Redshift via les options de connexion AWS Glue. Pour obtenir la liste complète des options de connecteur prises en charge, consultez la section relative aux *paramètres SQL de Spark* dans [Intégration Amazon Redshift pour Apache Spark](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html).
Pour vous faciliter la tâche, nous vous rappelons ici certaines nouvelles options :
| Nom | Obligatoire | Par défaut | Description |
| --- | --- | --- | --- |
| autopushdown | Non | TRUE | Applique le pushdown des prédicats et des requêtes en capturant et en analysant les plans logiques de Spark pour les opérations SQL. Les opérations sont traduites en une requête SQL, puis exécutées dans Amazon Redshift pour améliorer les performances. |
| autopushdown.s3\$1result\$1cache | Non | FALSE | Met en cache la requête SQL pour décharger les données du mappage des chemins Amazon S3 en mémoire, afin que la même requête n'ait pas besoin de s'exécuter à nouveau dans la même session Spark. Pris en charge uniquement lorsqu'`autopushdown` est activé. |
| unload\$1s3\$1format | Non | PARQUET | PARQUET : décharge les résultats de la requête au format Parquet. TEXTE : décharge les résultats de la requête séparés par une barre verticale au format texte. |
| sse\$1kms\$1key | Non | N/A | La clé AWS SSE-KMS à utiliser pour le chiffrement pendant les `UNLOAD` opérations au lieu du chiffrement par défaut pour. AWS |
| extracopyoptions | Non | N/A | Une liste d'options supplémentaires à ajouter à la commande `COPY` d'Amazon Redshift lors du chargement de données, telles que `TRUNCATECOLUMNS` ou `MAXERROR n` (pour en savoir plus sur les autres options, voir [COPY : paramètres facultatifs](https://docs.aws.amazon.com/redshift/latest/dg/r_COPY.html#r_COPY-syntax-overview-optional-parameters)). Notez que ces options étant ajoutées à la fin de la commande `COPY`, seules des options qui ont du sens peuvent être utilisées à la fin de la commande. Cela devrait couvrir la plupart des cas d'utilisation possibles. |
| csvnullstring (expérimental) | Non | NULL | La valeur de chaîne à écrire pour les valeurs nulles lors de l'utilisation du `tempformat` CSV. Il doit s'agir d'une valeur qui n'apparaît pas dans vos données réelles. |
Ces nouveaux paramètres peuvent être utilisés comme suit.
**Nouvelles options destinées à améliorer les performances**
Le nouveau connecteur intègre de nouvelles options d'amélioration des performances :
+ `autopushdown` : activée par défaut.
+ `autopushdown.s3_result_cache` : désactivée par défaut.
+ `unload_s3_format` : `PARQUET` par défaut.
Pour plus d'informations sur l'utilisation de ces options, consultez [Intégration Amazon Redshift pour Apache Spark](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html). Nous vous recommandons de ne pas activer ` autopushdown.s3_result_cache` lorsque vous effectuez des opérations mixtes (lecture et écriture), car les résultats mis en cache peuvent contenir des informations périmées. L'option `unload_s3_format` est définie sur `PARQUET` par défaut pour la commande `UNLOAD`, afin d'améliorer les performances et de réduire les coûts de stockage. Pour utiliser le comportement par défaut de la commande `UNLOAD`, réinitialisez l'option sur `TEXT`.
**Nouvelle option de chiffrement pour la lecture**
Par défaut, les données du dossier temporaire que AWS Glue utilise lors de la lecture des données de la table Amazon Redshift sont chiffrées à l'aide du chiffrement `SSE-S3`. Pour utiliser les clés gérées par le client à partir de AWS Key Management Service (AWS KMS) pour chiffrer vos données, vous pouvez définir d'`("sse_kms_key" → kmsKey)`où KSMKey est l'[ID de clé AWS KMS, au lieu de](https://docs.aws.amazon.com/kms/latest/developerguide/find-cmk-id-arn.html) l'ancienne option `("extraunloadoptions" → s"ENCRYPTED KMS_KEY_ID '$kmsKey'")` de configuration de la version 3.0. AWS Glue
```
datasource0 = glueContext.create_dynamic_frame.from_catalog(
database = "database-name",
table_name = "table-name",
redshift_tmp_dir = args["TempDir"],
additional_options = {"sse_kms_key":""},
transformation_ctx = "datasource0"
)
```
**Prise en charge de l'URL JDBC basée sur IAM**
Le nouveau connecteur prend en charge une URL JDBC basée sur IAM, vous n'avez donc pas besoin de transmettre un code secret. user/password Avec une URL JDBC basée sur IAM, le connecteur utilise le rôle d'exécution des tâches pour accéder à la source de données Amazon Redshift.
Étape 1 : associez la politique minimale requise suivante à votre rôle d'exécution de tâches AWS Glue.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": "redshift:GetClusterCredentials",
"Resource": [
"arn:aws:redshift:us-east-1:111122223333:dbgroup:/*",
"arn:aws:redshift:*:111122223333:dbuser:*/*",
"arn:aws:redshift:us-east-1:111122223333:dbname:/"
]
},
{
"Sid": "VisualEditor1",
"Effect": "Allow",
"Action": "redshift:DescribeClusters",
"Resource": "*"
}
]
}
```
------
Étape 2 : utilisez l'URL JDBC basée sur IAM comme suit. Spécifiez une nouvelle option `DbUser` avec le nom d'utilisateur Amazon Redshift qui permet de vous connecter.
```
conn_options = {
// IAM-based JDBC URL
"url": "jdbc:redshift:iam://:/",
"dbtable": dbtable,
"redshiftTmpDir": redshiftTmpDir,
"aws_iam_role": aws_iam_role,
"DbUser": "" // required for IAM-based JDBC URL
}
redshift_write = glueContext.write_dynamic_frame.from_options(
frame=dyf,
connection_type="redshift",
connection_options=conn_options
)
redshift_read = glueContext.create_dynamic_frame.from_options(
connection_type="redshift",
connection_options=conn_options
)
```
**Note**
`DynamicFrame` ne prend actuellement en charge qu'une URL JDBC basée sur IAM avec un ` DbUser` dans le flux de travail `GlueContext.create_dynamic_frame.from_options`.
## Migration de AWS Glue version 3.0 vers la version 4.0
Dans AWS Glue 4.0, les tâches ETL ont accès à un nouveau connecteur Amazon Redshift Spark et à un nouveau pilote JDBC avec différentes options et configurations. Le nouveau connecteur et le nouveau pilote Amazon Redshift ont été conçus dans un souci de performance et garantissent la cohérence transactionnelle de vos données. Ces produits sont décrits dans la documentation Amazon Redshift. Pour en savoir plus, consultez :
+ [Intégration Amazon Redshift pour Apache Spark](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html)
+ [Pilote Amazon Redshift JDBC, version 2.1](https://docs.aws.amazon.com/redshift/latest/mgmt/jdbc20-download-driver.html)
**Restriction portant sur les noms et les identifiants des tables et des colonnes**
Concernant le nom de la table Redshift, les exigences du nouveau connecteur et du nouveau pilote Amazon Redshift Spark sont plus restreintes. Pour plus d'informations, consultez la section [Noms et identifiants](https://docs.aws.amazon.com/redshift/latest/dg/r_names.html) qui explique comment définir le nom de votre table Amazon Redshift. Le flux de travail des signets de tâches peut ne pas fonctionner avec un nom de table non conforme aux règles et avec certains caractères (l'espace, par exemple).
Si vous utilisez d'anciennes tables dont les noms ne sont pas conformes aux règles relatives aux [noms et identifiants](https://docs.aws.amazon.com/redshift/latest/dg/r_names.html) et que vous rencontrez des problèmes liés aux signets (tâches dédiées au retraitement des données d'anciennes tables Amazon Redshift), nous vous recommandons de renommer vos tables. Pour plus d'informations, consultez les [exemples d'utilisation de la commande ALTER TABLE](https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_TABLE_examples_basic.html).
**Modification de tempformat par défaut dans le Dataframe**
Le connecteur Spark de AWS Glue version 3.0 définit par défaut le `tempformat` sur CSV lors de l'écriture dans Amazon Redshift. Par souci de cohérence, dans AWS Glue version 3.0, ` DynamicFrame` définit toujours par défaut le `tempformat` de manière à utiliser le format `CSV`. Si vous avez déjà utilisé Spark Dataframe APIs directement avec le connecteur Amazon Redshift Spark, vous pouvez définir explicitement le format CSV dans `tempformat` `DataframeReader` les options/. `Writer` Sinon, `tempformat` est défini par défaut sur `AVRO` dans le nouveau connecteur Spark.
**Changement de comportement : mapper le type de données Amazon Redshift REAL sur le type de données FLOAT de Spark au lieu de DOUBLE**
Dans AWS Glue version 3.0, Amazon Redshift `REAL` est converti en type ` DOUBLE` de Spark. Le nouveau connecteur Amazon Redshift Spark a mis à jour le comportement afin que le type Amazon Redshift ` REAL` soit converti en type `FLOAT` de Spark et inversement. Si, conformément à un ancien cas d'utilisation, vous souhaitez toujours que le type `REAL` Amazon Redshift soit mappé sur un type Spark `DOUBLE`, vous pouvez utiliser la solution alternative suivante :
+ Pour un `DynamicFrame`, mappez le type `Float` sur un type `Double` avec `DynamicFrame.ApplyMapping`. Pour un `Dataframe`, vous devez utiliser `cast`.
Exemple de code :
```
dyf_cast = dyf.apply_mapping([('a', 'long', 'a', 'long'), ('b', 'float', 'b', 'double')])
```
**Gestion du type de données VARBYTE**
Lorsque vous travaillez avec les types de données AWS Glue 3.0 et Amazon Redshift, AWS Glue 3.0 convertit Amazon `VARBYTE` Redshift en type Spark. `STRING` Cependant, le dernier connecteur Amazon Redshift Spark ne prend pas en charge le type de données `VARBYTE`. Pour contourner cette restriction, vous pouvez [créer une vue Redshift](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_VIEW.html) qui transforme les colonnes `VARBYTE` en type de données compatible. Utilisez ensuite le nouveau connecteur pour charger les données à partir de cette vue au lieu de la table d’origine, ce qui garantit la compatibilité tout en maintenant l’accès à vos données `VARBYTE`.
Exemple de requête Redshift :
```
CREATE VIEW view_name AS SELECT FROM_VARBYTE(varbyte_column, 'hex') FROM table_name
```
# Connexions Kafka
Vous pouvez utiliser une connexion Kafka pour lire et écrire dans des flux de données Kafka à l’aide d’informations stockées dans une table de catalogue de données ou en fournissant des informations permettant d’accéder directement au flux de données. La connexion prend en charge un cluster Kafka ou un cluster Amazon Managed Streaming for Apache Kafka. Vous pouvez lire les informations de Kafka dans un Spark DataFrame, puis les convertir en AWS Glue DynamicFrame. Vous pouvez DynamicFrames écrire dans Kafka au format JSON. Si vous accédez directement au flux de données, utilisez ces options pour fournir des informations sur la façon d'accéder au flux de données.
Si vous utilisez `getCatalogSource` ou `create_data_frame_from_catalog` pour consommer des enregistrements à partir d’une source de streaming Kafka, ou `getCatalogSink` ou `write_dynamic_frame_from_catalog` pour écrire des enregistrements dans Kafka, et que la tâche dispose des informations relatives à la base de données Data Catalog et au nom de la table, et peut les utiliser pour obtenir certains paramètres de base pour la lecture à partir de la source de streaming Kafka. Si vous utilisez `getSource`, `getCatalogSink`, `getSourceWithFormat`, `getSinkWithFormat`, `createDataFrameFromOptions`, `create_data_frame_from_options` ou `write_dynamic_frame_from_catalog`, vous devez spécifier ces paramètres de base à l’aide des options de connexion décrites ici.
Vous pouvez spécifier les options de connexion pour Kafka à l’aide des arguments suivants pour les méthodes spécifiées dans la classe `GlueContext`.
+ Scala
+ `connectionOptions` : utiliser avec `getSource`, `createDataFrameFromOptions`, `getSink`
+ `additionalOptions` : utiliser avec `getCatalogSource`, `getCatalogSink`
+ `options` : utiliser avec `getSourceWithFormat`, `getSinkWithFormat`
+ Python
+ `connection_options` : utiliser avec `create_data_frame_from_options`, `write_dynamic_frame_from_options`
+ `additional_options` : utiliser avec `create_data_frame_from_catalog`, `write_dynamic_frame_from_catalog`
+ `options` : utiliser avec `getSource`, `getSink`
Pour les remarques et les restrictions concernant les tâches ETL de streaming, consultez [Restrictions et notes sur ETL en streaming](add-job-streaming.md#create-job-streaming-restrictions).
**Topics**
+ [
## Configurer Kafka
](#aws-glue-programming-etl-connect-kafka-configure)
+ [
## Exemple : lecture à partir de flux Kafka
](#aws-glue-programming-etl-connect-kafka-read)
+ [
## Exemple : écriture dans les flux Kafka
](#aws-glue-programming-etl-connect-kafka-write)
+ [
## Référence des options de connexion de Kafka
](#aws-glue-programming-etl-connect-kafka)
## Configurer Kafka
Il n'y a aucune AWS condition préalable pour se connecter aux flux Kafka disponibles sur Internet.
Vous pouvez créer une connexion AWS Glue Kafka pour gérer vos identifiants de connexion. Pour de plus amples informations, veuillez consulter [Création d’une connexion AWS Glue pour un flux de données Apache Kafka](add-job-streaming.md#create-conn-streaming). Dans la configuration de votre tâche AWS Glue, fournissez *connectionName* une **connexion réseau supplémentaire**, puis, dans votre appel de méthode, fournissez *connectionName* le `connectionName` paramètre.
Dans certains cas, vous devrez configurer des prérequis supplémentaires :
+ Si vous utilisez Amazon Managed Streaming pour Apache Kafka avec l'authentification IAM, vous aurez besoin d'une configuration IAM appropriée.
+ Si vous utilisez Amazon Managed Streaming pour Apache Kafka avec un Amazon VPC, vous aurez besoin d'une configuration Amazon VPC appropriée. Vous devez créer une connexion AWS Glue fournissant les informations de connexion Amazon VPC. Vous aurez besoin de la configuration de votre tâche pour inclure la connexion AWS Glue en tant que **connexion réseau supplémentaire**.
Pour plus d’informations sur les prérequis de la tâche ETL de streaming, consultez [Tâches ETL en streaming dans AWS Glue](add-job-streaming.md).
## Exemple : lecture à partir de flux Kafka
Utilisez conjointement avec [forEachBatch](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-forEachBatch).
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)
```
## Exemple : écriture dans les flux Kafka
Exemples pour écrire dans Kafka :
Exemple avec la méthode `getSink` :
```
data_frame_datasource0 =
glueContext.getSink(
connectionType="kafka",
connectionOptions={
JsonOptions("""{
"connectionName": "ConfluentKafka",
"classification": "json",
"topic": "kafka-auth-topic",
"typeOfData": "kafka"}
""")},
transformationContext="dataframe_ApacheKafka_node1711729173428")
.getDataFrame()
```
Exemple avec la méthode `write_dynamic_frame.from_options` :
```
kafka_options =
{ "connectionName": "ConfluentKafka",
"topicName": "kafka-auth-topic",
"classification": "json"
}
data_frame_datasource0 = glueContext.write_dynamic_frame.from_options(connection_type="kafka", connection_options=kafka_options)
```
## Référence des options de connexion de Kafka
Lors de la lecture, utilisez les options de connexion suivantes avec `"connectionType": "kafka"` :
+ `"bootstrap.servers"`(Obligatoire) Une liste de serveurs bootstrap URLs, par exemple, comme`b-1.vpc-test-2.o4q88o.c6.kafka.us-east-1.amazonaws.com:9094`. Cette option doit être spécifiée dans l'appel d'API ou définie dans les métadonnées de la table dans le catalogue de données.
+ `"security.protocol"`(Obligatoire) Le protocole utilisé pour communiquer avec les agents. Les valeurs possibles sont `"SSL"` ou `"PLAINTEXT"`.
+ `"topicName"` : (requis) liste de rubriques séparées par des virgules auxquelles s'abonner. Vous devez spécifier un seul et unique élément parmi `"topicName"`, `"assign"` ou `"subscribePattern"`.
+ `"assign"` : (requis) chaîne JSON indiquant le `TopicPartitions` spécifique à utiliser. Vous devez spécifier un seul et unique élément parmi `"topicName"`, `"assign"` ou `"subscribePattern"`.
Exemple : '\$1"topicA":[0,1],"topicB":[2,4]\$1'
+ `"subscribePattern"` : (obligatoire) chaîne d'expression rationnelle Java qui identifie la liste de rubriques à laquelle vous souhaitez vous abonner. Vous devez spécifier un seul et unique élément parmi `"topicName"`, `"assign"` ou `"subscribePattern"`.
Exemple : 'topic.\$1'
+ `"classification"` : (obligatoire) le format de fichier utilisé par les données de l'enregistrement. Obligatoire, sauf s'il est fourni par le catalogue de données.
+ `"delimiter"` : (facultatif) le séparateur de valeurs utilisé lorsque `classification` est CSV. La valeur par défaut est « `,` ».
+ `"startingOffsets"` : (facultatif) position de départ dans la rubrique Kafka à partir de laquelle lire les données. Les valeurs possibles sont `"earliest"` ou `"latest"`. La valeur par défaut est `"latest"`.
+ `"startingTimestamp"`: (Facultatif, disponible uniquement pour AWS la version 4.0 ou ultérieure de Glue) Horodatage de l'enregistrement dans la rubrique Kafka à partir duquel les données doivent être lues. La valeur possible est une chaîne d'horodatage au format UTC dans le modèle `yyyy-mm-ddTHH:MM:SSZ` (où `Z` représente un décalage de fuseau horaire UTC avec un \$1/-. Par exemple : « 2023-04-04T08:00:00-04:00 »).
Remarque : seule l'une des propriétés « StartingOffsets » ou « StartingTimestamp » peut figurer dans la liste des options de connexion du script de streaming AWS Glue. L'inclusion de ces deux propriétés entraînera l'échec de la tâche.
+ `"endingOffsets"` : (facultatif) point de fin lorsqu'une requête par lots est terminée. Les valeurs possibles sont `"latest"` ou une chaîne JSON qui spécifie un décalage de fin pour chaque `TopicPartition`.
Pour la chaîne JSON, le format est `{"topicA":{"0":23,"1":-1},"topicB":{"0":-1}}`. La valeur `-1` en tant que décalage représente `"latest"`.
+ `"pollTimeoutMs"` : (facultatif) délai d'attente en millisecondes pour interroger les données de Kafka dans les exécuteurs de tâches Spark. La valeur par défaut est `600000`.
+ `"numRetries"` : (facultatif) nombre de nouvelles tentatives avant de ne pas récupérer les décalages Kafka. La valeur par défaut est `3`.
+ `"retryIntervalMs"` : (facultatif) temps d'attente en millisecondes avant d'essayer de récupérer les décalages Kafka. La valeur par défaut est `10`.
+ `"maxOffsetsPerTrigger"` : (facultatif) limite de taux sur le nombre maximal de décalages qui sont traités par intervalle de déclenchement. Le nombre total spécifié de décalages est réparti proportionnellement entre les `topicPartitions` des différents volumes. La valeur par défaut est null, ce qui signifie que le consommateur lit tous les décalages jusqu'au dernier décalage connu.
+ `"minPartitions"` : (facultatif) nombre minimum de partitions à lire à partir de Kafka. La valeur par défaut est nulle, ce qui signifie que le nombre de partitions Spark est égal au nombre de partitions Kafka.
+ `"includeHeaders"`: (facultatif) indique s'il faut inclure les en-têtes Kafka. Lorsque l'option est définie sur « true » (vrai), la sortie de données contiendra une colonne supplémentaire nommée « glue\$1streaming\$1kafka\$1headers » avec le type `Array[Struct(key: String, value: String)]`. La valeur définie par défaut est « false ». Cette option est disponible dans AWS Glue version 3.0 ou ultérieure.
+ `"schema"` : (requis lorsque inferSchema est défini sur false) schéma à utiliser pour traiter la charge utile. Si la classification est `avro`, le schéma fourni doit être au format de schéma Avro. Si la classification n'est pas `avro`, le schéma fourni doit être au format de schéma DDL.
Voici quelques exemples de schémas.
------
#### [ Example in DDL schema format ]
```
'column1' INT, 'column2' STRING , 'column3' FLOAT
```
------
#### [ Example in Avro schema format ]
```
{
"type":"array",
"items":
{
"type":"record",
"name":"test",
"fields":
[
{
"name":"_id",
"type":"string"
},
{
"name":"index",
"type":
[
"int",
"string",
"float"
]
}
]
}
}
```
------
+ `"inferSchema"` : (facultatif) la valeur par défaut est « false ». S'il est défini sur « true », le schéma sera détecté lors de l'exécution à partir de la charge utile dans `foreachbatch`.
+ `"avroSchema"` : (obsolète) paramètre utilisé pour spécifier un schéma de données Avro lorsque le format Avro est utilisé. Ce paramètre est désormais obsolète. Utilisez le paramètre `schema`.
+ `"addRecordTimestamp"` : (facultatif) lorsque cette option est définie sur « true », la sortie de données contient une colonne supplémentaire nommée « \$1\$1src\$1timestamp » qui indique l'heure à laquelle l'enregistrement correspondant est reçu par la rubrique. La valeur par défaut est « false ». Cette option est prise en charge dans AWS Glue version 4.0 ou ultérieure.
+ `"emitConsumerLagMetrics"`: (Facultatif) Lorsque l'option est définie sur « vrai », pour chaque lot, elle émet les métriques correspondant à la durée comprise entre le plus ancien enregistrement reçu par le sujet et le moment où il arrive CloudWatch. AWS Glue Le nom de la métrique est « glue.driver.streaming ». maxConsumerLagInMs». La valeur par défaut est « false ». Cette option est prise en charge dans AWS Glue version 4.0 ou ultérieure.
Lors de l’écriture, utilisez les options de connexion suivantes avec `"connectionType": "kafka"` :
+ `"connectionName"`(Obligatoire) Nom de la connexion AWS Glue utilisée pour se connecter au cluster Kafka (similaire à la source Kafka).
+ `"topic"` (Obligatoire) Si une colonne de rubrique existe, sa valeur est utilisée comme rubrique lors de l’écriture de la ligne donnée dans Kafka, sauf si l’option de configuration de la rubrique est définie. C’est-à-dire que l’option de configuration `topic` remplace la colonne de rubrique.
+ `"partition"` (Facultatif) Si un numéro de partition valide est spécifié, cette `partition` sera utilisée lors de l’envoi de l’enregistrement.
Si aucune partition n’est spécifiée, mais qu’une `key` est présente, une partition sera choisie en utilisant le hachage de la clé.
Si ni une `key`, ni une `partition` ne sont présentes, une partition sera choisie en partitionnant de manière permanente ces modifications lorsqu’au moins des octets batch.size seront produits sur la partition.
+ `"key"` (Facultatif) Utilisé pour le partitionnement si `partition` est nul.
+ `"classification"` (Facultatif) Format de fichier utilisé par les données de l’enregistrement. Nous prenons uniquement en charge les formats JSON, CSV et Avro.
Avec le format Avro, nous pouvons fournir une valeur avroSchema personnalisée avec laquelle il est possible de sérialiser, mais notez que cela doit également être fourni sur la source pour la désérialisation. Sinon, par défaut, il utilise Apache AvroSchema pour la sérialisation.
En outre, vous pouvez optimiser le récepteur Kafka selon les besoins en mettant à jour les [paramètres de configuration du producteur Kafka](https://kafka.apache.org/documentation/#producerconfigs). Notez qu’il n’existe aucune liste d’autorisation pour les options de connexion, toutes les paires clé-valeur sont conservées telles quelles sur le récepteur.
Cependant, il existe une petite liste de refus d’options qui ne prendra pas effet. Pour plus d’informations, consultez [Kafka specific configurations](https://spark.apache.org/docs/latest/structured-streaming-kafka-integration.html).
# Connexions Azure Cosmos DB
Vous pouvez utiliser AWS Glue for Spark pour lire et écrire dans des conteneurs existants dans Azure Cosmos DB à l'aide de l'API NoSQL de AWS Glue 4.0 et des versions ultérieures. Vous pouvez définir ce qu'il faut lire dans Azure Cosmos DB à l'aide d'une requête SQL. Vous vous connectez à Azure Cosmos DB à l'aide d'une clé Azure Cosmos DB stockée AWS Secrets Manager via une connexion AWS Glue.
Pour plus d'informations sur Azure Cosmos DB pour NoSQL, consultez [la documentation Azure](https://learn.microsoft.com/en-us/azure/cosmos-db/nosql/).
## Configuration des connexions Azure Cosmos DB
Pour vous connecter à Azure Cosmos DB depuis AWS Glue, vous devez créer et stocker votre clé de base de données Azure Cosmos dans un AWS Secrets Manager secret, puis associer ce secret à une connexion Azure Cosmos DB AWS Glue.
**Prérequis :**
+ Dans Azure, vous devrez identifier ou générer une clé de base de données Azure Cosmos à utiliser par AWS Glue,`cosmosKey`. Pour plus d'informations, consultez la section [Accès sécurisé aux données dans Azure Cosmos DB](https://learn.microsoft.com/en-us/azure/cosmos-db/secure-access-to-data?tabs=using-primary-key) dans la documentation Azure.
**Pour configurer une connexion à Azure Cosmos DB :**
1. Dans AWS Secrets Manager, créez un secret à l'aide de votre clé de base de données Azure Cosmos. Pour créer un secret dans Secrets Manager, suivez le didacticiel disponible dans la [section Créer un AWS Secrets Manager secret](https://docs.aws.amazon.com//secretsmanager/latest/userguide/create_secret.html) dans la AWS Secrets Manager documentation. Après avoir créé le secret, conservez le nom du secret *secretName* pour l'étape suivante.
+ Lorsque vous sélectionnez des **paires clé/valeur**, créez une paire pour la clé `spark.cosmos.accountKey` contenant la valeur. *cosmosKey*
1. Dans la console AWS Glue, créez une connexion en suivant les étapes décrites dans[Ajouter une AWS Glue connexion](console-connections.md). Après avoir créé la connexion, conservez le nom de la connexion pour une utilisation future dans AWS Glue. *connectionName*
+ Lorsque vous sélectionnez un **type de connexion**, sélectionnez Azure Cosmos DB.
+ Lorsque vous sélectionnez un **AWS secret**, fournissez*secretName*.
Après avoir créé une connexion AWS Glue Azure Cosmos DB, vous devez effectuer les étapes suivantes avant d'exécuter votre tâche AWS Glue :
+ Accordez au rôle IAM associé à votre tâche AWS Glue l'autorisation de lire*secretName*.
+ Dans la configuration de votre tâche AWS Glue*connectionName*, fournissez une **connexion réseau supplémentaire**.
## Lire à partir de la Azure Cosmos DB pour les conteneurs NoSQL
**Prérequis :**
+ Un conteneur Azure Cosmos DB pour NoSQL à partir duquel vous souhaitez lire. Vous aurez besoin des informations d'identification du conteneur.
Un conteneur Azure Cosmos pour NoSQL est identifié par sa base de données et son conteneur. Vous devez fournir les noms de base de données et de conteneur lorsque vous vous connectez à l'API Azure Cosmos pour NoSQL. *cosmosDBName* *cosmosContainerName*
+ Une connexion AWS Glue Azure Cosmos DB configurée pour fournir des informations d'authentification et de localisation réseau. Pour cela, suivez les étapes de la procédure précédente, *Pour configurer une connexion à Azure Cosmos DB*. Vous aurez besoin du nom de la connexion AWS Glue,*connectionName*.
Par exemple :
```
azurecosmos_read = glueContext.create_dynamic_frame.from_options(
connection_type="azurecosmos",
connection_options={
"connectionName": connectionName,
"spark.cosmos.database": cosmosDBName,
"spark.cosmos.container": cosmosContainerName,
}
)
```
Vous pouvez également fournir une requête SQL SELECT pour filtrer les résultats renvoyés à votre DynamicFrame. Vous devrez configurer `query`.
Par exemple :
```
azurecosmos_read_query = glueContext.create_dynamic_frame.from_options(
connection_type="azurecosmos",
connection_options={
"connectionName": "connectionName",
"spark.cosmos.database": cosmosDBName,
"spark.cosmos.container": cosmosContainerName,
"spark.cosmos.read.customQuery": "query"
}
)
```
## Écrire dans Azure Cosmos DB pour les conteneurs NoSQL
Cet exemple écrit des informations à partir d'une base de données existante DynamicFrame *dynamicFrame* dans Azure Cosmos DB. Si le conteneur contient déjà des informations, AWS Glue ajoutera les données de votre DynamicFrame. Si les informations contenues dans le conteneur ont un schéma différent de celui des informations que vous écrivez, vous rencontrerez des erreurs.
**Prérequis :**
+ Une table Azure Cosmos DB dans laquelle vous souhaitez écrire. Vous aurez besoin des informations d'identification du conteneur. **Vous devez créer le conteneur avant d'appeler la méthode de connexion.**
Un conteneur Azure Cosmos pour NoSQL est identifié par sa base de données et son conteneur. Vous devez fournir les noms de base de données et de conteneur lorsque vous vous connectez à l'API Azure Cosmos pour NoSQL. *cosmosDBName* *cosmosContainerName*
+ Une connexion AWS Glue Azure Cosmos DB configurée pour fournir des informations d'authentification et de localisation réseau. Pour cela, suivez les étapes de la procédure précédente, *Pour configurer une connexion à Azure Cosmos DB*. Vous aurez besoin du nom de la connexion AWS Glue,*connectionName*.
Par exemple :
```
azurecosmos_write = glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type="azurecosmos",
connection_options={
"connectionName": connectionName,
"spark.cosmos.database": cosmosDBName,
"spark.cosmos.container": cosmosContainerName
)
```
## Référence des options de connexion Azure Cosmos DB
+ `connectionName` — Obligatoire. Utilisé pour la lecture/l'écriture. Nom d'une connexion AWS Glue Azure Cosmos DB configurée pour fournir des informations d'authentification et de localisation réseau à votre méthode de connexion.
+ `spark.cosmos.database` — Obligatoire. Utilisé pour la lecture/l'écriture. Valeurs valides : noms des bases de données. Nom de la base de données Azure Cosmos DB pour NoSQL.
+ `spark.cosmos.container` — Obligatoire. Utilisé pour la lecture/l'écriture. Valeurs valides : noms des conteneurs. Nom du conteneur Azure Cosmos DB pour NoSQL.
+ `spark.cosmos.read.customQuery` : utilisé pour la lecture. Valeurs valides : requêtes SELECT SQL. Requête personnalisée pour sélectionner les documents à lire.
# Connexions Azure SQL
Vous pouvez utiliser AWS Glue for Spark pour lire et écrire dans des tables sur des instances gérées Azure SQL dans AWS Glue 4.0 et versions ultérieures. Vous pouvez définir ce qu'il faut lire dans Azure SQL à l'aide d'une requête SQL. Vous vous connectez à Azure SQL à l'aide des informations d'identification d'utilisateur et de mot de passe stockées AWS Secrets Manager via une connexion AWS Glue.
Pour plus d'informations sur Azure SQL, consultez [la documentation Azure SQL](https://azure.microsoft.com/en-us/products/azure-sql).
## Configuration des connexions Azure SQL
Pour vous connecter à Azure SQL depuis AWS Glue, vous devez créer et stocker vos informations d'identification Azure SQL dans un AWS Secrets Manager secret, puis associer ce secret à une connexion Azure SQL AWS Glue.
**Pour configurer une connexion à Azure SQL :**
1. Dans AWS Secrets Manager, créez un secret à l'aide de vos informations d'identification Azure SQL. Pour créer un secret dans Secrets Manager, suivez le didacticiel disponible dans la [section Créer un AWS Secrets Manager secret](https://docs.aws.amazon.com//secretsmanager/latest/userguide/create_secret.html) dans la AWS Secrets Manager documentation. Après avoir créé le secret, conservez le nom du secret *secretName* pour l'étape suivante.
+ Lorsque vous sélectionnez des **paires clé/valeur**, créez une paire pour la clé `user` contenant la valeur. *azuresqlUsername*
+ Lorsque vous sélectionnez des **paires clé/valeur**, créez une paire pour la clé `password` contenant la valeur. *azuresqlPassword*
1. Dans la console AWS Glue, créez une connexion en suivant les étapes décrites dans[Ajouter une AWS Glue connexion](console-connections.md). Après avoir créé la connexion, conservez le nom de la connexion pour une utilisation future dans AWS Glue. *connectionName*
+ Lorsque vous sélectionnez un **type de connexion**, sélectionnez Azure SQL.
+ Lorsque vous fournissez une **URL Azure SQL**, fournissez une URL de point de terminaison JDBC.
La URL doit avoir le format suivant : `jdbc:sqlserver://databaseServerName:databasePort;databaseName=azuresqlDBname;`.
AWS Glue nécessite les propriétés d'URL suivantes :
+ `databaseName` – une base de données par défaut dans Azure SQL à laquelle se connecter.
Pour plus d'informations sur JDBC URLs pour Azure SQL Managed Instances, consultez la documentation [Microsoft](https://learn.microsoft.com/en-us/sql/connect/jdbc/building-the-connection-url?view=azuresqldb-mi-current).
+ Lorsque vous sélectionnez un **AWS secret**, indiquez-le*secretName*.
Après avoir créé une connexion AWS Glue Azure SQL, vous devez effectuer les étapes suivantes avant d'exécuter votre tâche AWS Glue :
+ Accordez au rôle IAM associé à votre tâche AWS Glue l'autorisation de lire*secretName*.
+ Dans la configuration de votre tâche AWS Glue*connectionName*, fournissez une **connexion réseau supplémentaire**.
## Lire à partir de tables SQL Azure
**Prérequis :**
+ Une table Azure SQL à partir de laquelle vous souhaitez lire. Vous aurez besoin d'informations d'identification pour la table, *databaseName* et*tableIdentifier*.
Une table Azure SQL est identifiée par sa base de données, son schéma et son nom de table. Vous devez fournir le nom de la base de données et le nom de la table lorsque vous vous connectez à Azure SQL. Vous devez également fournir le schéma s'il n'est pas « public » par défaut. La base de données est fournie via une propriété d'URL dans*connectionName*, un schéma et un nom de table via le`dbtable`.
+ Une connexion SQL AWS Glue Azure configurée pour fournir des informations d'authentification. Suivez les étapes de la procédure précédente *Pour configurer une connexion à Azure SQL* afin de configurer vos informations d'authentification. Vous aurez besoin du nom de la connexion AWS Glue,*connectionName*.
Par exemple :
```
azuresql_read_table = glueContext.create_dynamic_frame.from_options(
connection_type="azuresql",
connection_options={
"connectionName": "connectionName",
"dbtable": "tableIdentifier"
}
)
```
Vous pouvez également fournir une requête SQL SELECT pour filtrer les résultats renvoyés à votre DynamicFrame. Vous devrez configurer `query`.
Par exemple :
```
azuresql_read_query = glueContext.create_dynamic_frame.from_options(
connection_type="azuresql",
connection_options={
"connectionName": "connectionName",
"query": "query"
}
)
```
## Écrire dans des tables Azure SQL
Cet exemple écrit des informations à partir d'un DynamicFrame fichier existant *dynamicFrame* dans Azure SQL. Si le tableau contient déjà des informations, AWS Glue ajoutera les données de votre DynamicFrame.
**Prérequis :**
+ Une table Azure SQL dans laquelle vous souhaitez écrire. Vous aurez besoin d'informations d'identification pour la table, *databaseName* et*tableIdentifier*.
Une table Azure SQL est identifiée par sa base de données, son schéma et son nom de table. Vous devez fournir le nom de la base de données et le nom de la table lorsque vous vous connectez à Azure SQL. Vous devez également fournir le schéma s'il n'est pas « public » par défaut. La base de données est fournie via une propriété d'URL dans*connectionName*, un schéma et un nom de table via le`dbtable`.
+ Informations d'authentification Azure SQL. Suivez les étapes de la procédure précédente *Pour configurer une connexion à Azure SQL* afin de configurer vos informations d'authentification. Vous aurez besoin du nom de la connexion AWS Glue,*connectionName*.
Par exemple :
```
azuresql_write = glueContext.write_dynamic_frame.from_options(
connection_type="azuresql",
connection_options={
"connectionName": "connectionName",
"dbtable": "tableIdentifier"
}
)
```
## Référence des options de connexion Azure SQL
+ `connectionName` — Obligatoire. Utilisé pour la lecture/l'écriture. Le nom d'une connexion SQL AWS Glue Azure configurée pour fournir des informations d'authentification à votre méthode de connexion.
+ `databaseName` : utilisé pour la lecture/l'écriture. Valeurs valides : noms des bases de données Azure SQL. Le nom de la base de données dans Azure SQL à laquelle se connecter.
+ `dbtable` — obligatoire pour l'écriture, obligatoire pour la lecture à moins qu'une `query` ne soit fournie. Utilisé pour les combinaisons de Read/Write. Valid Values: Names of Azure SQL tables, or period separated schema/table noms. Utilisées pour spécifier la table et le schéma qui identifient la table à laquelle se connecter. Le schéma par défaut est « public ». Si votre table n'est pas dans un schéma par défaut, fournissez ces informations dans le formulaire `schemaName.tableName`.
+ `query` : utilisé pour la lecture. Une requête Transact-SQL SELECT définissant ce qui doit être récupéré lors de la lecture à partir d'Azure SQL. Pour plus d'informations, consultez la [documentation Microsoft](https://learn.microsoft.com/en-us/sql/t-sql/queries/select-transact-sql?view=azuresqldb-mi-current).
# BigQuery connexions
Vous pouvez utiliser AWS Glue for Spark pour lire et écrire dans des tableaux de Google BigQuery dans AWS Glue 4.0 et versions ultérieures. Vous pouvez le lire à l' BigQuery aide d'une requête Google SQL. Vous vous connectez à BigQuery l'aide des informations d'identification stockées AWS Secrets Manager via une connexion AWS Glue.
Pour plus d'informations sur Google BigQuery, consultez le [ BigQuery site Web de Google Cloud](https://cloud.google.com/bigquery).
## Configuration des BigQuery connexions
Pour vous connecter à Google BigQuery depuis AWS Glue, vous devez créer et stocker vos informations d'identification Google Cloud Platform dans un AWS Secrets Manager secret, puis associer ce secret à une connexion Google BigQuery AWS Glue.
**Pour configurer une connexion à BigQuery :**
1. Dans Google Cloud Platform, créez et identifiez les ressources pertinentes :
+ Créez ou identifiez un projet GCP contenant des BigQuery tables auxquelles vous souhaitez vous connecter.
+ Activez l' BigQuery API. Pour plus d'informations, voir [Utiliser l'API BigQuery Storage Read pour lire les données des tables](https://cloud.google.com/bigquery/docs/reference/storage/#enabling_the_api).
1. Dans Google Cloud Platform, créez et exportez les informations d’identification du compte de service :
Vous pouvez utiliser l'assistant BigQuery d'identification pour accélérer cette étape : [créer des informations d'identification](https://console.cloud.google.com/apis/credentials/wizard?api=bigquery.googleapis.com).
Pour créer un compte de service dans GCP, suivez le didacticiel disponible dans la section [Créer des comptes de service](https://cloud.google.com/iam/docs/service-accounts-create).
+ Lorsque vous sélectionnez **un projet**, sélectionnez le projet contenant votre BigQuery tableau.
+ Lorsque vous sélectionnez des rôles GCP IAM pour votre compte de service, ajoutez ou créez un rôle qui accordera les autorisations appropriées pour exécuter des BigQuery tâches de lecture, d'écriture ou de création BigQuery de tables.
Pour créer des informations d’identification pour votre compte de service, suivez le didacticiel disponible dans la section [Créer une clé de compte de service](https://cloud.google.com/iam/docs/keys-create-delete#creating).
+ Lorsque vous sélectionnez le type de clé, sélectionnez **JSON**.
Vous devriez maintenant avoir téléchargé un fichier JSON contenant les informations d’identification de votre compte de service. Il doit ressembler à l’exemple ci-dessous.
```
{
"type": "service_account",
"project_id": "*****",
"private_key_id": "*****",
"private_key": "*****",
"client_email": "*****",
"client_id": "*****",
"auth_uri": "https://accounts.google.com/o/oauth2/auth",
"token_uri": "https://oauth2.googleapis.com/token",
"auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
"client_x509_cert_url": "*****",
"universe_domain": "googleapis.com"
}
```
1. Téléchargez le fichier JSON de vos informations d'identification sur un emplacement Amazon S3 correctement sécurisé. Conservez le chemin d'accès au fichier *s3secretpath* pour les étapes futures.
1. Dans AWS Secrets Manager, créez un secret à l'aide de vos informations d'identification Google Cloud Platform. Pour créer un secret dans Secrets Manager, suivez le didacticiel disponible dans la [section Créer un AWS Secrets Manager secret](https://docs.aws.amazon.com//secretsmanager/latest/userguide/create_secret.html) dans la AWS Secrets Manager documentation. Après avoir créé le secret, conservez le nom du secret *secretName* pour l'étape suivante.
Lorsque vous créez des Key/value paires, spécifiez les clés et les valeurs comme suit :
+ Pour les `client_id` clés`token_uri`,,`client_x509_cert_url`,,`private_key_id`,,`project_id`,,`universe_domain`,,`auth_provider_x509_cert_url`,,`auth_uri`,,`client_email`,,`private_key`,,`type`,,,,,,,,,,,,,, spécifiez les valeurs correspondantes dans le fichier JSON téléchargé.
+ Pour la `spark.hadoop.google.cloud.auth.service.account.json.keyfile` clé, spécifiez le*s3secretpath*.
1. Dans le catalogue de données AWS Glue, créez une connexion en suivant les étapes décrites dans[Ajouter une AWS Glue connexion](console-connections.md). Après avoir créé la connexion, conservez le nom de la connexion pour l'étape suivante. *connectionName*
+ Lorsque vous sélectionnez un **type de connexion**, sélectionnez Google BigQuery.
+ Lorsque vous sélectionnez un **AWS secret**, indiquez-le*secretName*.
1. Accordez au rôle IAM associé à votre tâche AWS Glue l'autorisation de lire*secretName*.
1. Dans la configuration de votre tâche AWS Glue*connectionName*, fournissez une **connexion réseau supplémentaire**.
## Lecture à partir de BigQuery tables
**Prérequis :**
+ Un BigQuery tableau que vous aimeriez lire. Vous aurez besoin des noms de BigQuery table et de jeu de données dans le formulaire`[dataset].[table]`. Appelons ça*tableName*.
+ Le projet de facturation de la BigQuery table. Vous aurez besoin du nom du projet,*parentProject*. S'il n'existe aucun projet parent de facturation, utilisez le projet contenant la table.
+ BigQuery informations d'authentification. Suivez les étapes *pour gérer vos informations de connexion avec AWS Glue* afin de configurer vos informations d'authentification. Vous aurez besoin du nom de la connexion AWS Glue,*connectionName*.
Par exemple :
```
bigquery_read = glueContext.create_dynamic_frame.from_options(
connection_type="bigquery",
connection_options={
"connectionName": "connectionName",
"parentProject": "parentProject",
"sourceType": "table",
"table": "tableName",
}
```
Vous pouvez également fournir une requête pour filtrer les résultats renvoyés à votre DynamicFrame. Vous devrez configurer `query`, `sourceType`, `viewsEnabled` et `materializationDataset`.
Par exemple :
**Prérequis supplémentaires :**
Vous devrez créer ou identifier un BigQuery jeu de données dans lequel vous BigQuery pourrez écrire des vues matérialisées pour vos requêtes. *materializationDataset*
Vous devrez accorder les autorisations GCP IAM appropriées à votre compte de service pour créer des tables dans. *materializationDataset*
```
glueContext.create_dynamic_frame.from_options(
connection_type="bigquery",
connection_options={
"connectionName": "connectionName",
"materializationDataset": materializationDataset,
"parentProject": "parentProject",
"viewsEnabled": "true",
"sourceType": "query",
"query": "select * from bqtest.test"
}
)
```
## Écrire sur des BigQuery tables
Cet exemple écrit directement dans le BigQuery service. BigQuery supporte également la méthode d'écriture « indirecte ». Pour plus d'informations sur les écritures indirectes, consultez [Utiliser l'écriture indirecte avec Google BigQuery](#aws-glue-programming-etl-connect-bigquery-indirect-write).
**Prérequis :**
+ Une BigQuery table dans laquelle vous souhaitez écrire. Vous aurez besoin des noms de BigQuery table et de jeu de données dans le formulaire`[dataset].[table]`. Vous pouvez également fournir un nouveau nom de table qui sera automatiquement créé. Appelons ça*tableName*.
+ Le projet de facturation de la BigQuery table. Vous aurez besoin du nom du projet,*parentProject*. S'il n'existe aucun projet parent de facturation, utilisez le projet contenant la table.
+ BigQuery informations d'authentification. Suivez les étapes *pour gérer vos informations de connexion avec AWS Glue* afin de configurer vos informations d'authentification. Vous aurez besoin du nom de la connexion AWS Glue,*connectionName*.
Par exemple :
```
bigquery_write = glueContext.write_dynamic_frame.from_options(
frame=frameToWrite,
connection_type="bigquery",
connection_options={
"connectionName": "connectionName",
"parentProject": "parentProject",
"writeMethod": "direct",
"table": "tableName",
}
)
```
## BigQuery référence des options de connexion
+ `project` : par défaut, le compte de service Google Cloud par défaut. Utilisé pour la lecture/l'écriture. Le nom d'un projet Google Cloud associé à votre table.
+ `table` : (obligatoire) utilisé pour la lecture/l'écriture. Le nom de votre BigQuery table dans le format`[[project:]dataset.]`.
+ `dataset` : obligatoire lorsqu'il n'est pas défini par l'option `table`. Utilisé pour la lecture/l'écriture. Le nom du jeu de données contenant votre BigQuery table.
+ `parentProject` : par défaut, le compte de service Google Cloud par défaut. Utilisé pour la lecture/l'écriture. Nom d'un projet Google Cloud associé à `project` utilisé pour la facturation.
+ `sourceType` : utilisé pour la lecture. Obligatoire lors de la lecture. Valeurs valides : `table` `query` indique à AWS Glue si vous allez lire par table ou par requête.
+ `materializationDataset` : utilisé pour la lecture. Valeurs valides : chaînes. Nom d'un BigQuery ensemble de données utilisé pour stocker les matérialisations des vues.
+ `viewsEnabled` : utilisé pour la lecture. Par défaut : false. Valeurs valides : true, false. Détermine si BigQuery vous souhaitez utiliser les vues.
+ `query` : utilisé pour la lecture. Utilisé quand `viewsEnabled` est true. Une requête GoogleSQL DQL.
+ `temporaryGcsBucket` : utilisé pour écrire. Obligatoire lorsque `writeMethod` est défini sur la valeur par défaut (`indirect`). Nom d'un bucket Google Cloud Storage utilisé pour stocker une forme intermédiaire de vos données lorsque vous y écrivez BigQuery.
+ `writeMethod` : `indirect` par défaut. Valeurs valides : `direct`, `indirect`. Utilisé pour écrire. Spécifie la méthode utilisée pour écrire les données.
+ S'il est défini sur`direct`, votre connecteur écrira à l'aide de l'API BigQuery Storage Write.
+ S'il est défini sur`indirect`, votre connecteur écrira dans Google Cloud Storage, puis le transférera à l' BigQuery aide d'une opération de chargement. Votre compte de service Google Cloud aura besoin des autorisations GCS appropriées.
## Utiliser l'écriture indirecte avec Google BigQuery
Cet exemple utilise l'écriture indirecte, qui écrit des données dans Google Cloud Storage et les copie dans Google BigQuery.
**Prérequis :**
Vous aurez besoin d'un bucket Google Cloud Storage temporaire*temporaryBucket*.
Le rôle GCP IAM pour le compte de service GCP de AWS Glue nécessitera les autorisations GCS appropriées pour y accéder. *temporaryBucket*
**Configuration supplémentaire :**
**Pour configurer l'écriture indirecte avec BigQuery :**
1. Évaluez [Configuration des BigQuery connexions](#aws-glue-programming-etl-connect-bigquery-configure) et localisez ou retéléchargez le fichier JSON de vos informations d'identification GCP. Identifiez*secretName*, le AWS Secrets Manager secret de la connexion Google BigQuery AWS Glue utilisée dans le cadre de votre travail.
1. Téléchargez le fichier JSON de vos informations d'identification sur un emplacement Amazon S3 correctement sécurisé. Conservez le chemin d'accès au fichier *s3secretpath* pour les étapes futures.
1. Modifier*secretName*, ajouter la `spark.hadoop.google.cloud.auth.service.account.json.keyfile` clé. Définissez la valeur sur *s3secretpath*.
1. Accordez à votre job AWS Glue Amazon S3 IAM des autorisations d'accès*s3secretpath*.
Vous pouvez désormais fournir l'emplacement temporaire de votre compartiment GCS à votre méthode d'écriture. Vous n'avez pas besoin de fournir `writeMethod`, car `indirect` est historiquement la valeur par défaut.
```
bigquery_write = glueContext.write_dynamic_frame.from_options(
frame=frameToWrite,
connection_type="bigquery",
connection_options={
"connectionName": "connectionName",
"parentProject": "parentProject",
"temporaryGcsBucket": "temporaryBucket",
"table": "tableName",
}
)
```
# Connexions JDBC
Certains types de bases de données, généralement relationnelles, prennent en charge la connexion via le standard JDBC. Pour plus d'informations sur JDBC, consultez la documentation de l'API [Java JDBC](https://docs.oracle.com/javase/8/docs/technotes/guides/jdbc/). AWS Glue prend en charge nativement la connexion à certaines bases de données via ses connecteurs JDBC. Les bibliothèques JDBC sont fournies dans les jobs Glue Spark. AWS Lorsque vous vous connectez à ces types de bases de données à l’aide des bibliothèques AWS Glue, vous avez accès à un ensemble standard d’options.
Les valeurs connectionType JDBC sont les suivantes :
+ `"connectionType": "sqlserver"` : Désigne une connexion à une base de données Microsoft SQL Server.
+ `"connectionType": "mysql"` : Désigne une connexion à une base de données MySQL.
+ `"connectionType": "oracle"` : Désigne une connexion à une base de données Oracle.
+ `"connectionType": "postgresql"` : Désigne une connexion à une base de données PostgreSQL.
+ `"connectionType": "redshift"` : désigne une connexion à une base de données Amazon Redshift. Pour de plus amples informations, veuillez consulter [Connexions Redshift](aws-glue-programming-etl-connect-redshift-home.md).
Le tableau suivant répertorie les versions du pilote JDBC prises en charge par AWS Glue.
| Produit (langue française non garantie) | Versions du pilote JDBC pour Glue 5.1 | Versions du pilote JDBC pour Glue 5.0 | Versions de pilotes JDBC pour Glue 4.0 | Versions de pilotes JDBC pour Glue 3.0 | Versions de pilotes JDBC pour Glue 0.9, 1.0, 2.0 |
| --- | --- | --- | --- | --- | --- |
| Microsoft SQL Server | 10.2.0 | 10.2.0 | 9.4.0 | 7.x | 6.x |
| MySQL | 8,0,33 | 8,0,33 | 8.0.23 | 8.0.23 | 5.1 |
| Oracle Database | 23,3.0,23,09 | 23,3.0,23,09 | 21,7 | 21,1 | 11.2 |
| PostgreSQL | 42.7.3 | 42.7.3 | 42,3.6 | 42,2,18 | 42.1.x |
| Amazon Redshift \$1 | redshift-jdbc42-2.1.0.29 | redshift-jdbc42-2.1.0.29 | redshift-jdbc42-2.1.0.16 | redshift-jdbc41-1.2.12.1017 | redshift-jdbc41-1.2.12.1017 |
\$1 Pour le type de connexion Amazon Redshift, toutes les autres name/value paires d'options incluses dans les options de connexion pour une connexion JDBC, y compris les options de formatage, sont transmises directement au SparkSQL sous-jacent. DataSource Dans les jobs AWS Glue with Spark de AWS Glue 4.0 et des versions ultérieures, le connecteur natif AWS Glue pour Amazon Redshift utilise l'intégration Amazon Redshift pour Apache Spark. Pour plus d’informations, consultez [Intégration d’Amazon Redshift à Apache Spark](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html). Pour les versions précédentes, consultez [Amazon Redshift data source for Spark](https://github.com/databricks/spark-redshift).
Pour configurer votre Amazon VPC afin de vous connecter aux magasins de données Amazon RDS à l’aide de JDBC, reportez-vous à [Configuration d’Amazon VPC pour les connexions JDBC aux entrepôts de données Amazon RDS depuis AWS Glue](setup-vpc-for-glue-access.md).
**Note**
AWS Les tâches Glue ne sont associées qu'à un seul sous-réseau lors d'une exécution. Cela peut avoir une incidence sur votre capacité à vous connecter à plusieurs sources de données par le biais de la même tâche. Ce comportement n’est pas limité aux sources JDBC.
**Topics**
+ [
## Référence des options de connexion JDBC
](#aws-glue-programming-etl-connect-jdbc)
+ [
## Utiliser sampleQuery
](#aws-glue-programming-etl-jdbc-samplequery)
+ [
## Utiliser un pilote JDBC personnalisé
](#aws-glue-programming-etl-jdbc-custom-driver)
+ [
# Lecture en parallèle à partir de tables JDBC
](run-jdbc-parallel-read-job.md)
+ [
# Configuration d’Amazon VPC pour les connexions JDBC aux entrepôts de données Amazon RDS depuis AWS Glue
](setup-vpc-for-glue-access.md)
## Référence des options de connexion JDBC
Si une connexion JDBC AWS Glue est déjà définie, vous pouvez réutiliser les propriétés de configuration qui y sont définies, telles que : url, utilisateur et mot de passe ; vous n'avez donc pas à les spécifier dans le code en tant qu'options de connexion. Cette fonctionnalité est disponible dans AWS Glue 3.0 et versions ultérieures. Pour ce faire, utilisez les propriétés de connexion suivantes :
+ `"useConnectionProperties"` : à définir sur « true » pour indiquer que vous souhaitez utiliser la configuration à partir d’une connexion.
+ `"connectionName"` : saisissez le nom de connexion à partir duquel récupérer la configuration. La connexion doit être définie dans la même région que la tâche.
Utilisez ces options de connexion avec les connexions JDBC :
+ `"url"` : (Obligatoire) URL JDBC de la base de données.
+ `"dbtable"` : (obligatoire) table de la base de données à partir de laquelle la lecture doit s’effectuer. 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é.
+ `"user"` : (Obligatoire) Nom d’utilisateur à utiliser lors de la connexion.
+ `"password"` : (Obligatoire) Mot de passe à utiliser lors de la connexion.
+ (Facultatif) les options suivantes vous permettent de fournir un pilote JDBC personnalisé. Utilisez ces options si vous devez utiliser un pilote que AWS Glue ne prend pas en charge de manière native.
Les tâches ETL peuvent utiliser différentes versions de pilote JDBC pour la source de données et la cible, même si la source et la cible sont le même produit de base de données. Cela vous permet de migrer des données entre les bases de données source et cible avec différentes versions. Pour utiliser ces options, vous devez d’abord charger le fichier JAR du pilote JDBC vers Amazon S3.
+ `"customJdbcDriverS3Path"` : chemin Amazon S3 du pilote JDBC personnalisé.
+ `"customJdbcDriverClassName"` : nom de la classe du pilote JDBC.
+ `"bulkSize"` : (Facultatif) Utilisé pour configurer des insertions parallèles pour accélérer les charges groupées dans les cibles JDBC. Spécifiez une valeur entière pour le degré de parallélisme à utiliser lors de l’écriture ou de l’insertion de données. Cette option permet d’améliorer les performances d’écriture dans les bases de données telles que le référentiel d’utilisateurs Arch (AUR).
+ `"hashfield"` : (facultatif) chaîne utilisée pour indiquer le nom d’une colonne de la table JDBC à utiliser pour diviser les données en partitions lors de la lecture de tables JDBC en parallèle. Indiquez « hashfield » OU « hashexpression ». Pour de plus amples informations, veuillez consulter [Lecture en parallèle à partir de tables JDBC](run-jdbc-parallel-read-job.md).
+ `"hashexpression"` : (facultatif) une clause de sélection SQL renvoyant un nombre entier. Utilisée pour diviser les données d’une table JDBC en partitions lors de la lecture de tables JDBC en parallèle. Indiquez « hashfield » OU « hashexpression ». Pour de plus amples informations, veuillez consulter [Lecture en parallèle à partir de tables JDBC](run-jdbc-parallel-read-job.md).
+ `"hashpartitions"` : (facultatif) un entier positif. Utilisé pour indiquer le nombre de lectures parallèles de la table JDBC lors de la lecture de tables JDBC en parallèle. Par défaut : 7. Pour de plus amples informations, veuillez consulter [Lecture en parallèle à partir de tables JDBC](run-jdbc-parallel-read-job.md).
+ `"sampleQuery"` : (facultatif) une instruction de requête SQL personnalisée. Utilisé pour spécifier un sous-ensemble d’informations dans une table afin de récupérer un échantillon du contenu de la table. **Lorsqu'elle est configurée sans tenir compte de vos données, elle peut être moins efficace que DynamicFrame les méthodes, entraînant des délais d'attente ou des erreurs de mémoire insuffisante.** Pour de plus amples informations, veuillez consulter [Utiliser sampleQuery](#aws-glue-programming-etl-jdbc-samplequery).
+ `"enablePartitioningForSampleQuery"` : (facultatif) une valeur booléenne. Par défaut : faux. Utilisé pour permettre la lecture des tables JDBC en parallèle lorsque vous indiquez `sampleQuery`. **S'il est défini sur true, `sampleQuery` il doit se terminer par « where » ou « and » pour que AWS Glue ajoute des conditions de partitionnement.** Pour de plus amples informations, veuillez consulter [Utiliser sampleQuery](#aws-glue-programming-etl-jdbc-samplequery).
+ `"sampleSize"` : (facultatif) un entier positif. Limite le nombre de lignes renvoyées par l’exemple de requête. Fonctionne uniquement lorsque `enablePartitioningForSampleQuery` a la valeur « true ». Si le partitionnement n’est pas activé, vous devez plutôt ajouter directement `"limit x"` dans `sampleQuery` pour limiter la taille. Pour de plus amples informations, veuillez consulter [Utiliser sampleQuery](#aws-glue-programming-etl-jdbc-samplequery).
## Utiliser sampleQuery
Cette section explique comment utiliser `sampleQuery`, `sampleSize` et `enablePartitioningForSampleQuery`.
`sampleQuery` peut être un moyen efficace d’échantillonner quelques lignes de votre jeu de données. Par défaut, la requête est exécutée par un exécuteur unique. Lorsqu'elle est configurée sans tenir compte de vos données, elle peut être moins efficace que DynamicFrame les méthodes, entraînant des délais d'attente ou des erreurs de mémoire insuffisante. L’exécution de SQL sur la base de données sous-jacente dans le cadre de votre pipeline ETL n’est généralement nécessaire que pour des raisons de performances. Si vous essayez de prévisualiser quelques lignes de votre jeu de données, pensez à utiliser [show](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-show). Si vous essayez de transformer votre ensemble de données à l'aide de SQL, pensez [toDF](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-toDF) à l'utiliser pour définir une transformation SparkSQL par rapport à vos données dans un formulaire. DataFrame
Bien que votre requête puisse manipuler diverses tables, `dbtable` reste obligatoire.
**Utilisation de sampleQuery pour récupérer un échantillon de votre table**
Lorsque vous utilisez le comportement SampleQuery par défaut pour récupérer un échantillon de vos données, AWS Glue ne s'attend pas à un débit important. Il exécute donc votre requête sur un seul exécuteur. Afin de limiter les données que vous fournissez et de ne pas entraîner de problèmes de performances, nous vous suggérons de fournir une clause `LIMIT` à SQL.
**Example Utiliser SampleQuery sans partitionnement**
L’exemple de code suivant illustre comment utiliser `sampleQuery` sans partitionnement.
```
//A full sql query statement.
val query = "select name from $tableName where age > 0 limit 1"
val connectionOptions = JsonOptions(Map(
"url" -> url,
"dbtable" -> tableName,
"user" -> user,
"password" -> password,
"sampleQuery" -> query ))
val dyf = glueContext.getSource("mysql", connectionOptions)
.getDynamicFrame()
```
**Utilisation de sampleQuery sur des jeux de données plus volumineux**
Si vous lisez un jeu de données volumineux, vous devrez peut-être activer le partitionnement JDBC pour interroger une table en parallèle. Pour de plus amples informations, veuillez consulter [Lecture en parallèle à partir de tables JDBC](run-jdbc-parallel-read-job.md). Pour utiliser `sampleQuery` avec le partitionnement JDBC, paramétrez `enablePartitioningForSampleQuery` sur la valeur « true ». L’activation de cette fonctionnalité nécessite que vous apportiez quelques modifications à votre `sampleQuery`.
Lorsque vous utilisez le partitionnement JDBC avec`sampleQuery`, votre requête doit se terminer par « where » ou « and » pour que AWS Glue ajoute des conditions de partitionnement.
Si vous souhaitez limiter les résultats de votre sampleQuery lorsque vous lisez des tables JDBC en parallèle, définissez le paramètre `"sampleSize"` plutôt que d’indiquer une clause `LIMIT`.
**Example Utiliser SampleQuery avec le partitionnement JDBC**
L’exemple de code suivant illustre comment utiliser `sampleQuery` avec partitionnement JDBC.
```
//note that the query should end with "where" or "and" if use with JDBC partitioning.
val query = "select name from $tableName where age > 0 and"
//Enable JDBC partitioning by setting hashfield.
//to use sampleQuery with partitioning, set enablePartitioningForSampleQuery.
//use sampleSize to limit the size of returned data.
val connectionOptions = JsonOptions(Map(
"url" -> url,
"dbtable" -> tableName,
"user" -> user,
"password" -> password,
"hashfield" -> primaryKey,
"sampleQuery" -> query,
"enablePartitioningForSampleQuery" -> true,
"sampleSize" -> "1" ))
val dyf = glueContext.getSource("mysql", connectionOptions)
.getDynamicFrame()
```
**Notes et restrictions :**
Les exemples de requêtes ne peuvent pas être utilisés avec des signets de tâche. L’état du signet sera ignoré lorsque la configuration sera fournie pour les deux.
## Utiliser un pilote JDBC personnalisé
Les exemples de code suivants montrent comment lire et écrire des bases de données JDBC avec des pilotes JDBC personnalisés. Ils présentent la lecture d’une version d’un produit de base de données et l’écriture dans une version ultérieure du même produit.
------
#### [ Python ]
```
import sys
from awsglue.transforms import *
from awsglue.utils import getResolvedOptions
from pyspark.context import SparkContext, SparkConf
from awsglue.context import GlueContext
from awsglue.job import Job
import time
from pyspark.sql.types import StructType, StructField, IntegerType, StringType
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
# Construct JDBC connection options
connection_mysql5_options = {
"url": "jdbc:mysql://:3306/db",
"dbtable": "test",
"user": "admin",
"password": "pwd"}
connection_mysql8_options = {
"url": "jdbc:mysql://:3306/db",
"dbtable": "test",
"user": "admin",
"password": "pwd",
"customJdbcDriverS3Path": "s3://amzn-s3-demo-bucket/mysql-connector-java-8.0.17.jar",
"customJdbcDriverClassName": "com.mysql.cj.jdbc.Driver"}
connection_oracle11_options = {
"url": "jdbc:oracle:thin:@//:1521/ORCL",
"dbtable": "test",
"user": "admin",
"password": "pwd"}
connection_oracle18_options = {
"url": "jdbc:oracle:thin:@//:1521/ORCL",
"dbtable": "test",
"user": "admin",
"password": "pwd",
"customJdbcDriverS3Path": "s3://amzn-s3-demo-bucket/ojdbc10.jar",
"customJdbcDriverClassName": "oracle.jdbc.OracleDriver"}
# Read from JDBC databases with custom driver
df_mysql8 = glueContext.create_dynamic_frame.from_options(connection_type="mysql",
connection_options=connection_mysql8_options)
# Read DynamicFrame from MySQL 5 and write to MySQL 8
df_mysql5 = glueContext.create_dynamic_frame.from_options(connection_type="mysql",
connection_options=connection_mysql5_options)
glueContext.write_from_options(frame_or_dfc=df_mysql5, connection_type="mysql",
connection_options=connection_mysql8_options)
# Read DynamicFrame from Oracle 11 and write to Oracle 18
df_oracle11 = glueContext.create_dynamic_frame.from_options(connection_type="oracle",
connection_options=connection_oracle11_options)
glueContext.write_from_options(frame_or_dfc=df_oracle11, connection_type="oracle",
connection_options=connection_oracle18_options)
```
------
#### [ Scala ]
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.MappingSpec
import com.amazonaws.services.glue.errors.CallSite
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.DynamicFrame
import org.apache.spark.SparkContext
import scala.collection.JavaConverters._
object GlueApp {
val MYSQL_5_URI: String = "jdbc:mysql://:3306/db"
val MYSQL_8_URI: String = "jdbc:mysql://:3306/db"
val ORACLE_11_URI: String = "jdbc:oracle:thin:@//:1521/ORCL"
val ORACLE_18_URI: String = "jdbc:oracle:thin:@//:1521/ORCL"
// Construct JDBC connection options
lazy val mysql5JsonOption = jsonOptions(MYSQL_5_URI)
lazy val mysql8JsonOption = customJDBCDriverJsonOptions(MYSQL_8_URI, "s3://amzn-s3-demo-bucket/mysql-connector-java-8.0.17.jar", "com.mysql.cj.jdbc.Driver")
lazy val oracle11JsonOption = jsonOptions(ORACLE_11_URI)
lazy val oracle18JsonOption = customJDBCDriverJsonOptions(ORACLE_18_URI, "s3://amzn-s3-demo-bucket/ojdbc10.jar", "oracle.jdbc.OracleDriver")
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
// Read from JDBC database with custom driver
val df_mysql8: DynamicFrame = glueContext.getSource("mysql", mysql8JsonOption).getDynamicFrame()
// Read DynamicFrame from MySQL 5 and write to MySQL 8
val df_mysql5: DynamicFrame = glueContext.getSource("mysql", mysql5JsonOption).getDynamicFrame()
glueContext.getSink("mysql", mysql8JsonOption).writeDynamicFrame(df_mysql5)
// Read DynamicFrame from Oracle 11 and write to Oracle 18
val df_oracle11: DynamicFrame = glueContext.getSource("oracle", oracle11JsonOption).getDynamicFrame()
glueContext.getSink("oracle", oracle18JsonOption).writeDynamicFrame(df_oracle11)
Job.commit()
}
private def jsonOptions(url: String): JsonOptions = {
new JsonOptions(
s"""{"url": "${url}",
|"dbtable":"test",
|"user": "admin",
|"password": "pwd"}""".stripMargin)
}
private def customJDBCDriverJsonOptions(url: String, customJdbcDriverS3Path: String, customJdbcDriverClassName: String): JsonOptions = {
new JsonOptions(
s"""{"url": "${url}",
|"dbtable":"test",
|"user": "admin",
|"password": "pwd",
|"customJdbcDriverS3Path": "${customJdbcDriverS3Path}",
|"customJdbcDriverClassName" : "${customJdbcDriverClassName}"}""".stripMargin)
}
}
```
------
# Lecture en parallèle à partir de tables JDBC
Vous pouvez définir les propriétés de votre table JDBC afin d'autoriser AWS Glue à lire les données en parallèle. Lorsque vous définissez certaines propriétés, vous demandez à AWS Glue d'exécuter des requêtes SQL parallèles sur des partitions logiques de vos données. Vous pouvez contrôler le partitionnement en définissant un champ de hachage ou une expression de hachage. Vous pouvez également contrôler le nombre de lectures parallèles utilisées pour accéder à vos données.
La lecture en parallèle à partir de tables JDBC est une technique d'optimisation susceptible d'améliorer les performances. Pour plus d'informations sur le processus permettant d'identifier le moment où cette technique est appropriée, consultez la section [Réduire la quantité de données analysées](https://docs.aws.amazon.com/prescriptive-guidance/latest/tuning-aws-glue-for-apache-spark/parallelize-tasks.html) dans le guide des *meilleures pratiques pour le réglage des performances AWS Glue pour les tâches Apache Spark* sur les directives AWS prescriptives.
Pour activer les lectures parallèles, vous pouvez définir des paires clé-valeur dans le champ des paramètres de la structure de votre table. Utilisez la notation JSON pour définir une valeur pour le champ des paramètres de votre table. Pour plus d'informations sur la modification des propriétés d'une table, consultez [Affichage et gestion des détails d’une table](tables-described.md#console-tables-details). Vous pouvez également activer les lectures parallèles lorsque vous appelez les méthodes d'extraction, de transformation et de chargement (ETL) `create_dynamic_frame_from_options` et `create_dynamic_frame_from_catalog`. Pour plus d'informations sur la spécification d'options dans ces méthodes, consultez [from\$1options](aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader-from_options) et [from\$1catalog](aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader-from_catalog).
Vous pouvez utiliser cette méthode pour les tables JDBC, c'est-à-dire la plupart des tables dont la base de données est un magasin de données JDBC. Ces propriétés sont ignorées lors de la lecture des tables Amazon Redshift et Amazon S3.
**hashfield**
Définissez `hashfield` sur le nom d'une colonne de la table JDBC à utiliser pour diviser les données en partitions. Pour de meilleurs résultats, cette colonne doit avoir une distribution uniforme des valeurs pour répartir les données entre les partitions. Cette colonne peut avoir n'importe quel type de données. AWS Glue génère des requêtes qui ne se chevauchent pas et qui s'exécutent en parallèle pour lire les données partitionnées à partir de cette colonne. Par exemple, si vos données sont réparties de façon uniforme par mois, vous pouvez utiliser la colonne `month` pour lire chaque mois de données en parallèle.
```
'hashfield': 'month'
```
AWS Glue crée une requête pour hacher la valeur du champ vers un numéro de partition et exécute la requête pour toutes les partitions en parallèle. Pour utiliser votre propre requête de partition d'une lecture de table, fournissez un élément `hashexpression` au lieu d'un élément `hashfield`.
**hashexpression**
Définissez `hashexpression` sur une expression SQL (conforme à la syntaxe du moteur de base de données JDBC) qui renvoie un nombre entier. Une expression simple représente le nom d'une colonne numérique dans la table. AWS Glue génère des requêtes SQL pour lire les données JDBC en parallèle à l'aide de l'élément `hashexpression` dans la clause `WHERE` pour partitionner les données.
Par exemple, utilisez la colonne numérique `customerID` pour lire les données partitionnées en fonction d'un numéro de client.
```
'hashexpression': 'customerID'
```
Pour qu'AWS Glue contrôle le partitionnement, fournissez un élément `hashfield` au lieu de `hashexpression`.
**hashpartitions**
Définissez l'élément `hashpartitions` sur le nombre de lectures parallèles de la table JDBC. Si cette propriété n'est pas définie, la valeur par défaut est 7.
Par exemple, définissez le nombre de lectures parallèles sur `5` afin qu'AWS Glue lise vos données avec cinq requêtes (ou moins).
```
'hashpartitions': '5'
```
# Configuration d’Amazon VPC pour les connexions JDBC aux entrepôts de données Amazon RDS depuis AWS Glue
Lorsque vous utilisez JDBC pour vous connecter à des bases de données dans Amazon RDS, vous devez effectuer une configuration supplémentaire. Pour permettre aux composants AWS Glue de communiquer avec Amazon RDS, vous devez configurer l’accès à vos entrepôts de données de données Amazon RDS dans Amazon VPC. Pour permettre à AWS Glue de communiquer entre ses composants, spécifiez un groupe de sécurité avec une règle entrante avec référence circulaire pour tous les ports TCP. En créant une règle avec référence circulaire, vous pouvez restreindre la source au même groupe de sécurité dans le VPC. Une règle d’autoréférencement n’ouvrira pas le VPC à tous les réseaux. Le groupe de sécurité par défaut pour votre VPC peut déjà avoir une règle entrante avec référence circulaire pour ALL Traffic.
**Pour configurer l'accès entre les magasins de données AWS Glue et Amazon RDS**
1. Connectez-vous à la console Amazon RDS AWS Management Console et ouvrez-la à [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)l'adresse.
1. Dans la console Amazon RDS, identifiez le ou les groupes de sécurité utilisés pour contrôler l’accès à votre base de données Amazon RDS.
Dans le volet de navigation de gauche, choisissez **Bases de données**, puis sélectionnez l’instance à laquelle vous souhaitez vous connecter dans la liste du volet principal.
Sur la page détaillée de la base de données, recherchez **Groupes de sécurité VPC** dans l’onglet **Connectivité et sécurité**.
1. En fonction de l'architecture de votre réseau, identifiez le groupe de sécurité associé qu'il est préférable de modifier pour autoriser l'accès au service AWS Glue. Enregistrez son nom *database-security-group* pour référence future. S’il n’existe aucun groupe de sécurité approprié, suivez les instructions pour [fournir l’accès à votre instance de base de données dans votre VPC en créant un groupe de sécurité](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_SettingUp.html) dans la documentation Amazon RDS.
1. Connectez-vous à la console Amazon VPC AWS Management Console et ouvrez-la à l'adresse. [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/)
1. Dans la console Amazon VPC, déterminez comment effectuer la mise à jour. *database-security-group*
Dans le volet de navigation de gauche, choisissez **Groupes *database-security-group* de sécurité**, puis sélectionnez-les dans la liste du volet principal.
1. Identifiez l'ID du groupe de sécurité pour*database-security-group*,*database-sg-id*. Conservez-le en vue d’une référence future.
Sur la page détaillée du groupe de sécurité, recherchez **ID du groupe de sécurité**.
1. Modifiez les règles entrantes pour*database-security-group*, ajoutez une règle d'autoréférencement pour permettre aux AWS Glue composants de communiquer. Plus précisément, ajoutez ou confirmez qu'il existe une règle dans laquelle le **type** est`All TCP`, le **protocole** est`TCP`, la **plage de ports** inclut tous les ports et la **source** est*database-sg-id*. Vérifiez que le groupe de sécurité que vous avez saisi pour **Source** est le même que le groupe de sécurité que vous modifiez.
Sur la page détaillée du groupe de sécurité, sélectionnez **Modifier les règles entrantes**.
La règle entrante ressemble à ce qui suit :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/setup-vpc-for-glue-access.html)
1. Ajoutez des règles pour le trafic sortant.
Sur la page détaillée du groupe de sécurité, sélectionnez **Modifier les règles sortantes**.
Si votre groupe de sécurité autorise tout le trafic sortant, vous n’avez pas besoin de règles distinctes. Par exemple :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/setup-vpc-for-glue-access.html)
Si votre architecture réseau est conçue pour vous permettre de restreindre le trafic sortant, créez les règles de trafic sortant suivantes :
Créez une règle d'autoréférencement où le **type** est`All TCP`, le **protocole** est`TCP`, la **plage de ports** inclut tous les ports et la **destination** est. *database-sg-id* Vérifiez que le groupe de sécurité que vous avez saisi pour **Destination** est le même que le groupe de sécurité que vous modifiez.
Si vous utilisez un point de terminaison d’un VPC Amazon S3, ajoutez une règle HTTPS pour autoriser le trafic du VPC vers Amazon S3. Créez une règle dans laquelle le **type** est`HTTPS`, le **protocole** est`TCP`, la **plage de ports** est `443` et la **destination** est l'ID de la liste de préfixes gérée pour le point de terminaison de la passerelle Amazon S3,*s3-prefix-list-id*. Pour plus d’informations sur les listes de préfixes et les points de terminaison de passerelle Amazon S3, consultez [Gateway endpoints for Amazon S3](https://docs.aws.amazon.com//vpc/latest/privatelink/vpc-endpoints-s3.html) dans la documentation Amazon VPC.
Par exemple :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/setup-vpc-for-glue-access.html)
# Connexions MongoDB
Vous pouvez utiliser AWS Glue for Spark pour lire et écrire dans des tables dans MongoDB et MongoDB Atlas dans AWS Glue 4.0 et versions ultérieures. Vous pouvez vous connecter à MongoDB en utilisant les informations d'identification du nom d'utilisateur et du mot de passe stockées AWS Secrets Manager via une connexion AWS Glue.
Pour plus d'informations sur MongoDB, consultez la [documentation MongoDB](https://www.mongodb.com/docs/).
## Configuration de connexions MongoDB
Pour vous connecter à MongoDB depuis AWS Glue, vous aurez besoin de vos informations d'identification MongoDB, et. *mongodbUser* *mongodbPass*
Pour vous connecter à MongoDB depuis AWS Glue, vous aurez peut-être besoin de certaines conditions préalables :
+ Si votre instance MongoDB se trouve dans un Amazon VPC, configurez Amazon VPC pour permettre à votre tâche AWS Glue de communiquer avec l'instance MongoDB sans que le trafic ne transite par l'Internet public.
Dans Amazon VPC, identifiez ou créez un **VPC**, un **sous-réseau** et un **groupe de sécurité que** AWS Glue utilisera lors de l'exécution de la tâche. En outre, vous devez vous assurer qu'Amazon VPC est configuré pour autoriser le trafic réseau entre votre instance MongoDB et cet emplacement. Selon la configuration de votre réseau, cela peut nécessiter des modifications des règles du groupe de sécurité, du réseau ACLs, des passerelles NAT et des connexions d'appairage.
Vous pouvez ensuite configurer AWS Glue pour l'utiliser avec MongoDB.
**Pour configurer une connexion à MongoDB :**
1. Vous pouvez éventuellement créer un secret à AWS Secrets Manager l'aide de vos informations d'identification MongoDB. Pour créer un secret dans Secrets Manager, suivez le didacticiel disponible dans la [section Créer un AWS Secrets Manager secret](https://docs.aws.amazon.com//secretsmanager/latest/userguide/create_secret.html) dans la AWS Secrets Manager documentation. Après avoir créé le secret, conservez le nom du secret *secretName* pour l'étape suivante.
+ Lorsque vous sélectionnez des **paires clé/valeur**, créez une paire pour la clé `username` contenant la valeur. *mongodbUser*
Lorsque vous sélectionnez des **paires clé/valeur**, créez une paire pour la clé `password` contenant la valeur. *mongodbPass*
1. Dans la console AWS Glue, créez une connexion en suivant les étapes décrites dans[Ajouter une AWS Glue connexion](console-connections.md). Après avoir créé la connexion, conservez le nom de la connexion pour une utilisation future dans AWS Glue. *connectionName*
+ Lorsque vous sélectionnez un **type de connexion**, sélectionnez **MongoDB** ou **MongoDB Atlas**.
+ Lorsque vous sélectionnez une **URL MongoDB** ou une **URL MongoDB Atlas**, indiquez le nom d'hôte de votre instance MongoDB.
Une URL MongoDB est fournie au format `mongodb://mongoHost:mongoPort/mongoDBname`.
Une URL MongoDB Atlas est fournie au format `mongodb+srv://mongoHost/mongoDBname`.
+ Si vous avez choisi de créer un secret Secrets Manager, choisissez le **type AWS Secrets Manager d'identifiant**.
Ensuite, dans **AWS Secret**, fournissez*secretName*.
+ Si vous choisissez de fournir un **nom d'utilisateur et un mot de passe**, fournissez *mongodbUser* et*mongodbPass*.
1. Dans les situations suivantes, vous pouvez avoir besoin d'une configuration supplémentaire :
+
Pour les instances MongoDB hébergées AWS dans un Amazon VPC
+ Vous devrez fournir les informations de connexion Amazon VPC à la connexion AWS Glue qui définit vos informations de sécurité MongoDB. Lorsque vous créez ou mettez à jour votre connexion, définissez le **VPC**, le **sous-réseau** et les **groupes de sécurité** dans les **options réseau**.
Après avoir créé une connexion AWS Glue MongoDB, vous devez effectuer les actions suivantes avant d'appeler votre méthode de connexion :
+ Si vous avez choisi de créer un secret Secrets Manager, accordez au rôle IAM associé à votre tâche AWS Glue l'autorisation de lecture*secretName*.
+ Dans la configuration de votre tâche AWS Glue*connectionName*, fournissez une **connexion réseau supplémentaire**.
Pour utiliser votre connexion AWS Glue MongoDB dans AWS Glue for Spark, indiquez l'`connectionName`option dans votre appel de méthode de connexion. Vous pouvez également suivre les étapes décrites [Utilisation des connexions MongoDB dans les tâches ETL](integrate-with-mongo-db.md) pour utiliser la connexion en conjonction avec le AWS Glue Data Catalog.
## Lecture depuis MongoDB à l'aide d'une connexion Glue AWS
**Prérequis :**
+ Une collection MongoDB à partir de laquelle vous souhaitez lire. Vous aurez besoin des informations d'identification pour la collection.
Une collection MongoDB est identifiée par un nom de base de données et un nom de collection,,*mongodbName*. *mongodbCollection*
+ Une connexion AWS Glue MongoDB configurée pour fournir des informations d'authentification. Suivez les étapes de la procédure précédente *Pour configurer une connexion à MongoDB* afin de configurer vos informations d'authentification. Vous aurez besoin du nom de la connexion AWS Glue,*connectionName*.
Par exemple :
```
mongodb_read = glueContext.create_dynamic_frame.from_options(
connection_type="mongodb",
connection_options={
"connectionName": "connectionName",
"database": "mongodbName",
"collection": "mongodbCollection",
"partitioner": "com.mongodb.spark.sql.connector.read.partitioner.SinglePartitionPartitioner",
"partitionerOptions.partitionSizeMB": "10",
"partitionerOptions.partitionKey": "_id",
"disableUpdateUri": "false",
}
)
```
## Écrire dans des tables MongoDB
Cet exemple écrit les informations d'un fichier existant DynamicFrame *dynamicFrame* dans MongoDB.
**Prérequis :**
+ Une collection MongoDB sur laquelle vous souhaitez écrire. Vous aurez besoin des informations d'identification pour la collection.
Une collection MongoDB est identifiée par un nom de base de données et un nom de collection,,*mongodbName*. *mongodbCollection*
+ Une connexion AWS Glue MongoDB configurée pour fournir des informations d'authentification. Suivez les étapes de la procédure précédente *Pour configurer une connexion à MongoDB* afin de configurer vos informations d'authentification. Vous aurez besoin du nom de la connexion AWS Glue,*connectionName*.
Par exemple :
```
glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type="mongodb",
connection_options={
"connectionName": "connectionName",
"database": "mongodbName",
"collection": "mongodbCollection",
"disableUpdateUri": "false",
"retryWrites": "false",
},
)
```
## Lire et écrire dans des tables MongoDB
Cet exemple écrit les informations d'un fichier existant DynamicFrame *dynamicFrame* dans MongoDB.
**Prérequis :**
+ Une collection MongoDB à partir de laquelle vous souhaitez lire. Vous aurez besoin des informations d'identification pour la collection.
Une collection MongoDB sur laquelle vous souhaitez écrire. Vous aurez besoin des informations d'identification pour la collection.
Une collection MongoDB est identifiée par un nom de base de données et un nom de collection,,*mongodbName*. *mongodbCollection*
+ informations d'authentification MongoDB, et. *mongodbUser* *mongodbPassword*
Par exemple :
------
#### [ Python ]
```
import sys
from awsglue.transforms import *
from awsglue.utils import getResolvedOptions
from pyspark.context import SparkContext, SparkConf
from awsglue.context import GlueContext
from awsglue.job import Job
import time
## @params: [JOB_NAME]
args = getResolvedOptions(sys.argv, ['JOB_NAME'])
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
job = Job(glueContext)
job.init(args['JOB_NAME'], args)
output_path = "s3://some_bucket/output/" + str(time.time()) + "/"
mongo_uri = "mongodb://:27017"
mongo_ssl_uri = "mongodb://:27017"
write_uri = "mongodb://:27017"
read_mongo_options = {
"uri": mongo_uri,
"database": "mongodbName",
"collection": "mongodbCollection",
"username": "mongodbUsername",
"password": "mongodbPassword",
"partitioner": "MongoSamplePartitioner",
"partitionerOptions.partitionSizeMB": "10",
"partitionerOptions.partitionKey": "_id"}
ssl_mongo_options = {
"uri": mongo_ssl_uri,
"database": "mongodbName",
"collection": "mongodbCollection",
"ssl": "true",
"ssl.domain_match": "false"
}
write_mongo_options = {
"uri": write_uri,
"database": "mongodbName",
"collection": "mongodbCollection",
"username": "mongodbUsername",
"password": "mongodbPassword",
}
# Get DynamicFrame from MongoDB
dynamic_frame = glueContext.create_dynamic_frame.from_options(connection_type="mongodb",
connection_options=read_mongo_options)
# Write DynamicFrame to MongoDB
glueContext.write_dynamic_frame.from_options(dynamicFrame, connection_type="mongodb", connection_options=write_mongo_options)
job.commit()
```
------
#### [ Scala ]
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.MappingSpec
import com.amazonaws.services.glue.errors.CallSite
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.DynamicFrame
import org.apache.spark.SparkContext
import scala.collection.JavaConverters._
object GlueApp {
val DEFAULT_URI: String = "mongodb://:27017"
val WRITE_URI: String = "mongodb://:27017"
lazy val defaultJsonOption = jsonOptions(DEFAULT_URI)
lazy val writeJsonOption = jsonOptions(WRITE_URI)
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
// Get DynamicFrame from MongoDB
val dynamicFrame: DynamicFrame = glueContext.getSource("mongodb", defaultJsonOption).getDynamicFrame()
// Write DynamicFrame to MongoDB
glueContext.getSink("mongodb", writeJsonOption).writeDynamicFrame(dynamicFrame)
Job.commit()
}
private def jsonOptions(uri: String): JsonOptions = {
new JsonOptions(
s"""{"uri": "${uri}",
|"database":"mongodbName",
|"collection":"mongodbCollection",
|"username": "mongodbUsername",
|"password": "mongodbPassword",
|"ssl":"true",
|"ssl.domain_match":"false",
|"partitioner": "MongoSamplePartitioner",
|"partitionerOptions.partitionSizeMB": "10",
|"partitionerOptions.partitionKey": "_id"}""".stripMargin)
}
}
```
------
## Référence des options de connexion MongoDB
Désigne une connexion à MongoDB. Les options de connexion sont différentes pour une connexion source et une connexion collecteur.
Les propriétés de connexion suivantes sont partagées entre les connexions source et récepteur :
+ `connectionName` : utilisé pour la lecture/l'écriture. Le nom d'une connexion AWS Glue MongoDB configurée pour fournir des informations d'authentification et de mise en réseau à votre méthode de connexion. Lorsqu'une connexion AWS Glue est configurée comme décrit dans la section précédente[Configuration de connexions MongoDB](#aws-glue-programming-etl-connect-mongodb-configure), la fourniture `connectionName` remplacera le besoin de fournir `"uri"` les options `"username"` et de `"password"` connexion.
+ `"uri"`: (Obligatoire) L'hôte MongoDB à lire, formaté comme `mongodb://:`. Utilisé dans les versions de AWS Glue antérieures à AWS Glue 4.0.
+ `"connection.uri"`: (Obligatoire) L'hôte MongoDB à lire, formaté comme `mongodb://:`. Utilisé dans AWS Glue 4.0 et versions ultérieures.
+ `"username"` : (Obligatoire) Le nom d'utilisateur MongoDB.
+ `"password"` : (Obligatoire) Le mot de passe MongoDB.
+ `"database"`: (Obligatoire) La base de données MongoDB à lire. Cette option peut également être transmise dans `additional_options` lors de l'appel à `glue_context.create_dynamic_frame_from_catalog` dans votre script de tâche.
+ `"collection"` : (Obligatoire) La collection MongoDB à lire. Cette option peut également être transmise dans `additional_options` lors de l'appel à `glue_context.create_dynamic_frame_from_catalog` dans votre script de tâche.
### « connectionType »: « mongodb » comme source
Utilisez les options de connexion suivantes avec `"connectionType": "mongodb"` comme source :
+ `"ssl"` : (Facultatif) Si `true`, lance une connexion SSL. La valeur par défaut est `false`.
+ `"ssl.domain_match"` : (Facultatif) Si `true` et `ssl` est `true`, la vérification de la correspondance de domaine est effectuée. La valeur par défaut est `true`.
+ `"batchSize"` : (Facultatif) : Nombre de documents à renvoyer par lot, utilisé dans le curseur des lots internes.
+ `"partitioner"` : (Facultatif) : Le nom de classe du partitionneur pour lire les données d'entrée de MongoDB. Le connecteur fournit les partitionneurs suivants :
+ `MongoDefaultPartitioner`(par défaut) (Non pris en charge dans AWS Glue 4.0)
+ `MongoSamplePartitioner`(Nécessite MongoDB 3.2 ou version ultérieure) (Non pris en charge dans AWS Glue 4.0)
+ `MongoShardedPartitioner`(Non pris en charge dans AWS Glue 4.0)
+ `MongoSplitVectorPartitioner`(Non pris en charge dans AWS Glue 4.0)
+ `MongoPaginateByCountPartitioner`(Non pris en charge dans AWS Glue 4.0)
+ `MongoPaginateBySizePartitioner`(Non pris en charge dans AWS Glue 4.0)
+ `com.mongodb.spark.sql.connector.read.partitioner.SinglePartitionPartitioner`
+ `com.mongodb.spark.sql.connector.read.partitioner.ShardedPartitioner`
+ `com.mongodb.spark.sql.connector.read.partitioner.PaginateIntoPartitionsPartitioner`
+ `"partitionerOptions"` ( Facultatif) : Options pour le partitionneur désigné. Les options suivantes sont prises en charge pour chaque partitionneur :
+ `MongoSamplePartitioner`: `partitionKey`, `partitionSizeMB`, `samplesPerPartition`
+ `MongoShardedPartitioner`: `shardkey`
+ `MongoSplitVectorPartitioner`: `partitionKey`, `partitionSizeMB`
+ `MongoPaginateByCountPartitioner`: `partitionKey`, `numberOfPartitions`
+ `MongoPaginateBySizePartitioner`: `partitionKey`, `partitionSizeMB`
Pour plus d'informations sur ces options, consultez [Configuration du partitionneur](https://docs.mongodb.com/spark-connector/master/configuration/#partitioner-conf) dans la documentation MongoDB.
### « connectionType »: « mongodb » comme collecteur
Utilisez les options de connexion suivantes avec `"connectionType": "mongodb"` comme collecteur :
+ `"ssl"` : (Facultatif) Si `true`, lance une connexion SSL. La valeur par défaut est `false`.
+ `"ssl.domain_match"` : (Facultatif) Si `true` et `ssl` est `true`, la vérification de la correspondance de domaine est effectuée. La valeur par défaut est `true`.
+ `"extendedBsonTypes"` : (facultatif) si la valeur est `true`, cela active les types BSON étendus lors de l'écriture de données dans MongoDB. La valeur par défaut est `true`.
+ `"replaceDocument"` : (Facultatif) Si `true`, remplace l'ensemble du document lors de l'enregistrement de jeux de données contenant un champ `_id`. Si `false`, seuls les champs du document qui correspondent aux champs du jeu de données sont mis à jour. La valeur par défaut est `true`.
+ `"maxBatchSize"` : (Facultatif) : Taille maximale du lot pour les opérations en bloc lors de l'enregistrement des données. La valeur par défaut est 512.
+ `"retryWrites"`: (Facultatif) : Réessayez automatiquement certaines opérations d'écriture une seule fois si AWS Glue rencontre une erreur réseau.
# Connexions SAP HANA
Vous pouvez utiliser AWS Glue for Spark pour lire et écrire dans des tables dans SAP HANA dans AWS Glue 4.0 et versions ultérieures. Vous pouvez définir ce qu'il faut lire dans SAP HANA à l'aide d'une requête SQL. Vous vous connectez à SAP HANA à l'aide des informations d'identification JDBC stockées via AWS Secrets Manager une connexion AWS Glue SAP HANA.
Pour plus d'informations sur SAP HANA JDBC, consultez [la documentation SAP HANA](https://help.sap.com/docs/SAP_HANA_PLATFORM/0eec0d68141541d1b07893a39944924e/ff15928cf5594d78b841fbbe649f04b4.html).
## Configuration des connexions SAP HANA
Pour vous connecter à SAP HANA depuis AWS Glue, vous devez créer et stocker vos informations d'identification SAP HANA dans un AWS Secrets Manager secret, puis associer ce secret à une connexion SAP HANA AWS Glue. Vous devrez configurer la connectivité réseau entre votre service SAP HANA et AWS Glue.
Pour vous connecter à SAP HANA, vous aurez peut-être besoin de certaines conditions préalables :
+ Si votre service SAP HANA se trouve dans un Amazon VPC, configurez Amazon VPC pour permettre à votre tâche AWS Glue de communiquer avec le service SAP HANA sans que le trafic ne transite par l'Internet public.
Dans Amazon VPC, identifiez ou créez un **VPC**, un **sous-réseau** et un **groupe de sécurité que** AWS Glue utilisera lors de l'exécution de la tâche. En outre, vous devez vous assurer qu'Amazon VPC est configuré pour autoriser le trafic réseau entre votre point de terminaison SAP HANA et cet emplacement. Votre tâche devra établir une connexion TCP avec votre port JDBC SAP HANA. Pour plus d'informations sur les ports SAP HANA, consultez [la documentation SAP HANA](https://help.sap.com/docs/HANA_SMART_DATA_INTEGRATION/7952ef28a6914997abc01745fef1b607/88e2e8bded9e4041ad3ad87dc46c7b55.html?locale=en-US). Selon la configuration de votre réseau, cela peut nécessiter des modifications des règles du groupe de sécurité, du réseau ACLs, des passerelles NAT et des connexions d'appairage.
+ Il n'y a aucune condition préalable supplémentaire si votre point de terminaison SAP HANA est accessible sur Internet.
**Pour configurer une connexion à SAP HANA :**
1. Dans AWS Secrets Manager, créez un secret à l'aide de vos informations d'identification SAP HANA. Pour créer un secret dans Secrets Manager, suivez le didacticiel disponible dans la [section Créer un AWS Secrets Manager secret](https://docs.aws.amazon.com//secretsmanager/latest/userguide/create_secret.html) dans la AWS Secrets Manager documentation. Après avoir créé le secret, conservez le nom du secret *secretName* pour l'étape suivante.
+ Lorsque vous sélectionnez des **paires clé/valeur**, créez une paire pour la clé `username/USERNAME` contenant la valeur. *saphanaUsername*
+ Lorsque vous sélectionnez des **paires clé/valeur**, créez une paire pour la clé `password/PASSWORD` contenant la valeur. *saphanaPassword*
1. Dans la console AWS Glue, créez une connexion en suivant les étapes décrites dans[Ajouter une AWS Glue connexion](console-connections.md). Après avoir créé la connexion, conservez le nom de la connexion pour une utilisation future dans AWS Glue. *connectionName*
+ Lorsque vous sélectionnez un **type de connexion**, sélectionnez SAP HANA.
+ Lorsque vous fournissez l'**URL SAP HANA**, indiquez l'URL de votre instance.
SAP HANA JDBC se présente sous la URLs forme `jdbc:sap://saphanaHostname:saphanaPort/?databaseName=saphanaDBname,ParameterName=ParameterValue`
AWS Glue nécessite les paramètres d'URL JDBC suivants :
+ `databaseName` – une base de données par défaut dans SAP HANA à laquelle se connecter.
+ Lorsque vous sélectionnez un **AWS secret**, fournissez*secretName*.
Après avoir créé une connexion AWS Glue SAP HANA, vous devez suivre les étapes suivantes avant d'exécuter votre tâche AWS Glue :
+ Accordez au rôle IAM associé à votre tâche AWS Glue l'autorisation de lire*secretName*.
+ Dans la configuration de votre tâche AWS Glue*connectionName*, fournissez une **connexion réseau supplémentaire**.
## Lecture à partir de tables SAP HANA
**Prérequis :**
+ Une table SAP HANA à partir de laquelle vous souhaitez lire. Vous aurez besoin des informations d'identification de la table.
Une table peut être spécifiée avec un nom de table SAP HANA et un nom de schéma, sous forme de `schemaName.tableName`. Le nom du schéma et le séparateur « . » ne sont pas obligatoires si la table se trouve dans le schéma par défaut, « public ». Appelle ça*tableIdentifier*. Notez que la base de données est fournie sous forme de paramètre d'URL JDBC dans `connectionName`.
+ Une connexion AWS Glue SAP HANA configurée pour fournir des informations d'authentification. Suivez les étapes de la procédure précédente *Pour configurer une connexion à SAP HANA* afin de configurer vos informations d'authentification. Vous aurez besoin du nom de la connexion AWS Glue,*connectionName*.
Par exemple :
```
saphana_read_table = glueContext.create_dynamic_frame.from_options(
connection_type="saphana",
connection_options={
"connectionName": "connectionName",
"dbtable": "tableIdentifier",
}
)
```
Vous pouvez également fournir une requête SQL SELECT pour filtrer les résultats renvoyés à votre DynamicFrame. Vous devrez configurer `query`.
Par exemple :
```
saphana_read_query = glueContext.create_dynamic_frame.from_options(
connection_type="saphana",
connection_options={
"connectionName": "connectionName",
"query": "query"
}
)
```
## Écrire dans des tables SAP HANA
Cet exemple écrit les informations d'un fichier existant DynamicFrame *dynamicFrame* dans SAP HANA. Si le tableau contient déjà des informations, AWS Glue génère une erreur.
**Prérequis :**
+ Une table SAP HANA dans laquelle vous souhaitez écrire.
Une table peut être spécifiée avec un nom de table SAP HANA et un nom de schéma, sous forme de `schemaName.tableName`. Le nom du schéma et le séparateur « . » ne sont pas obligatoires si la table se trouve dans le schéma par défaut, « public ». Appelle ça*tableIdentifier*. Notez que la base de données est fournie sous forme de paramètre d'URL JDBC dans `connectionName`.
+ Informations d'authentification SAP HANA. Suivez les étapes de la procédure précédente *Pour configurer une connexion à SAP HANA* afin de configurer vos informations d'authentification. Vous aurez besoin du nom de la connexion AWS Glue,*connectionName*.
Par exemple :
```
options = {
"connectionName": "connectionName",
"dbtable": 'tableIdentifier'
}
saphana_write = glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type="saphana",
connection_options=options
)
```
## Référence des options de connexion de SAP HANA
+ `connectionName` — Obligatoire. Utilisé pour la lecture/l'écriture. Nom d'une connexion AWS Glue SAP HANA configurée pour fournir des informations d'authentification et de mise en réseau à votre méthode de connexion.
+ `databaseName` : utilisé pour la lecture/l'écriture. Valeurs valides : noms des bases de données dans SAP HANA. Nom de base de données à laquelle se connecter.
+ `dbtable` — obligatoire pour l'écriture, obligatoire pour la lecture à moins qu'une `query` ne soit fournie. Utilisé pour la lecture/l'écriture. Valeurs valides : contenu d'une clause SAP HANA SQL FROM. Identifie une table dans SAP HANA à laquelle se connecter. Vous pouvez également fournir un SQL autre qu'un nom de table, comme une sous-requête. Pour plus d'informations, consultez la [clause From](https://help.sap.com/docs/SAP_HANA_PLATFORM/4fe29514fd584807ac9f2a04f6754767/20fcf24075191014a89e9dc7b8408b26.html#loio20fcf24075191014a89e9dc7b8408b26__from_clause) dans la documentation SAP HANA.
+ `query` : utilisé pour la lecture. Une requête SAP HANA SQL SELECT définissant ce qui doit être récupéré lors de la lecture à partir de SAP HANA.
# Connexions Snowflake
Vous pouvez utiliser AWS Glue for Spark pour lire et écrire dans des tables dans Snowflake dans AWS Glue 4.0 et versions ultérieures. Vous pouvez lire depuis Snowflake à l'aide d'une requête SQL. Vous pouvez vous connecter à Snowflake à l'aide d'un nom d'utilisateur et d'un mot de passe. Vous pouvez vous référer aux informations d'identification Snowflake stockées dans le catalogue AWS Secrets Manager de données AWS Glue. Les informations d'identification Snowflake du catalogue de données pour AWS Glue for Spark sont stockées séparément des informations d'identification du catalogue de données Snowflake pour les robots d'exploration. Vous devez choisir un type de connexion `SNOWFLAKE` et non un type de connexion `JDBC` configuré pour se connecter à Snowflake.
Pour en savoir plus sur Snowflake, consultez le [site web Snowflake](https://www.snowflake.com/). Pour plus d'informations sur Snowflake on AWS, consultez [Snowflake Data Warehouse sur Amazon Web Services](https://aws.amazon.com/financial-services/partner-solutions/snowflake/).
## Configuration des connexions Snowflake
Il n'y a aucune AWS condition préalable pour se connecter aux bases de données Snowflake disponibles sur Internet.
Vous pouvez éventuellement effectuer la configuration suivante pour gérer vos informations de connexion avec AWS Glue.
**Pour gérer vos informations de connexion avec AWS Glue**
1. Dans Snowflake, générez un utilisateur *snowflakeUser* et un mot de passe. *snowflakePassword*
1. Dans AWS Secrets Manager, créez un secret à l'aide de vos informations d'identification Snowflake. Pour créer un secret dans Secrets Manager, suivez le didacticiel disponible dans la [section Créer un AWS Secrets Manager secret](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html#create_secret_cli) dans la AWS Secrets Manager documentation. Après avoir créé le secret, conservez le nom du secret *secretName* pour l'étape suivante.
+ Lorsque vous sélectionnez des **paires clé/valeur**, créez une paire pour *snowflakeUser* avec la clé. `USERNAME`
+ Lorsque vous sélectionnez des **paires clé/valeur**, créez une paire pour *snowflakePassword* avec la clé. `PASSWORD`
+ Lorsque vous sélectionnez des **paires clé/valeur**, vous pouvez fournir à votre entrepôt Snowflake la clé `sfWarehouse`.
+ Lorsque vous sélectionnez des **paires clé/valeur**, vous pouvez fournir des propriétés de connexion Snowflake supplémentaires en utilisant les noms de propriété Spark correspondants comme clés. Les propriétés prises en charge sont les suivantes :
+ `sfDatabase` : nom de la base de données Snowflake
+ `sfSchema` : nom du schéma Snowflake
+ `sfRole` : nom du rôle Snowflake
+ `pem_private_key` : clé privée pour l’authentification par paire de clés
1. Dans le catalogue de données AWS Glue, créez une connexion en choisissant **Connections**, puis **Create connection**. Suivez les étapes décrites dans l’assistant de connexion pour finaliser le processus :
+ Lorsque vous sélectionnez une **source de données**, sélectionnez Snowflake, puis **Suivant**.
+ Saisissez les détails de connexion tels que l’hôte et le port. Lorsque vous saisissez l’**URL Snowflake** hôte, indiquez l’URL de votre instance Snowflake. L’URL utilisera généralement un nom d’hôte sous la forme `account_identifier.snowflakecomputing.com`. Cependant, le format de l'URL peut varier en fonction du type de compte Snowflake (par exemple AWS, Azure ou hébergé par Snowflake).
+ Lorsque vous sélectionnez le rôle de service IAM, choisissez dans le menu déroulant. Il s'agit du rôle IAM de votre compte qui sera utilisé pour accéder à l'adresse IP AWS Secrets Manager et l'attribuer si un VPC est spécifié.
+ Lorsque vous sélectionnez un **AWS secret**, indiquez-le*secretName*.
1. À l’étape suivante de l’assistant, définissez les propriétés de votre connexion Snowflake.
1. Dans la dernière étape de l’assistant, examinez vos paramètres, puis terminez le processus de création de votre connexion.
Dans les situations suivantes, vous pouvez avoir besoin des éléments suivants :
+
Pour Snowflake hébergé sur un Amazon AWS VPC
+ Vous aurez besoin d'une configuration Amazon VPC appropriée pour Snowflake. Pour plus d'informations sur la configuration de votre Amazon VPC, consultez [AWS PrivateLink et Snowflake](https://docs.snowflake.com/en/user-guide/admin-security-privatelink) dans la documentation Snowflake.
+ Vous aurez besoin d'une configuration Amazon VPC appropriée pour Glue AWS . [Configuration de points de terminaison d’un VPC d’interface (AWS PrivateLink) pour AWS Glue (AWS PrivateLink)](vpc-interface-endpoints.md).
+ Vous devrez créer une connexion AWS Glue Data Catalog qui fournit les informations de connexion Amazon VPC (en plus de l'identifiant d'un AWS Secrets Manager secret qui définit vos informations de sécurité Snowflake). Votre URL changera lors de l'utilisation AWS PrivateLink, comme décrit dans la documentation Snowflake dont le lien figure dans un article précédent.
+ Vous aurez besoin de la configuration de votre tâche pour inclure la connexion au catalogue de données en tant que **connexion réseau supplémentaire**.
## Lecture à partir de tables Snowflake
**Conditions préalables :** une table Snowflake à partir de laquelle vous souhaitez lire. Vous aurez besoin du nom de la table Snowflake,. *tableName* Vous aurez besoin de votre URL*snowflakeUrl*, nom d'utilisateur *snowflakeUser* et mot de passe Snowflake. *snowflakePassword* Si aucun espace de noms par défaut n'est défini pour votre utilisateur Snowflake, vous aurez besoin du nom de la base de données Snowflake et du nom du schéma. *databaseName* *schemaName* De plus, si votre utilisateur Snowflake n'a pas défini d'entrepôt par défaut, vous aurez besoin d'un nom d'entrepôt. *warehouseName*
Par exemple :
**Conditions préalables supplémentaires :** suivez les étapes *pour gérer vos informations d'identification de connexion avec AWS Glue* pour les configurer*snowflakeUrl*, *snowflakeUsername* et*snowflakePassword*. Pour passer en revue ces étapes, reportez-vous à la section précédente, [Configuration des connexions Snowflake](#aws-glue-programming-etl-connect-snowflake-configure). Pour sélectionner la **connexion réseau supplémentaire** à laquelle se connecter, nous utiliserons le paramètre `connectionName`.
```
snowflake_read = glueContext.create_dynamic_frame.from_options(
connection_type="snowflake",
connection_options={
"connectionName": "connectionName",
"dbtable": "tableName",
"sfDatabase": "databaseName",
"sfSchema": "schemaName",
"sfWarehouse": "warehouseName",
}
)
```
De plus, vous pouvez utiliser les paramètres `autopushdown` et `query` pour lire une partie d'une table Snowflake. Cela peut être nettement plus efficace que de filtrer vos résultats une fois qu'ils ont été chargés dans Spark. Prenons un exemple où toutes les ventes sont stockées dans la même table, mais où vous n'avez besoin d'analyser que les ventes d'un certain magasin pendant les jours fériés. Si ces informations sont stockées dans la table, vous pouvez utiliser le pushdown de prédicat pour récupérer les résultats comme suit :
```
snowflake_node = glueContext.create_dynamic_frame.from_options(
connection_type="snowflake",
connection_options={
"autopushdown": "on",
"query": "select * from sales where store='1' and IsHoliday='TRUE'",
"connectionName": "snowflake-glue-conn",
"sfDatabase": "databaseName",
"sfSchema": "schemaName",
"sfWarehouse": "warehouseName",
}
)
```
## Écrire sur les tables Snowflake
**Conditions préalables :** une base de données Snowflake sur laquelle vous souhaitez écrire. Vous aurez besoin d'un nom de table actuel ou souhaité,*tableName*. Vous aurez besoin de votre URL*snowflakeUrl*, nom d'utilisateur *snowflakeUser* et mot de passe Snowflake. *snowflakePassword* Si aucun espace de noms par défaut n'est défini pour votre utilisateur Snowflake, vous aurez besoin du nom de la base de données Snowflake et du nom du schéma. *databaseName* *schemaName* De plus, si votre utilisateur Snowflake n'a pas défini d'entrepôt par défaut, vous aurez besoin d'un nom d'entrepôt. *warehouseName*
Par exemple :
**Conditions préalables supplémentaires :** suivez les étapes *pour gérer vos informations d'identification de connexion avec AWS Glue* pour les configurer*snowflakeUrl*, *snowflakeUsername* et*snowflakePassword*. Pour passer en revue ces étapes, reportez-vous à la section précédente, [Configuration des connexions Snowflake](#aws-glue-programming-etl-connect-snowflake-configure). Pour sélectionner la **connexion réseau supplémentaire** à laquelle se connecter, nous utiliserons le paramètre `connectionName`.
```
glueContext.write_dynamic_frame.from_options(
connection_type="snowflake",
connection_options={
"connectionName": "connectionName",
"dbtable": "tableName",
"sfDatabase": "databaseName",
"sfSchema": "schemaName",
"sfWarehouse": "warehouseName",
},
)
```
## Référence des options de connexion Snowflake
Le type de connexion Snowflake accepte les options de connexion suivantes :
Vous pouvez récupérer certains paramètres de cette section à partir d'une connexion au catalogue de données (`sfUrl`, `sfUser`, `sfPassword`), auquel cas vous n'êtes pas obligé de les fournir. Pour ce faire, fournissez le paramètre `connectionName`.
Vous pouvez récupérer les paramètres de connexion à partir des AWS Secrets Manager secrets à l'aide du `secretId` paramètre. Lorsque vous utilisez Secrets Manager, les propriétés Spark suivantes peuvent être automatiquement récupérées si elles sont présentes dans le secret :
+ `sfUser` (à l’aide d’une clé `USERNAME` ou `sfUser`)
+ `sfPassword` (à l’aide d’une clé `PASSWORD` ou `sfPassword`)
+ `sfWarehouse` (à l’aide d’une clé `sfWarehouse`)
+ `sfDatabase` (à l’aide d’une clé `sfDatabase`)
+ `sfSchema` (à l’aide d’une clé `sfSchema`)
+ `sfRole` (à l’aide d’une clé `sfRole`)
+ `pem_private_key` (à l’aide d’une clé `pem_private_key`)
**Ordre de priorité des propriétés :** lorsque la même propriété est spécifiée à plusieurs emplacements, AWS Glue utilise l'ordre de priorité suivant (du plus haut au plus bas) :
1. Options de connexion explicitement fournies dans votre code de tâche
1. Propriétés de la connexion au catalogue de données
1. AWS Secrets Manager valeurs secrètes (lorsqu'elles `secretId` sont spécifiées)
1. Paramètres utilisateur par défaut de Snowflake
Les paramètres suivants sont généralement utilisés lors de la connexion à Snowflake.
+ `sfDatabase` : obligatoire si aucune valeur par défaut de l'utilisateur n'est définie dans Snowflake. Utilisé pour la lecture/l'écriture. La base de données à utiliser pour la session après la connexion.
+ `sfSchema` : obligatoire si aucune valeur par défaut de l'utilisateur n'est définie dans Snowflake. Utilisé pour la lecture/l'écriture. Le schéma à utiliser pour la session après la connexion.
+ `sfWarehouse` : obligatoire si aucune valeur par défaut de l'utilisateur n'est définie dans Snowflake. Utilisé pour la lecture/l'écriture. L'entrepôt virtuel par défaut à utiliser pour la session après la connexion.
+ `sfRole` : obligatoire si aucune valeur par défaut de l'utilisateur n'est définie dans Snowflake. Utilisé pour la lecture/l'écriture. Le rôle de sécurité par défaut à utiliser pour la session après la connexion.
+ `sfUrl` : (obligatoire) utilisé pour la lecture/l'écriture. Indique le nom d'hôte de votre compte au format suivant : `account_identifier.snowflakecomputing.com`. Pour plus d'informations sur les identifiants de compte, consultez [Identifiants de compte](https://docs.snowflake.com/en/user-guide/admin-account-identifier) dans la documentation de Snowflake.
+ `sfUser` : (obligatoire) utilisé pour la lecture/l'écriture. Nom de connexion de l'utilisateur Snowflake.
+ `sfPassword` : (Obligatoire sauf si la clé `pem_private_key` est fournie) utilisé pour la lecture/l’écriture. Mot de passe de l'utilisateur Snowflake.
+ `dbtable` : obligatoire lorsque vous travaillez avec des tables complètes. Utilisé pour la lecture/l'écriture. Le nom de la table à lire ou de la table dans laquelle les données sont écrites. Lors de la lecture, toutes les colonnes et tous les enregistrements sont récupérés.
+ `pem_private_key` : utilisé pour la lecture/l'écriture. Chaîne de clé privée codée en b64 non chiffrée. Clé privée de l’utilisateur Snowflake. Il est courant de la copier à partir d’un fichier PEM. Pour plus d’informations, consultez [Authentification par paire de clés et rotation des paires de clés](https://docs.snowflake.com/en/user-guide/key-pair-auth) dans la documentation Snowflake.
+ `query` : obligatoire lors de la lecture avec une requête. Utilisé pour la lecture. La requête exacte (instruction `SELECT`) à exécuter
Les options suivantes sont utilisées pour configurer des comportements spécifiques lors du processus de connexion à Snowflake.
+ `preactions` : utilisé pour la lecture/l'écriture. Valeurs valides : liste d'instructions SQL séparées par des points-virgules sous forme de chaîne. Les instructions SQL sont exécutées avant le transfert des données entre AWS Glue et Snowflake. Si une instruction contient `%s`, `%s` est remplacé par le nom de table référencé pour l'opération.
+ `postactions` : utilisé pour la lecture/l'écriture. Les instructions SQL sont exécutées après le transfert des données entre AWS Glue et Snowflake. Si une instruction contient `%s`, `%s` est remplacé par le nom de table référencé pour l'opération.
+ `autopushdown` : `"on"` par défaut. Valeurs valides : `"on"`, `"off"`. Ce paramètre contrôle si le pushdown automatique des requêtes est activé. Lorsque l'option pushdown est activée, si une partie de la requête peut être « poussée vers le bas » sur le serveur Snowflake, elle est poussée vers le bas au moment de l'exécution de la requête sur Spark. Cela améliore les performances de certaines requêtes. Pour savoir si votre requête peut être poussée vers le bas, consultez [Pushdown](https://docs.snowflake.com/en/user-guide/spark-connector-use#pushdown) dans la documentation de Snowflake.
En outre, certaines des options disponibles sur le connecteur Snowflake Spark peuvent être prises en charge dans Glue AWS . Pour plus d'informations sur les options disponibles sur le connecteur Snowflake Spark, consultez la section [Réglage des options de configuration du connecteur](https://docs.snowflake.com/en/user-guide/spark-connector-use#setting-configuration-options-for-the-connector) dans la documentation Snowflake.
## Méthodes d’authentification Snowflake
AWS Glue prend en charge les méthodes d'authentification suivantes pour se connecter à Snowflake :
+ **Authentification par nom d’utilisateur et mot de passe :** indiquez les paramètres `sfUser` et `sfPassword`.
+ **Authentification par paire de clés :** indiquez les paramètres `sfUser` et `pem_private_key`. Lorsque vous utilisez l’authentification par paire de clés, le paramètre `sfPassword` n’est pas obligatoire.
Les deux méthodes d'authentification sont entièrement prises en charge et peuvent être configurées à l'aide de n'importe quelle combinaison d'options de connexion, de connexions au catalogue de données ou de AWS Secrets Manager secrets.
## Limites du connecteur Snowflake
La connexion à Snowflake avec AWS Glue for Spark est soumise aux restrictions suivantes.
+ Ce connecteur ne prend pas en charge les signets de tâches. Pour plus d’informations sur les signets de tâche, consultez [Suivi des données traitées à l'aide de signets de tâche](monitor-continuations.md).
+ Ce connecteur ne prend pas en charge les lectures et écritures Snowflake via les tables du catalogue de données AWS Glue à l'aide des méthodes `create_dynamic_frame.from_catalog` et`write_dynamic_frame.from_catalog`.
+ Ce connecteur prend en charge username/password l'authentification et l'authentification par paire de clés. Les autres méthodes d'authentification (telles que OAuth SAML) ne sont actuellement pas prises en charge.
+ Ce connecteur n'est pas pris en charge dans les tâches de streaming.
+ Ce connecteur prend en charge les requêtes basées sur des instructions `SELECT` lors de la récupération d'informations (par exemple avec le paramètre `query`). Les autres types de requêtes (telles que `SHOW`, `DESC` ou les instructions DML) ne sont pas pris en charge.
+ Snowflake limite la taille du texte de la requête (c'est-à-dire les instructions SQL) soumis par les clients Snowflake à 1 Mo par instruction. Pour plus d'informations, consultez [Limites de la taille du texte de requête](https://docs.snowflake.com/en/user-guide/query-size-limits).
# Connexions Teradata Vantage
Vous pouvez utiliser AWS Glue for Spark pour lire et écrire dans des tables existantes dans Teradata Vantage dans AWS Glue 4.0 et versions ultérieures. Vous pouvez définir ce qu'il faut lire dans Teradata à l'aide d'une requête SQL. Vous pouvez vous connecter à Teradata à l'aide du nom d'utilisateur et du mot de passe enregistrés AWS Secrets Manager via une connexion AWS Glue.
Pour de plus amples informations sur Teradata, veuillez consulter la [documentation Teradata](https://docs.teradata.com/)
## Configuration de connexions Teradata
Pour vous connecter à Teradata depuis AWS Glue, vous devez créer et stocker vos informations d'identification Teradata dans un AWS Secrets Manager secret, puis associer ce secret à une connexion AWS Glue Teradata. Si votre instance Teradata se trouve dans un Amazon VPC, vous devrez également fournir des options réseau à votre connexion AWS Glue Teradata.
Pour vous connecter à Teradata depuis AWS Glue, vous aurez peut-être besoin de certaines conditions préalables :
+ Si vous accédez à votre environnement Teradata via Amazon VPC, configurez Amazon VPC pour permettre à votre tâche AWS Glue de communiquer avec l'environnement Teradata. Nous vous déconseillons d'accéder à l'environnement Teradata via l'Internet public.
Dans Amazon VPC, identifiez ou créez un **VPC**, un **sous-réseau** et un **groupe de sécurité que** AWS Glue utilisera lors de l'exécution de la tâche. En outre, vous devez vous assurer qu'Amazon VPC est configuré pour autoriser le trafic réseau entre votre instance Teradata et cet emplacement. Votre tâche devra établir une connexion TCP avec votre port client Teradata. Pour de plus amples informations sur les ports Teradata, consultez la [documentation Teradata](https://docs.teradata.com/r/Teradata-VantageTM-on-AWS-DIY-Installation-and-Administration-Guide/April-2020/Before-Deploying-Vantage-on-AWS-DIY/Security-Groups-and-Ports).
Selon la configuration de votre réseau, la connectivité VPC sécurisée peut nécessiter des modifications dans Amazon VPC et dans d'autres services réseau. Pour plus d'informations sur AWS la connectivité, consultez [les options de AWS connectivité](https://docs.teradata.com/r/Teradata-VantageCloud-Enterprise/Get-Started/Connecting-Your-Environment/AWS-Connectivity-Options) dans la documentation Teradata.
**Pour configurer une connexion AWS Glue Teradata :**
1. Dans votre configuration Teradata, identifiez ou créez un utilisateur et un mot de passe auxquels AWS Glue se connectera, *teradataUser* et*teradataPassword*. Pour plus d'informations, consultez la [présentation de Vantage Security](https://docs.teradata.com/r/Configuring-Teradata-VantageTM-After-Installation/January-2021/Security-Overview/Vantage-Security-Overview) dans la documentation Teradata.
1. Dans AWS Secrets Manager, créez un secret à l'aide de vos informations d'identification Teradata. Pour créer un secret dans Secrets Manager, suivez le didacticiel disponible dans la [section Créer un AWS Secrets Manager secret](https://docs.aws.amazon.com//secretsmanager/latest/userguide/create_secret.html) dans la AWS Secrets Manager documentation. Après avoir créé le secret, conservez le nom du secret *secretName* pour l'étape suivante.
+ Lorsque vous sélectionnez des **paires clé/valeur**, créez une paire pour la clé `user` contenant la valeur. *teradataUsername*
+ Lorsque vous sélectionnez des **paires clé/valeur**, créez une paire pour la clé `password` contenant la valeur. *teradataPassword*
1. Dans la console AWS Glue, créez une connexion en suivant les étapes décrites dans[Ajouter une AWS Glue connexion](console-connections.md). Après avoir créé la connexion, conservez le nom de la connexion pour l'étape suivante. *connectionName*
+ Lorsque vous sélectionnez un **type de connexion**, sélectionnez Teradata.
+ Lorsque vous fournissez l'**URL JDBC**, indiquez l'URL de votre instance. Vous pouvez également coder en dur certains paramètres de connexion séparés par des virgules dans votre URL JDBC. L'URL doit être conforme au format suivant : `jdbc:teradata://teradataHostname/ParameterName=ParameterValue,ParameterName=ParameterValue`
Les paramètres d'URL pris en charge sont les suivants :
+ `DATABASE` – nom de la base de données sur l'hôte à laquelle accéder par défaut.
+ `DBS_PORT` – le port de base de données utilisé lors de l'exécution sur un port non standard.
+ Lorsque vous sélectionnez un **type d'identifiant**, sélectionnez **AWS Secrets Manager**, puis définissez **AWS Secret** sur*secretName*.
1. Dans les situations suivantes, vous pouvez avoir besoin d'une configuration supplémentaire :
+
Pour les instances Teradata hébergées sur AWS un Amazon VPC
+ Vous devrez fournir les informations de connexion Amazon VPC à la connexion AWS Glue qui définit vos informations de sécurité Teradata. Lorsque vous créez ou mettez à jour votre connexion, définissez le **VPC**, le **sous-réseau** et les **groupes de sécurité** dans les **options réseau**.
Après avoir créé une connexion AWS Glue Teradata, vous devez effectuer les étapes suivantes avant d'appeler votre méthode de connexion.
+ Accordez au rôle IAM associé à votre tâche AWS Glue l'autorisation de lire*secretName*.
+ Dans la configuration de votre tâche AWS Glue*connectionName*, fournissez une **connexion réseau supplémentaire**.
## Lecture à partir de Teradata
**Prérequis :**
+ Une table Teradata à partir de laquelle vous souhaitez lire. Vous aurez besoin du nom de la table,*tableName*.
+ Une connexion AWS Glue Teradata configurée pour fournir des informations d'authentification. Suivez les étapes *pour configurer une connexion à Teradata* afin de configurer vos informations d'authentification. Vous aurez besoin du nom de la connexion AWS Glue,*connectionName*.
Par exemple :
```
teradata_read_table = glueContext.create_dynamic_frame.from_options(
connection_type="teradata",
connection_options={
"connectionName": "connectionName",
"dbtable": "tableName"
}
)
```
Vous pouvez également fournir une requête SQL SELECT pour filtrer les résultats renvoyés à votre DynamicFrame. Vous devrez configurer `query`.
Par exemple :
```
teradata_read_query = glueContext.create_dynamic_frame.from_options(
connection_type="teradata",
connection_options={
"connectionName": "connectionName",
"query": "query"
}
)
```
## Écrire dans les tables Teradata
**Prérequis :** une table Teradata dans laquelle vous souhaitez écrire,. *tableName* **Vous devez créer la table avant d'appeler la méthode de connexion.**
Par exemple :
```
teradata_write = glueContext.write_dynamic_frame.from_options(
connection_type="teradata",
connection_options={
"connectionName": "connectionName",
"dbtable": "tableName"
}
)
```
## Référence des options de connexion Teradata
+ `connectionName` — Obligatoire. Utilisé pour la lecture/l'écriture. Nom d'une connexion AWS Glue Teradata configurée pour fournir des informations d'authentification et de mise en réseau à votre méthode de connexion.
+ `dbtable` — obligatoire pour l'écriture, obligatoire pour la lecture à moins qu'une `query` ne soit fournie. Utilisé pour la lecture/l'écriture. Le nom de la table avec lequelle votre méthode de connexion va interagir.
+ `query` : utilisé pour la lecture. Une requête SELECT SQL définissant ce qui doit être récupéré lors de la lecture à partir de Teradata.
# Connexions Teradata Vantage NOS
La connexion Teradata NOS (Native Object Store) est une nouvelle connexion pour Teradata Vantage qui utilise la requête Teradata WRITE\$1NOS pour lire des tables existantes et la requête READ\$1NOS pour écrire dans des tables. Ces requêtes utilisent Amazon S3 comme répertoire intermédiaire. Le connecteur Teradata NOS est donc plus rapide que le connecteur Teradata existant (basé sur JDBC), surtout lorsqu’il s’agit de gérer de grandes quantités de données.
Vous pouvez utiliser la connexion Teradata NOS dans Spark AWS Glue pour lire et écrire dans des tables existantes dans Teradata Vantage dans les AWS Glue versions 5.0 et ultérieures. Vous pouvez définir ce qu'il faut lire dans Teradata à l'aide d'une requête SQL. Vous pouvez vous connecter à Teradata à l'aide des identifiants de nom d'utilisateur et de mot de passe enregistrés AWS Secrets Manager via une AWS Glue connexion.
Pour plus d’informations sur Teradata, veuillez consulter la [documentation Teradata](https://docs.teradata.com/)
**Topics**
+ [
## Création d’une connexion Teradata NOS
](#creating-teradata-nos-connection)
+ [
## Lecture à partir de tables Teradata
](#reading-from-teradata-nos-tables)
+ [
## Écrire dans les tables Teradata
](#writing-to-teradata-nos-tables)
+ [
## Référence des options de connexion Teradata
](#teradata-nos-connection-option-reference)
+ [
## Fournir des options dans l'interface utilisateur AWS Glue Visual ETL
](#teradata-nos-connection-option-visual-etl-ui)
## Création d’une connexion Teradata NOS
Pour vous connecter à Teradata NOS depuis AWS Glue, vous devez créer et stocker vos informations d'identification Teradata dans un AWS Secrets Manager secret, puis associer ce secret à une connexion AWS Glue Teradata NOS. Si votre instance Teradata se trouve dans un Amazon VPC, vous devrez également fournir des options réseau à AWS Glue votre connexion Teradata NOS.
**Prérequis :**
+ Si vous accédez à votre environnement Teradata via Amazon VPC, configurez Amazon VPC pour permettre à AWS Glue votre tâche de communiquer avec l'environnement Teradata. Nous vous déconseillons d'accéder à l'environnement Teradata via l'Internet public.
+ Dans Amazon VPC, identifiez ou créez un VPC, un sous-réseau et un groupe de sécurité qui AWS Glue seront utilisés lors de l'exécution de la tâche. En outre, vous devez vous assurer qu'Amazon VPC est configuré pour autoriser le trafic réseau entre votre instance Teradata et cet emplacement. Votre tâche devra établir une connexion TCP avec votre port client Teradata. Pour plus d’informations sur les ports Teradata, consultez [Security Groups for Teradata Vantage](https://docs.teradata.com/r/Teradata-VantageTM-on-AWS-DIY-Installation-and-Administration-Guide/April-2020/Before-Deploying-Vantage-on-AWS-DIY/Security-Groups-and-Ports).
+ Selon la configuration de votre réseau, la connectivité VPC sécurisée peut nécessiter des modifications dans Amazon VPC et dans d'autres services réseau. Pour plus d'informations sur AWS la connectivité, consultez la section [Options de AWS connectivité](https://docs.teradata.com/r/Teradata-VantageCloud-Enterprise/Get-Started/Connecting-Your-Environment/AWS-Connectivity-Options) dans la documentation Teradata.
### Pour configurer une connexion AWS Glue Teradata NOS :
1. Dans votre configuration Teradata, identifiez ou créez un *teradataUsername* et auquel *teradataPassword* AWS Glue vous vous connecterez. Pour plus d’informations, consultez [Vantage Security Overview](https://docs.teradata.com/r/Configuring-Teradata-VantageTM-After-Installation/January-2021/Security-Overview/Vantage-Security-Overview) dans la documentation Teradata.
1. Dans AWS Secrets Manager, créez un secret à l'aide de vos informations d'identification Teradata. Pour créer un secret dans AWS Secrets Manager, suivez le didacticiel disponible dans la [section Créer un AWS Secrets Manager secret dans la AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html) documentation. Après avoir créé le secret, conservez le nom du secret *secretName* pour l'étape suivante.
+ Lorsque vous sélectionnez des Key/value paires, créez une paire pour la clé USERNAME avec la valeur*teradataUsername*.
+ Lorsque vous sélectionnez des Key/value paires, créez une paire pour la clé PASSWORD avec la valeur*teradataPassword*.
1. Dans la AWS Glue console, créez une connexion en suivant les étapes décrites dans [Ajouter une AWS Glue connexion](https://docs.aws.amazon.com/glue/latest/dg/console-connections.html). Après avoir créé la connexion, conservez le nom de la connexion pour l'étape suivante. *connectionName*
+ Lorsque vous sélectionnez un **type de connexion**, sélectionnez Teradata Vantage NOS.
+ Lorsque vous fournissez l'URL JDBC, indiquez l'URL de votre instance. Vous pouvez également coder en dur certains paramètres de connexion séparés par des virgules dans votre URL JDBC. L'URL doit être conforme au format suivant :` jdbc:teradata://teradataHostname/ParameterName=ParameterValue,ParameterName=ParameterValue `.
+ Les paramètres d'URL pris en charge sont les suivants :
+ `DATABASE` – nom de la base de données sur l'hôte à laquelle accéder par défaut.
+ `DBS_PORT` – le port de base de données utilisé lors de l'exécution sur un port non standard.
+ Lorsque vous sélectionnez un **type d'identifiant**, sélectionnez AWS Secrets Manager, puis définissez ** AWS Secret** sur*secretName*.
1. Dans les situations suivantes, vous pouvez avoir besoin d'une configuration supplémentaire :
+ Pour les instances Teradata AWS hébergées sur un Amazon VPC, vous devrez fournir les informations de connexion Amazon VPC à AWS Glue la connexion qui définit vos informations de sécurité Teradata. Lorsque vous créez ou mettez à jour votre connexion, définissez le **VPC**, le **sous-réseau** et les **groupes de sécurité** dans les **options réseau**.
Après avoir créé une connexion AWS Glue Teradata Vantage NOS, vous devez effectuer les étapes suivantes avant d'appeler votre méthode de connexion.
1. Accordez au rôle IAM associé à votre AWS Glue travail l'autorisation de lire*secretName*.
1. Dans la configuration de votre AWS Glue tâche, *connectionName* indiquez une **connexion réseau supplémentaire** sous **Connexions**.
## Lecture à partir de tables Teradata
### Prérequis :
+ Une table Teradata à partir de laquelle vous souhaitez lire. Vous aurez besoin du nom de la table,*tableName*.
+ L'environnement Teradata dispose d'un accès en écriture au chemin Amazon S3 spécifié par l'`staging_fs_url`option,*stagingFsUrl*.
+ Le rôle IAM associé à la AWS Glue tâche dispose d'un accès en écriture à l'emplacement Amazon S3 spécifié par `staging_fs_url` option.
+ Une connexion AWS Glue Teradata NOS configurée pour fournir des informations d'authentification. Suivez la procédure [Pour configurer une connexion AWS Glue Teradata NOS :](#creating-teradata-nos-connection-procedure) pour configurer vos informations d’authentification. Vous aurez besoin du nom de la AWS Glue connexion,*connectionName*.
Exemple :
```
teradata_read_table = glueContext.create_dynamic_frame.from_options(
connection_type= "teradatanos",
connection_options={
"connectionName": "connectionName",
"dbtable": "tableName",
"staging_fs_url": "stagingFsUrl"
}
)
```
Vous pouvez également fournir une requête SQL SELECT pour filtrer les résultats renvoyés à votre DynamicFrame. Vous devrez configurer query. Si vous configurez à la fois dbTable et query, le connecteur ne parvient pas à lire les données. Par exemple :
```
teradata_read_query = glueContext.create_dynamic_frame.from_options(
connection_type="teradatanos",
connection_options={
"connectionName": "connectionName",
"query": "query",
"staging_fs_url": "stagingFsUrl"
}
)
```
En outre, vous pouvez utiliser l' DataFrame API Spark pour lire des tables Teradata. Par exemple :
```
options = {
"url": "JDBC_URL",
"dbtable": "tableName",
"user": "teradataUsername", # or use "username" as key here
"password": "teradataPassword",
"staging_fs_url": "stagingFsUrl"
}
teradata_read_table = spark.read.format("teradatanos").option(**options).load()
```
## Écrire dans les tables Teradata
### Conditions préalables
+ Une table Teradata dans laquelle vous souhaitez écrire :*tableName*.
+ L'environnement Teradata dispose d'un accès en lecture à l'emplacement Amazon S3 spécifié par l'`staging_fs_url`option,* stagingFsUrl *.
+ Le rôle IAM associé à la AWS Glue tâche dispose d'un accès en écriture à l'emplacement Amazon S3 spécifié par `staging_fs_url` option.
+ Une connexion AWS Glue Teradata configurée pour fournir des informations d'authentification. Suivez la procédure indiquée dans [Pour configurer une connexion AWS Glue Teradata NOS :](#creating-teradata-nos-connection-procedure) pour configurer vos informations d’authentification. Vous aurez besoin du nom de la AWS Glue connexion,*connectionName*.
Par exemple :
```
teradata_write = glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type= "teradatanos",
connection_options={
"connectionName": "connectionName",
"dbtable": "tableName",
"staging_fs_url": "stagingFsUrl"
}
)
```
## Référence des options de connexion Teradata
**Options de connexion et d’opération :**
+ `connectionName` — Obligatoire. Utilisé pour la lecture/l'écriture. Nom d'une connexion AWS Glue Teradata configurée pour fournir des informations d'authentification et de mise en réseau à votre méthode de connexion.
+ `staging_fs_url` — Obligatoire. Utilisé pour la lecture/l'écriture. Emplacement accessible en écriture dans Amazon S3, à utiliser pour les données déchargées lors de la lecture depuis Teradata, et pour les données Parquet à charger dans Redshift lors de l’écriture sur Teradata. Le compartiment S3 doit se trouver dans la même région que celle de vos AWS Glue tâches.
+ `dbtable` — obligatoire pour l'écriture, obligatoire pour la lecture à moins qu'une `query` ne soit fournie. Utilisé pour la lecture/l'écriture. Le nom de la table avec lequelle votre méthode de connexion va interagir.
+ `query` : utilisé pour la lecture. Une requête SELECT SQL définissant ce qui doit être récupéré lors de la lecture à partir de Teradata. Vous ne pouvez pas réussir si l’option `dbtable` est fournie.
+ `clean_staging_s3_dir`— Facultatif. Utilisé pour la lecture/l'écriture. Si la valeur est true, nettoyez les objets Amazon S3 intermédiaires après une lecture ou une écriture. La valeur par défaut est True.
+ `pre_actions`— Facultatif. Utilisé pour écrire. Liste séparée par des points-virgules des commandes SQL exécutées avant le transfert des données entre Spark et Teradata Vantage.
+ `post_actions`— Facultatif. Utilisé pour écrire. Liste séparée par des points-virgules des commandes SQL exécutées après le transfert des données entre Spark et Teradata Vantage.
+ `truncate`— Facultatif. Utilisé pour écrire. Si la valeur est true, le connecteur tronque la table lors de l’écriture en mode de réécriture. Si la valeur est false, le connecteur supprime la table lors de l’écriture en mode de réécriture. La valeur par défaut est false.
+ `create_table_script`— Facultatif. Utilisé pour écrire. Une instruction SQL pour créer une table lors de l’écriture sur Teradata Vantage. Cette option est utile lorsque vous souhaitez créer une table avec des métadonnées personnalisées (par exemple, table CREATE MULTISET ou SET ou modifier l’index principal). Notez que le nom de table utilisé dans le script de création de table doit correspondre au nom de table spécifié dans l’option `dbtable`.
+ `partition_size_in_mb`— Facultatif. Utilisé pour la lecture. Taille maximale d’une partition Spark en mégaoctets lors de la lecture d’objets Amazon S3 intermédiaires. La valeur par défaut est 128.
Vous pouvez fournir des options avancées lors de la création d’un nœud Teradata. Ces options sont les mêmes que celles disponibles lors de la programmation AWS Glue de scripts Spark.
Consultez [Connexions Teradata Vantage](aws-glue-programming-etl-connect-teradata-home.md).
**Options d’autorisation :**
Vous trouverez ci-dessous les options utilisées pour fournir les informations d'identification du AWS compte que le connecteur utilise pour accéder au compartiment Amazon S3 intermédiaire. Vous pouvez choisir (1) de ne fournir aucune option d'autorisation et d'utiliser des informations d'identification temporaires générées à partir de votre rôle d' AWS Glue exécution ; ou (2) de fournir un objet d'autorisation `auth_object` que vous avez créé ; ou (3) de le fournir `aws_access_key_id and aws_secret_access_key` si vous utilisez des informations d'identification à long terme, ou de fournir `aws_access_key``aws_secret_access_key`, et `aws_session_token` si vous utilisez des informations d'identification temporaires.
+ `auth_object` : facultatif. Utilisé pour accéder au compartiment Amazon S3 intermédiaire. Chaîne d’objets d’autorisation créée dans une instance Teradata. Si elle est fournie, le connecteur utilisera cet objet d’autorisation pour accéder au compartiment Amazon S3 intermédiaire. Si elles ne sont pas fournies, `aws_access_key_id` et qu'elles ne le `aws_secret_access_key` sont pas non plus, une information d'identification temporaire sera extraite du rôle AWS Glue d'exécution et utilisée par le connecteur. Le AWS compte associé à cet objet d'autorisation doit se trouver dans la même région que vos AWS Glue tâches et votre compartiment Amazon S3 intermédiaire ou être configuré avec la confiance entre comptes.
+ `aws_access_key_id` : facultatif. Utilisé pour accéder au compartiment Amazon S3 intermédiaire. Fait partie des informations d'identification de sécurité d'un AWS compte. Si `auth_object` n’est pas fourni et si `aws_access_key_id` est fourni avec `aws_secret_access_key`, le connecteur les utilisera pour accéder au compartiment Amazon S3 intermédiaire. Le AWS compte associé à cette clé d'accès doit se trouver dans la même région que vos AWS Glue tâches et votre compartiment Amazon S3 intermédiaire ou être configuré avec la confiance entre comptes.
+ `aws_secret_access_key` : facultatif. Utilisé pour accéder au compartiment Amazon S3 intermédiaire. Fait partie des informations d'identification de sécurité d'un AWS compte. Si `auth_object` n’est pas fourni et si `aws_secret_access_key` est fourni avec `aws_access_key_id`, le connecteur les utilisera pour accéder au compartiment Amazon S3 intermédiaire. Le AWS compte associé à cette clé secrète doit se trouver dans la même région que vos AWS Glue tâches et votre compartiment Amazon S3 intermédiaire ou être configuré avec la confiance entre comptes.
+ `aws_session_token` : facultatif. Utilisé pour accéder au compartiment Amazon S3 intermédiaire. Fait partie d'un identifiant de sécurité temporaire d'un AWS compte. Doit être fourni avec `aws_access_key_id` et `aws_secret_access_key`.
## Fournir des options dans l'interface utilisateur AWS Glue Visual ETL
Vous pouvez indiquer toutes les options ci-dessus dans l’interface utilisateur de votre tâche ETL visuel. Pour l’option connectionName, vous devez choisir dans la liste déroulante des connexions Teradata Vantage NOS. Pour toutes les autres options, vous devez les fournir via les propriétés personnalisées de Teradata Vantage NOS sous forme de paires clé-valeur.
![\[Le volet de la fenêtre indique que la connexion Teradata NOS Vantage est sélectionnée.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/teradata-nos-vantage-connection-options.png)
# Connexions Vertica
Vous pouvez utiliser AWS Glue for Spark pour lire et écrire dans des tables dans Vertica dans AWS Glue 4.0 et versions ultérieures. Vous pouvez définir ce qu'il faut lire dans Vertica à l'aide d'une requête SQL. Vous vous connectez à Vertica à l'aide du nom d'utilisateur et du mot de passe enregistrés AWS Secrets Manager via une connexion AWS Glue.
Pour de plus amples informations sur Vertica, consultez la [documentation Vertica](https://www.vertica.com/docs/9.3.x/HTML/Content/Authoring/UsingVerticaOnAWS/UsingVerticaOnAWS.htm).
## Configuration de connexions Vertica
Pour vous connecter à Vertica depuis AWS Glue, vous devez créer et stocker vos informations d'identification Vertica dans un AWS Secrets Manager secret, puis associer ce secret à une connexion Vertica AWS Glue. Si votre instance Vertica se trouve dans un Amazon VPC, vous devrez également fournir des options réseau à votre connexion AWS Glue Vertica. Vous aurez besoin d'un compartiment Amazon S3 ou d'un dossier à utiliser pour le stockage temporaire lors de la lecture et de l'écriture dans la base de données.
Pour vous connecter à Vertica depuis AWS Glue, vous aurez besoin de certaines conditions préalables :
+ Un compartiment ou un dossier Amazon S3 à utiliser pour le stockage temporaire lors de la lecture et de l'écriture dans la base de données, désigné par*tempS3Path*.
**Note**
Lorsque vous utilisez Vertica dans les aperçus des données des tâches AWS Glue, il est possible que les fichiers temporaires ne soient pas automatiquement supprimés. *tempS3Path* Pour garantir la suppression des fichiers temporaires, mettez directement fin à la session de prévisualisation des données en choisissant **Mettre fin à la session** dans le volet **Prévisualisation des données**.
Si vous ne pouvez pas garantir la fin directe de la session de prévisualisation des données, pensez à configurer le cycle de vie d’Amazon S3 pour supprimer les anciennes données. Nous recommandons de supprimer les données de plus de 49 heures, sur la base de la durée d'exécution maximale des tâches plus une marge. Pour de plus amples informations sur la configuration du cycle de vie Amazon S3, consultez [Gestion du cycle de vie de votre stockage](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) dans la documentation Amazon S3.
+ Une politique IAM avec les autorisations appropriées pour votre chemin Amazon S3 que vous pouvez associer à votre rôle de travail AWS Glue.
+ Si votre instance Vertica se trouve dans un Amazon VPC, configurez Amazon VPC pour permettre à votre tâche AWS Glue de communiquer avec l'instance Vertica sans que le trafic ne transite par l'Internet public.
Dans Amazon VPC, identifiez ou créez un **VPC**, un **sous-réseau** et un **groupe de sécurité que** AWS Glue utilisera lors de l'exécution de la tâche. En outre, vous devez vous assurer qu'Amazon VPC est configuré pour autoriser le trafic réseau entre votre instance Vertica et cet emplacement. Votre tâche devra établir une connexion TCP avec votre port client Vertica (par défaut 5433). Selon la configuration de votre réseau, cela peut nécessiter des modifications des règles du groupe de sécurité, du réseau ACLs, des passerelles NAT et des connexions d'appairage.
Vous pouvez ensuite configurer AWS Glue pour l'utiliser avec Vertica.
**Pour configurer une connexion à Vertica :**
1. Dans AWS Secrets Manager, créez un secret à l'aide de vos informations d'identification Vertica, *verticaUsername* et*verticaPassword*. Pour créer un secret dans Secrets Manager, suivez le didacticiel disponible dans la [section Créer un AWS Secrets Manager secret](https://docs.aws.amazon.com//secretsmanager/latest/userguide/create_secret.html) dans la AWS Secrets Manager documentation. Après avoir créé le secret, conservez le nom du secret *secretName* pour l'étape suivante.
+ Lorsque vous sélectionnez des **paires clé/valeur**, créez une paire pour la clé `user` contenant la valeur. *verticaUsername*
+ Lorsque vous sélectionnez des **paires clé/valeur**, créez une paire pour la clé `password` contenant la valeur. *verticaPassword*
1. Dans la console AWS Glue, créez une connexion en suivant les étapes décrites dans[Ajouter une AWS Glue connexion](console-connections.md). Après avoir créé la connexion, conservez le nom de la connexion pour l'étape suivante. *connectionName*
+ Lorsque vous sélectionnez un **type de connexion**, sélectionnez Vertica.
+ Lorsque vous sélectionnez l'**hôte Vertica**, indiquez le nome d'hôte de votre installation Vertica.
+ Lorsque vous sélectionnez le **port Vertica**, le port via lequel votre installation Vertica est disponible.
+ Lorsque vous sélectionnez un **AWS secret**, indiquez-le*secretName*.
1. Dans les situations suivantes, vous pouvez avoir besoin d'une configuration supplémentaire :
+
Pour les instances Vertica hébergées AWS dans un Amazon VPC
+ Fournissez les informations de connexion Amazon VPC à la connexion AWS Glue qui définit vos informations de sécurité Vertica. Lorsque vous créez ou mettez à jour votre connexion, définissez le **VPC**, le **sous-réseau** et les **groupes de sécurité** dans les **options réseau**.
Après avoir créé une connexion AWS Glue Vertica, vous devez effectuer les étapes suivantes avant d'appeler votre méthode de connexion.
+ Accordez au rôle IAM associé à votre tâche AWS Glue des autorisations à*tempS3Path*.
+ Accordez au rôle IAM associé à votre tâche AWS Glue l'autorisation de lire*secretName*.
+ Dans la configuration de votre tâche AWS Glue*connectionName*, fournissez une **connexion réseau supplémentaire**.
## Lecture à partir de Vertica
**Prérequis :**
+ Une table Vertica à partir de laquelle vous souhaitez lire. Vous aurez besoin du nom de la base de données Vertica *dbName* et du nom de la table. *tableName*
+ Une connexion AWS Glue Vertica configurée pour fournir des informations d'authentification. Suivez les étapes de la procédure précédente *Pour configurer une connexion à Vertica* afin de configurer vos informations d'authentification. Vous aurez besoin du nom de la connexion AWS Glue,*connectionName*.
+ Un compartiment ou un dossier Amazon S3 à utiliser pour le stockage temporaire, mentionné précédemment. Vous aurez besoin du nom,*tempS3Path*. Vous devrez vous connecter à cet emplacement à l'aide du protocole `s3a`.
Par exemple :
```
dynamicFrame = glueContext.create_dynamic_frame.from_options(
connection_type="vertica",
connection_options={
"connectionName": "connectionName",
"staging_fs_url": "s3a://tempS3Path",
"db": "dbName",
"table": "tableName",
}
)
```
Vous pouvez également fournir une requête SQL SELECT pour filtrer les résultats qui vous sont renvoyés DynamicFrame ou pour accéder à un ensemble de données à partir de plusieurs tables.
Par exemple :
```
dynamicFrame = glueContext.create_dynamic_frame.from_options(
connection_type="vertica",
connection_options={
"connectionName": "connectionName",
"staging_fs_url": "s3a://tempS3Path",
"db": "dbName",
"query": "select * FROM tableName",
},
)
```
## Écrire dans les tables Vertica
Cet exemple écrit les informations d'un fichier existant DynamicFrame *dynamicFrame* dans Vertica. Si le tableau contient déjà des informations, AWS Glue ajoutera les données de votre DynamicFrame.
**Prérequis :**
+ Nom de table actuel ou souhaité*tableName*, dans lequel vous souhaitez écrire. Vous aurez également besoin du nom de base de données Vertica correspondant,*dbName*.
+ Une connexion AWS Glue Vertica configurée pour fournir des informations d'authentification. Suivez les étapes de la procédure précédente *Pour configurer une connexion à Vertica* afin de configurer vos informations d'authentification. Vous aurez besoin du nom de la connexion AWS Glue,*connectionName*.
+ Un compartiment ou un dossier Amazon S3 à utiliser pour le stockage temporaire, mentionné précédemment. Vous aurez besoin du nom,*tempS3Path*. Vous devrez vous connecter à cet emplacement à l'aide du protocole `s3a`.
Par exemple :
```
glueContext.write_dynamic_frame.from_options(
frame=dynamicFrame,
connection_type="vertica",
connection_options={
"connectionName": "connectionName",
"staging_fs_url": "s3a://tempS3Path",
"db": "dbName",
"table": "tableName",
}
)
```
## Référence des options de connexion Vertica
+ `connectionName` — Obligatoire. Utilisé pour la lecture/l'écriture. Le nom d'une connexion AWS Glue Vertica configurée pour fournir des informations d'authentification et de réseau à votre méthode de connexion.
+ `db` — Obligatoire. Utilisé pour la lecture/l'écriture. Le nom d'une base de données dans Vertica avec lequelle votre méthode de connexion va interagir.
+ `dbSchema` — obligatoire si nécessaire pour identifier votre table. Utilisé pour la lecture/l'écriture. Valeur par défaut : `public`. Le nom d'un schéma avec lequel votre méthode de connexion va interagir.
+ `table` — obligatoire pour l'écriture, obligatoire pour la lecture à moins qu'une `query` ne soit fournie. Utilisé pour la lecture/l'écriture. Le nom de la table avec lequelle votre méthode de connexion va interagir.
+ `query` : utilisé pour la lecture. Une requête SELECT SQL définissant ce qui doit être récupéré lors de la lecture à partir de Teradata.
+ `staging_fs_url` — Obligatoire. Utilisé pour la lecture/l'écriture. Valeurs valides : `s3a` URLs. L'URL d'un compartiment ou d'un dossier Amazon S3 à utiliser pour le stockage temporaire.
## DataFrame options pour l'ETL dans AWS Glue 5.0 pour Spark
A DataFrame est un ensemble de données organisé en colonnes nommées semblables à une table et prenant en charge les opérations de style fonctionnel (map/reduce/filter/etc.) et les opérations SQL (sélection, projet, agrégation).
Pour créer un DataFrame pour une source de données prise en charge par Glue, les éléments suivants sont requis :
+ connecteur de source de données `ClassName`
+ connexion de source de données `Options`
De même, pour écrire un dans DataFrame un récepteur de données supporté par Glue, il en va de même :
+ connecteur de récepteur de données `ClassName`
+ connexion au récepteur de données `Options`
Notez que les fonctionnalités de AWS Glue telles que les signets de tâches et les DynamicFrame options telles que celles-ci ne `connectionName` sont pas prises en charge dans DataFrame. Pour plus de détails sur les opérations prises en charge DataFrame et pour en savoir plus, consultez la documentation de Spark pour [DataFrame](https://spark.apache.org/docs/3.5.2/api/python/reference/pyspark.sql/dataframe.html).
### Spécification du connecteur ClassName
Pour spécifier le `ClassName` d’une source de données/d’un récepteur, utilisez l’option `.format` permettant de fournir le `ClassName` du connecteur correspondant qui définit la source de données/le récepteur.
**Connecteurs JDBC**
Pour les connecteurs JDBC, indiquez `jdbc` en tant que valeur de l’option `.format` et fournissez le pilote JDBC `ClassName` dans l’option `driver`.
```
df = spark.read.format("jdbc").option("driver", "")...
df.write.format("jdbc").option("driver", "")...
```
Le tableau suivant répertorie le pilote JDBC de la source `ClassName` de données prise en charge dans AWS Glue for. DataFrames
| Source de données | Chauffeur ClassName |
| --- |--- |
| PostgreSQL | pilote org.postgreSQL |
| Oracle | oracle.jdbc.driver. OracleDriver |
| SQLServer | com.microsoft.sqlserver.jdbc. SQLServerChauffeur |
| MySQL | com.mysql.jdbc.driver |
| SAPHana | com.sap.db.jdbc.driver |
| Teradata | com.teradata.jdbc. TeraDriver |
**Connecteurs Spark**
Pour les connecteurs Spark, spécifiez le `ClassName` du connecteur en tant que valeur de l’option `.format`.
```
df = spark.read.format("")...
df.write.format("")...
```
Le tableau suivant répertorie le connecteur Spark `ClassName` de la source de données prise en charge dans AWS Glue for DataFrames.
| Source de données | ClassName |
| --- |--- |
| MongoDB/DocumentDB | glue.spark.mongodb |
| Redshift | io.github.spark\$1redshift\$1community.spark.redshift |
| AzureCosmos | cosmos.oltp |
| AzureSQL | com.microsoft.sqlserver.jdbc.spark |
| BigQuery | com.google.cloud.spark.bigquery |
| OpenSearch | org.opensearch.spark.sql |
| Snowflake | net.snowflake.spark.snowflake |
| Vertica | com.vertica.spark.datasource. VerticaSource |
### Spécification des options de connexion
Pour spécifier les `Options` de la connexion à une source de données/un récepteur, utilisez `.option(, )` pour fournir des options individuelles ou `.options(