# Conexiones de JDBC Algunos tipos de bases de datos, normalmente relacionales, admiten la conexión a través del estándar JDBC. Para obtener más información sobre JDBC, consulte la [Java JDBC API](https://docs.oracle.com/javase/8/docs/technotes/guides/jdbc/) documentation. AWS Glue admite de forma nativa la conexión a determinadas bases de datos a través de sus conectores JDBC; las bibliotecas JDBC se proporcionan en los trabajos de Glue Spark AWS. Al conectarse a estos tipos de bases de datos mediante las bibliotecas de GlueAWS , tiene acceso a un conjunto estándar de opciones. Entre los valores de ConnectionType de JDBC, se incluyen los siguientes: + `"connectionType": "sqlserver"`: designa una conexión a una base de datos Microsoft SQL Server. + `"connectionType": "mysql"`: designa una conexión a una base de datos MySQL. + `"connectionType": "oracle"`: designa una conexión a una base de datos Oracle. + `"connectionType": "postgresql"`: designa una conexión a una base de datos PostgreSQL. + `"connectionType": "redshift"`: designa una conexión a una base de datos de Amazon Redshift. Para obtener más información, consulte [Conexiones Redshift](aws-glue-programming-etl-connect-redshift-home.md). En la siguiente tabla, se muestran las versiones del controlador JDBC que AWS Glue soporta. | Producto | Versiones del controlador JDBC para Glue 5.1 | Versiones del controlador JDBC para Glue 5.0 | Versiones del controlador JDBC para Glue 4.0 | Versiones del controlador JDBC para Glue 3.0 | Versiones del controlador JDBC para 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 | | Base de datos de Oracle | 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 En el caso del tipo de conexión de Amazon Redshift, todos los demás pares nombre/valor que estén presentes en las opciones de una conexión JDBC, incluidas las opciones de formato, se pasan directamente al DataSource SparkSQL subyacente. En los trabajos de Glue with Spark AWS en Glue 4.0 AWS y versiones posteriores, el conector nativo de Glue AWS para Amazon Redshift utiliza la integración de Amazon Redshift para Apache Spark. Para obtener más información, consulte [Integración de Amazon Redshift para Apache Spark](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html). En versiones anteriores, consulte el [origen de datos de Amazon Redshift para Spark](https://github.com/databricks/spark-redshift). Para configurar Amazon VPC para que se conecte a los almacenes de datos de Amazon RDS mediante JDBC, consulte [Configuración de Amazon VPC para conexiones JDBC a los almacenes de datos de Amazon RDS de AWS Glue](setup-vpc-for-glue-access.md). **nota** Los trabajos de AWS Glue solo se asocian a una subred durante una ejecución. Esto puede afectar a su capacidad de conectarse a diversos orígenes de datos a través del mismo trabajo. Este comportamiento no se limita a los orígenes de JDBC. **Topics** + [Referencia de opciones de conexión de JDBC](#aws-glue-programming-etl-connect-jdbc) + [Utilice sampleQuery](#aws-glue-programming-etl-jdbc-samplequery) + [Utilice un controlador JDBC personalizado](#aws-glue-programming-etl-jdbc-custom-driver) + [Lectura desde tablas de JDBC en paralelo](run-jdbc-parallel-read-job.md) + [Configuración de Amazon VPC para conexiones JDBC a los almacenes de datos de Amazon RDS de AWS Glue](setup-vpc-for-glue-access.md) ## Referencia de opciones de conexión de JDBC Si ya tiene definida una conexión JDBC de Glue AWS, puede reutilizar las propiedades de configuración definidas en ella, como url, usuario y contraseña; de este modo, no tendrá que especificarlas en el código como opciones de conexión. Esta característica solo está disponible en Glue 3.0 AWS o versiones posteriores. Para ello, utilice las siguientes propiedades de conexión: + `"useConnectionProperties"`: configúrelo en “true” para indicar que desea utilizar la configuración desde una conexión. + `"connectionName"`: ingrese el nombre de la conexión desde la que recuperará la configuración. La conexión debe definirse en la misma región que el trabajo. Utilice estas opciones con las conexiones JDBC: + `"url"`: (obligatorio) la URL de JDBC de la base de datos. + `"dbtable"`: (Obligatorio) la tabla de la base de datos de la que se va a leer. Para almacenes de datos de JDBC que admiten esquemas dentro de una base de datos, especifique `schema.table-name`. Si no se ha proporcionado un esquema, se usa el esquema “public” predeterminado. + `"user"`: (obligatorio) nombre de usuario que se va a utilizar para establecer la conexión. + `"password"`: (obligatorio) contraseña que se utilizará para establecer la conexión. + (Opcional) las siguientes opciones le permiten proporcionar un controlador JDBC personalizado. Utilice estas opciones si debe utilizar un controlador que AWS Glue no soporte de forma nativa. Los trabajos de ETL pueden utilizar diferentes versiones de controladores JDBC para el origen y el destino de los datos, incluso aunque el origen y el destino sean el mismo producto de base de datos. Esto le permite migrar datos entre bases de datos de origen y destino con diferentes versiones. Para usar estas opciones, primero debe subir el archivo JAR del controlador JDBC a Amazon S3. + `"customJdbcDriverS3Path"`: ruta de Amazon S3 del controlador JDBC personalizado. + `"customJdbcDriverClassName"`: nombre de clase del controlador JDBC. + `"bulkSize"`: (opcional) se utiliza para configurar inserciones paralelas para acelerar las cargas masivas en los objetivos de JDBC. Especifique un valor entero para el grado de paralelismo que se utilizará al escribir o insertar datos. Esta opción resulta útil para mejorar el rendimiento de las escrituras en bases de datos como el repositorio de usuarios de Arch (AUR). + `"hashfield"` (Opcional) Una cadena, utilizada para especificar el nombre de una columna de la tabla JDBC que se utilizará para dividir los datos en particiones al leer tablas JDBC en paralelo. Proporcione “hashfield” O “hashexpression”. Para obtener más información, consulte [Lectura desde tablas de JDBC en paralelo](run-jdbc-parallel-read-job.md). + `"hashexpression"` (Opcional) Una cláusula de selección de SQL que devuelve un número entero. Se utiliza para dividir los datos de una tabla JDBC en particiones al leer tablas JDBC en paralelo. Proporcione “hashfield” O “hashexpression”. Para obtener más información, consulte [Lectura desde tablas de JDBC en paralelo](run-jdbc-parallel-read-job.md). + `"hashpartitions"` (Opcional) Un entero positivo. Se utiliza para especificar el número de lecturas paralelas de la tabla JDBC al leer tablas JDBC en paralelo. Valor predeterminado: 7. Para obtener más información, consulte [Lectura desde tablas de JDBC en paralelo](run-jdbc-parallel-read-job.md). + `"sampleQuery"`: (Opcional) Una instrucción de consulta SQL personalizada. Se utiliza para especificar un subconjunto de información en una tabla para recuperar una muestra del contenido de la tabla. **Cuando se configura sin tener en cuenta los datos, puede ser menos eficiente que los métodos DynamicFrame y provocar tiempos de espera o errores de falta de memoria.** Para obtener más información, consulte [Utilice sampleQuery](#aws-glue-programming-etl-jdbc-samplequery). + `"enablePartitioningForSampleQuery"`: (Opcional) Un booleano. Valor predeterminado: falso. Se utiliza para permitir la lectura de tablas JDBC en paralelo al especificar `sampleQuery`. **Si se establece en true, `sampleQuery` debe terminar con “where” (dónde) o “and” (y) para que Glue AWS agregue condiciones de partición.** Para obtener más información, consulte [Utilice sampleQuery](#aws-glue-programming-etl-jdbc-samplequery). + `"sampleSize"`: (Opcional) Un entero positivo. Limita el número de filas que devuelve la consulta de ejemplo. Funciona solo cuando `enablePartitioningForSampleQuery` es true. Si la partición no está habilitada, en su lugar debe agregar `"limit x"` en el `sampleQuery` para limitar el tamaño. Para obtener más información, consulte [Utilice sampleQuery](#aws-glue-programming-etl-jdbc-samplequery). ## Utilice sampleQuery En esta sección, se explica cómo utilizar `sampleQuery`, `sampleSize` y `enablePartitioningForSampleQuery`. `sampleQuery` puede ser una forma eficaz de muestrear algunas filas de su conjunto de datos. De forma predeterminada, la consulta la ejecuta un ejecutor único. Cuando se configura sin tener en cuenta los datos, puede ser menos eficiente que los métodos DynamicFrame y provocar tiempos de espera o errores de falta de memoria. Por lo general, solo es necesario ejecutar SQL en la base de datos subyacente como parte de la canalización de ETL por motivos de rendimiento. Si intenta obtener una vista previa de algunas filas de su conjunto de datos, considere utilizar [show](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-show). Si intenta transformar su conjunto de datos mediante SQL, considere utilizar [toDF](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-toDF) para definir una transformación de SparkSQL contra sus datos en forma de DataFrame. Si bien su consulta puede manipular una variedad de tablas, `dbtable` sigue siendo obligatoria. **Uso de sampleQuery para recuperar una muestra de la tabla** Cuando se utiliza el comportamiento predeterminado de sampleQuery para recuperar una muestra de los datos, Glue AWS no espera un rendimiento sustancial, por lo que ejecuta la consulta en un único ejecutor. Para limitar los datos que proporciona y no causar problemas de rendimiento, sugerimos que proporcione una cláusula `LIMIT` a SQL. **Example Uso de sampleQuery sin particionar** En el siguiente ejemplo de código, se muestra cómo utilizar `sampleQuery` sin particionar. ``` //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() ``` **Uso de sampleQuery contra conjuntos de datos más grandes** Si está leyendo un conjunto de datos grande, es posible que tenga que habilitar las particiones de JDBC para consultar una tabla en paralelo. Para obtener más información, consulte [Lectura desde tablas de JDBC en paralelo](run-jdbc-parallel-read-job.md). Para utilizar `sampleQuery` con la partición JDBC,configure `enablePartitioningForSampleQuery` como true. La activación de esta característica requiere que realice algunos cambios en su `sampleQuery`. Cuando utilice la partición JDBC con `sampleQuery`, la consulta debe terminar con “where” (dónde) o “and” (y) para que Glue AWS agregue condiciones de partición. Si desea limitar los resultados de su sampleQuery al leer tablas JDBC en paralelo, defina el parámetro `"sampleSize"` en lugar de especificar una cláusula `LIMIT`. **Example Uso de sampleQuery con particiones JDBC** En el siguiente ejemplo de código, se muestra cómo utilizar `sampleQuery` con partición 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() ``` **Notas y restricciones:** Las consultas de muestra no se pueden utilizar junto con los marcadores de trabajo. Se ignorará el estado del marcador cuando se brinden configuraciones para ambos. ## Utilice un controlador JDBC personalizado En los ejemplos de código siguientes, se muestra cómo se utilizan controladores JDBC personalizados para leer bases de datos JDBC y escribir en ellas. En ellos, se muestra cómo se lee una versión de un producto de base de datos y se escribe en una versión posterior del mismo producto. ------ #### [ 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) } } ``` ------ # Lectura desde tablas de JDBC en paralelo Puede establecer las propiedades de su tabla de JDBC para permitir a AWS Glue leer datos en paralelo. Cuando establece determinadas propiedades, le indica a AWS Glue que ejecute consultas SQL en paralelo en particiones lógicas de sus datos. Puede controlar la partición mediante el establecimiento de un campo hash o una expresión hash. También puede controlar el número de lecturas en paralelo que se utilizan para obtener acceso a los datos. La lectura paralela de tablas JDBC es una técnica de optimización que puede mejorar el rendimiento. Para obtener más información sobre el proceso de identificación de cuándo esta técnica es adecuada, consulte [Reducir la cantidad de datos escaneados](https://docs.aws.amazon.com/prescriptive-guidance/latest/tuning-aws-glue-for-apache-spark/parallelize-tasks.html) en la guía de *Prácticas recomendadas para el ajuste del rendimiento de AWS Glue para trabajos de Apache Spark * en las Recomendaciones de AWS. Para habilitar las lecturas en paralelo, puede establecer pares clave-valor en el campo de parámetros de la estructura de tabla. Utilice la notación JSON para establecer un valor del campo de parámetros de la tabla. Para obtener más información acerca de la edición de las propiedades de una tabla, consulte [Visualización y administración de los detalles de la tabla](tables-described.md#console-tables-details). También puede habilitar lecturas en paralelo cuando llama a los métodos de ETL (extraer, transformar y cargar) `create_dynamic_frame_from_options` y `create_dynamic_frame_from_catalog`. Para obtener más información sobre cómo especificar opciones en estos métodos, consulte [from\$1options](aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader-from_options) y [from\$1catalog](aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader-from_catalog). Puede utilizar este método para tablas de JDBC, es decir, la mayoría de tablas de datos cuya datos base es un almacén de datos de JDBC. Estas propiedades se ignoran cuando se leen las tablas de Amazon Redshift y Amazon S3. **hashfield** Establezca `hashfield` como el nombre de una columna de la tabla de JDBC que se va a utilizar para dividir los datos en particiones. Para obtener los mejores resultados, esta columna debe tener una distribución uniforme de valores para distribuir los datos entre particiones. Esta columna pueden ser de cualquier tipo de datos. AWS Glue genera consultas no solapadas que se ejecutan en paralelo para leer los datos particionados por esta columna. Por ejemplo, si los datos están distribuidos de manera uniforme por mes, puede utilizar la columna `month` para leer cada mes de datos en paralelo. ``` 'hashfield': 'month' ``` AWS Glue crea una consulta para aplicar la función hash en el valor del campo y convertirlo en un número de partición, y ejecuta la consulta para todas las particiones en paralelo. Para utilizar su propia consulta para dividir la lectura de una tabla, proporcione `hashexpression` en lugar de `hashfield`. **hashexpression** Establezca `hashexpression` como una expresión SQL (que cumpla la gramática del motor de base de datos JDBC) que devuelve un número entero. Una expresión simple es el nombre de cualquier columna numérica en la tabla. AWS Glue genera consultas SQL para leer los datos de JDBC en paralelo mediante `hashexpression` en la cláusula `WHERE` para dividir los datos. Por ejemplo, utilice la columna numérica `customerID` para leer los datos particionados por un número de cliente. ``` 'hashexpression': 'customerID' ``` Para que AWS Glue controle la partición, proporcione `hashfield` en lugar de `hashexpression`. **hashpartitions** Establezca `hashpartitions` como el número de lecturas en paralelo de la tabla de JDBC. Si no se define esta propiedad, el valor predeterminado es 7. Por ejemplo, establezca el número de lecturas en paralelo en `5`, de modo que AWS Glue lea los datos con cinco consultas (o menos). ``` 'hashpartitions': '5' ``` # Configuración de Amazon VPC para conexiones JDBC a los almacenes de datos de Amazon RDS de AWS Glue Al utilizar JDBC para conectar las bases de datos en Amazon RDS, se necesitará realizar una configuración adicional. Para habilitar la comunicación entre los componentes de AWS Glue y Amazon RDS, debe configurar el acceso a los almacenes de datos de Amazon RDS en Amazon VPC. Para que AWS Glue pueda comunicarse entre sus componentes, especifique un grupo de seguridad con una regla de entrada con autorreferencia para todos los puertos TCP. Al crear una regla con autorreferencia, se puede restringir el origen al mismo grupo de seguridad en la VPC. Una regla con autorreferencia no abrirá la VPC en todas las redes. Puede que el grupo de seguridad predeterminado de la VPC ya tenga una regla de entrada con autorreferencia para ALL Traffic. **Configuración del acceso entre AWS Glue y los almacenes de datos de Amazon RDS** 1. Inicie sesión en la Consola de administración de AWS y abra la consola de Amazon RDS en [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/). 1. En la consola de Amazon RDS, identifique los grupos de seguridad que se utilizan para controlar el acceso a la base de datos de Amazon RDS. En el panel de navegación a la izquierda, seleccione **Bases de datos** y, a continuación, seleccione la instancia a la que desea conectarse de la lista del panel principal. En la página de detalles de la base de datos, busque **Grupos de seguridad de VPC** dentro de la pestaña **Conectividad y seguridad**. 1. Según la arquitectura de la red, identifique qué grupo de seguridad asociado es mejor modificar para permitir el acceso al servicio de AWS Glue. Guarde el nombre *database-security-group* para consultarlo en el futuro. Si no hay un grupo de seguridad adecuado, siga las instrucciones para [brindar acceso a la instancia de base de datos en la VPC con la creación de un grupo de seguridad](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_SettingUp.html) en la documentación de Amazon RDS. 1. Inicie sesión en la Consola de administración de AWS y abra la consola de Amazon VPC en [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/). 1. En la consola de Amazon VPC, identifique cómo actualizar el *grupo de seguridad de la base de datos*. En el panel de navegación a la izquierda, seleccione **Grupos de seguridad** y, a continuación, seleccione *database-security-group* de la lista del panel principal. 1. Identifique el ID del grupo de seguridad para *database-security-group*, *database-sg-id*. Guárdelo para consultarlo en el futuro. En la página de detalles del grupo de seguridad, busque **ID del grupo de seguridad**. 1. Modifique las reglas de entrada del *database-security-group* y agregue una regla con autorreferencia para permitir que los componentes de AWS Glue se comuniquen. En concreto, agregue o confirme que haya una regla en la que **Tipo** sea `All TCP`, **Protocolo** sea `TCP`, **Intervalo de puertos** incluya todos los puertos y **Origen** sea *database-sg-id*. Compruebe que el grupo de seguridad que introduzca en **Origen** sea el mismo que el grupo de seguridad que está editando. En la página de detalles del grupo de seguridad, seleccione **Editar reglas de entrada**. La regla de entrada tiene un aspecto similar al siguiente: **** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/setup-vpc-for-glue-access.html) 1. Agregue reglas para el tráfico saliente. En la página de detalles del grupo de seguridad, seleccione **Editar reglas de salida**. En caso de que el grupo de seguridad permita todo el tráfico de salida, no se necesitan reglas independientes. Por ejemplo: **** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/setup-vpc-for-glue-access.html) Si la arquitectura de red está diseñada para restringir el tráfico de salida, cree las siguientes reglas salientes: Cree una regla con autorreferencia en la que **Tipo** sea `All TCP`, **Protocolo** sea `TCP`, **Intervalo de puertos** incluya todos los puertos y **Destino** sea *database-sg-id*. Compruebe que el grupo de seguridad que introduzca en **Destino** sea el mismo que el grupo de seguridad que está editando. En caso de que se utilice un punto de conexión de VPC de Amazon S3, agregue una regla HTTPS para permitir el tráfico desde la VPC a Amazon S3. Cree una regla en la que **Tipo** sea `HTTPS`, **Protocolo** sea`TCP`, **Intervalo de puertos** sea `443` y **Destino** sea el ID de la lista de prefijos administrados para el punto de conexión de la puerta de enlace de Amazon S3, *s3-prefix-list-id*. Para obtener más información sobre las listas de prefijos y los puntos de conexión de la puerta de enlace de Amazon S3, consulte [Gateway endpoints for Amazon S3](https://docs.aws.amazon.com//vpc/latest/privatelink/vpc-endpoints-s3.html) en la documentación de Amazon VPC. Por ejemplo: **** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/setup-vpc-for-glue-access.html)