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. # 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)