# Conexões JDBC Certos tipos de banco de dados, geralmente relacionais, são compatíveis com conexão por meio do padrão JDBC. Para obter mais informações sobre o JDBC, consulte a documentação da [Java JDBC API](https://docs.oracle.com/javase/8/docs/technotes/guides/jdbc/). O AWS Glue oferece suporte nativo à conexão a determinados bancos de dados por meio de conectores JDBC; as bibliotecas JDBC são fornecidas nos trabalhos do AWS Glue Spark. Ao se conectar a esses tipos de banco de dados usando as bibliotecas do AWS Glue, você tem acesso a um conjunto padrão de opções. Os valores JDBCConnectionType incluem o seguinte: + `"connectionType": "sqlserver"`: Designa uma conexão a um banco de dados do Microsoft SQL Server. + `"connectionType": "mysql"`: designa uma conexão com um banco de dados MySQL. + `"connectionType": "oracle"`: designa uma conexão com um banco de dados Oracle. + `"connectionType": "postgresql"`: designa uma conexão com um banco de dados PostgreSQL. + `"connectionType": "redshift"`: designa uma conexão com um banco de dados do Amazon Redshift. Para obter mais informações, consulte [Conexões do Redshift](aws-glue-programming-etl-connect-redshift-home.md). A tabela a seguir lista as versões de driver do JDBC compatíveis com o AWS Glue. | Produto | Versões do driver JDBC para o Glue 5.1 | Versões do driver JDBC para o Glue 5.0 | Versões do driver JDBC para o Glue 4.0 | Versões do driver JDBC para o Glue 3.0 | Versões do driver JDBC para o 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 Para o tipo de conexão do Amazon Redshift, todas as outras opções de pares nome/valor que estão incluídas nas opções de conexão para uma conexão JDBC, incluindo opções de formatação, são passadas diretamente para a fonte de dados SparkSQL subjacente. Nos trabalhos do AWS Glue com Spark no AWS Glue 4.0 e versões posteriores, o conector nativo do AWS Glue para o Amazon Redshift usa a integração do Amazon Redshift para o Apache Spark. Para obter informações sobre como usar essas opções, consulte [Integração do Amazon Redshift para o Apache Spark](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html). Nas versões anteriores, consulte a [fonte de dados do Amazon Redshift para Spark](https://github.com/databricks/spark-redshift). Para configurar a Amazon VPC para se conectar aos armazenamentos de dados do Amazon RDS usando JDBC, consulte [Configurar um Amazon VPC para conexões JDBC aos armazenamentos de dados do Amazon RDS desde o AWS Glue](setup-vpc-for-glue-access.md). **nota** Os trabalhos do AWS são associados apenas a uma sub-rede durante uma execução. Isso pode afetar sua capacidade de se conectar a várias fontes de dados por meio do mesmo trabalho. Esse comportamento não se limita às fontes JDBC. **Topics** + [Referência de opções de conexão JDBC](#aws-glue-programming-etl-connect-jdbc) + [Usar sampleQuery](#aws-glue-programming-etl-jdbc-samplequery) + [Usar o driver JDBC personalizado](#aws-glue-programming-etl-jdbc-custom-driver) + [Leitura de tabelas JDBC em paralelo](run-jdbc-parallel-read-job.md) + [Configurar um Amazon VPC para conexões JDBC aos armazenamentos de dados do Amazon RDS desde o AWS Glue](setup-vpc-for-glue-access.md) ## Referência de opções de conexão JDBC Se você já tiver uma conexão JDBC do AWS Glue definida, poderá reutilizar as propriedades de configuração nela definidas, como: url, usuário e senha, para não precisar especificá-las no código como opções de conexão. Esse atributo só está disponível no AWS Glue 3.0 e versões posteriores. Para fazer isso, use as seguintes propriedades de conexão: + `"useConnectionProperties"`: defina como "true" para indicar que você deseja usar a configuração de uma conexão. + `"connectionName"`: insira o nome da conexão da qual recuperar a configuração; a conexão deve ser definida na mesma região da tarefa. Use estas opções de conexão com conexões JDBC: + `"url"`: (Obrigatório) O URL do JDBC para o banco de dados. + `"dbtable"`: (obrigatório) o banco de dados a ser lido. Para armazenamentos de dados JDBC que oferecem suporte a esquemas dentro de um banco de dados, especifique `schema.table-name`. Se um esquema não for fornecido, o esquema "público" padrão será usado. + `"user"`: (obrigatório) o nome de usuário a ser usado ao se conectar. + `"password"`: (Obrigatório) A senha a ser usada ao se conectar. + (Opcional) As opções a seguir permitem que você forneça um driver do JDBC personalizado. Use estas opções se for necessário usar um driver que não seja compatível nativamente com o AWS Glue. Os trabalhos de ETL podem usar diferentes versões de driver JDBC para o destino e a fonte de dados, mesmo que o destino e a origem sejam o mesmo produto de banco de dados. Isso permite migrar dados entre bancos de dados de fonte e de destino com versões diferentes. Para usar estas opções, é necessário primeiro fazer upload do arquivo JAR do driver do JDBC para o Amazon S3. + `"customJdbcDriverS3Path"`: o caminho no Amazon S3 do driver JDBC personalizado. + `"customJdbcDriverClassName"`: o nome da classe do driver JDBC. + `"bulkSize"`: (opcional) usado para configurar inserções paralelas para acelerar cargas em massa em destinos de JDBC. Especifique um valor inteiro para o grau de paralelismo a ser usado ao gravar ou inserir dados. Essa opção é útil para melhorar a performance de gravações em bancos de dados, como o Arch User Repository (AUR). + `"hashfield"` (Opcional) Uma string, usada para especificar o nome de uma coluna na tabela JDBC a ser usada para dividir os dados em partições ao ler tabelas JDBC em paralelo. Forneça "hashfield" OU "hashexpression". Para obter mais informações, consulte [Leitura de tabelas JDBC em paralelo](run-jdbc-parallel-read-job.md). + `"hashexpression"` (Opcional) Uma cláusula de seleção SQL retornando um número inteiro. Usada para dividir os dados em uma tabela JDBC em partições ao ler tabelas JDBC em paralelo. Forneça "hashfield" OU "hashexpression". Para obter mais informações, consulte [Leitura de tabelas JDBC em paralelo](run-jdbc-parallel-read-job.md). + `"hashpartitions"` (Opcional) Um número inteiro positivo. Usado para especificar o número de leituras paralelas da tabela JDBC ao ler tabelas JDBC em paralelo. Padrão: 7. Para obter mais informações, consulte [Leitura de tabelas JDBC em paralelo](run-jdbc-parallel-read-job.md). + `"sampleQuery"`: (opcional) uma instrução de consulta SQL personalizada. Usada para especificar um subconjunto de informações em uma tabela para recuperar uma amostra do conteúdo da tabela. **Quando configurada sem considerar os dados, pode ser menos eficiente do que os métodos DynamicFrame, causando timeouts ou erros de falta de memória.** Para obter mais informações, consulte [Usar sampleQuery](#aws-glue-programming-etl-jdbc-samplequery). + `"enablePartitioningForSampleQuery"`: (opcional) um booleano. Padrão: falso. Usado para permitir a leitura de tabelas JDBC em paralelo ao especificar `sampleQuery`. **Se definido como verdadeiro, `sampleQuery` deve terminar com "where" ou "and" para o AWS Glue para anexar condições de particionamento.** Para obter mais informações, consulte [Usar sampleQuery](#aws-glue-programming-etl-jdbc-samplequery). + `"sampleSize"`: (opcional) um número inteiro positivo. Limita o número de linhas retornado pela consulta de amostra. Funciona somente quando `enablePartitioningForSampleQuery` é verdadeiro. Se o particionamento não estiver habilitado, você deverá adicionar diretamente `"limit x"` à `sampleQuery` para limitar o tamanho. Para obter mais informações, consulte [Usar sampleQuery](#aws-glue-programming-etl-jdbc-samplequery). ## Usar sampleQuery Esta seção explica como usar `sampleQuery`, `sampleSize` e `enablePartitioningForSampleQuery`. `sampleQuery` pode ser uma forma eficiente de amostrar algumas linhas do conjunto de dados. Por padrão, a consulta é executada por um único executor. Quando configurada sem considerar os dados, pode ser menos eficiente do que os métodos DynamicFrame, causando timeouts ou erros de falta de memória. A execução de SQL no banco de dados subjacente como parte do pipeline de ETL geralmente só é necessária para fins de performance. Se você estiver tentando visualizar algumas linhas do conjunto de dados, considere usar [show](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-show). Se você estiver tentando transformar o conjunto de dados usando SQL, considere usar [toDF](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-toDF) para definir uma transformação de SparkSQL para os dados no formato DataFrame. Embora sua consulta possa manipular uma variedade de tabelas, a `dbtable` continua sendo obrigatória. **Usar sampleQuery para recuperar uma amostra da tabela** Ao usar o comportamento padrão de sampleQuery para recuperar uma amostra dos dados, o AWS Glue não espera um throughput substancial, assim ele executa a consulta em um único executor. Para limitar os dados que você fornece e não causar problemas de performance, sugerimos que você inclua uma cláusula `LIMIT` no SQL. **Example Usar SampleQuery sem particionamento** O exemplo de código a seguir mostra como usar `sampleQuery` sem particionamento. ``` //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() ``` **Usar sampleQuery em conjuntos de dados maiores** Se você estiver lendo um conjunto de dados grande, talvez seja necessário ativar o particionamento JDBC para consultar uma tabela em paralelo. Para obter mais informações, consulte [Leitura de tabelas JDBC em paralelo](run-jdbc-parallel-read-job.md). Para usar `sampleQuery` com particionamento JDBC, defina `enablePartitioningForSampleQuery` como verdadeiro. A ativação desse atributo exige que você faça algumas alterações na `sampleQuery`. Ao usar particionamento JDBC com `sampleQuery`, a consulta deve terminar com "where" ou "and" para o AWS Glue para anexar condições de particionamento. Se você quiser limitar os resultados da sampleQuery ao ler tabelas JDBC em paralelo, defina o parâmetro `"sampleSize"` em vez de especificar uma cláusula `LIMIT`. **Example Usar SampleQuery com particionamento JDBC** O exemplo de código a seguir mostra como usar `sampleQuery` com particionamento 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() ``` **Regras e restrições:** Consultas de amostra não podem ser usadas junto com marcadores de trabalho. O estado do marcador será ignorado quando a configuração de ambos for fornecida. ## Usar o driver JDBC personalizado Os exemplos de código a seguir mostram como fazer a leitura e gravação de bancos de dados JDBC com drivers JDBC personalizados. Eles demonstram a leitura de uma versão de um produto de banco de dados e a gravação em uma versão posterior do mesmo produto. ------ #### [ 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) } } ``` ------ # Leitura de tabelas JDBC em paralelo Você pode definir propriedades da sua tabela JDBC para permitir que o AWS Glue leia dados em paralelo. Ao definir determinadas propriedades, você instrui o AWS Glue a executar consultas SQL paralelas em partições lógicas dos seus dados. Você pode controlar o particionamento definindo um campo de hash ou uma expressão de hash. Você também pode controlar o número de leituras paralelas que são usadas para acessar seus dados. Ler as tabelas JDBC em paralelo é uma técnica de otimização que pode melhorar a performance. Para obter mais informações sobre o processo para identificar quando essa técnica é adequada, consulte [Reduce the amount of data scan](https://docs.aws.amazon.com/prescriptive-guidance/latest/tuning-aws-glue-for-apache-spark/parallelize-tasks.html) no guia *Best practices for performance tuning AWS Glue for Apache Spark jobs* em AWS Prescriptive Guidance. Para habilitar leituras paralelas, você pode definir pares de chave e valor no campo de parâmetros da estrutura da tabela. Use a notação JSON para definir um valor para o campo de parâmetro da tabela. Para obter mais informações sobre como editar as propriedades de uma tabela, consulte [Exibir e gerenciar detalhes da tabela](tables-described.md#console-tables-details). Você também pode habilitar leituras paralelas ao chamar os métodos de ETL (extração, transformação e carregamento) `create_dynamic_frame_from_options` e `create_dynamic_frame_from_catalog`. Para obter mais informações sobre como especificar opções nesses 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) e [from\$1catalog](aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-reader-from_catalog). Você pode usar esse método para tabelas JDBC, ou seja, a maioria das tabelas cujos dados de base são um armazenamento de dados JDBC. Essas propriedades são ignoradas durante a leitura de tabelas do Amazon RedShift e Amazon S3. **hashfield** Defina `hashfield` como o nome de uma coluna na tabela JDBC a ser usada para dividir os dados em partições. Para obter os melhores resultados, essa coluna deve ter uma distribuição uniforme de valores para distribuir os dados entre partições. Essa coluna pode ser de qualquer tipo de dados. O AWS Glue gera consultas não sobrepostas que são executadas em paralelo para ler os dados particionados por essa coluna. Por exemplo, se os dados estiverem distribuídos uniformemente por mês, você poderá usar a coluna `month` para ler cada mês de dados em paralelo. ``` 'hashfield': 'month' ``` O AWS Glue cria uma consulta para definir o hash do valor do campo como um número de partição e executa essa consulta para todas as partições em paralelo. Para usar sua própria consulta para particionar uma leitura de tabela, forneça uma tabela `hashexpression` em vez de um `hashfield`. **hashexpression** Defina `hashexpression` como uma expressão SQL (de acordo com a gramática do mecanismo de banco de dados JDBC) que retorne um número inteiro. Uma expressão simples é o nome de qualquer coluna numérica na tabela. O AWS Glue gera consultas SQL para ler os dados JDBC em paralelo usando o `hashexpression` na cláusula `WHERE` para particionar os dados. Por exemplo, use a coluna numérica `customerID` para ler dados particionados por um número de cliente. ``` 'hashexpression': 'customerID' ``` Para que o AWS Glue controle o particionamento, forneça um `hashfield` em vez de um `hashexpression`. **hashpartitions** Defina `hashpartitions` como o número de leituras paralelas da tabela JDBC. Se essa propriedade não for definida, o valor padrão será 7. Por exemplo, defina o número de leituras em paralelo como `5` para que o AWS Glue lê os dados com cinco consultas (ou menos). ``` 'hashpartitions': '5' ``` # Configurar um Amazon VPC para conexões JDBC aos armazenamentos de dados do Amazon RDS desde o AWS Glue Ao usar o JDBC para conectar a bancos de dados no Amazon RDS, você precisará realizar configurações adicionais. Para permitir que os componentes do AWS Glue se comuniquem com o Amazon RDS, é necessário configurar o acesso aos seus armazenamentos de dados do Amazon RDS no Amazon VPC. Para permitir que o AWS Glue se comunique entre seus componentes, especifique um grupo de segurança com uma regra de entrada de autorreferência para todas as portas TCP. Ao criar uma regra de autorreferência, você pode restringir a origem ao mesmo security group na VPC. Uma regra de autorreferência não abrirá a VPC para todas as redes. O security group padrão para sua VPC pode já conter uma regra de entrada de autorreferenciada para ALL Traffic. **Para configurar o acesso entre o AWS Glue e os armazenamentos de dados do Amazon RDS** 1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon RDS em [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/). 1. No console do Amazon RDS, identifique os grupos de segurança usados para controlar o acesso ao banco de dados do Amazon RDS. No painel de navegação esquerdo, escolha **Bancos de dados** e, em seguida, selecione a instância à qual você gostaria de se conectar na lista no painel principal. Na página de detalhes do banco de dados, encontre **Grupos de segurança da VPC** na guia **Conectividade e segurança**. 1. Com base na sua arquitetura de rede, identifique qual grupo de segurança associado é melhor modificar para permitir o acesso ao serviço AWS Glue. Salve seu nome, *database-security-group*, para referência futura. Se não houver um grupo de segurança apropriado, siga as instruções para [Fornecer acesso à instância de banco de dados na VPC criando um grupo de segurança](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_SettingUp.html) na documentação do Amazon RDS. 1. Faça login no Console de gerenciamento da AWS e abra o console da Amazon VPC em [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/). 1. No console do Amazon VPC, identifique como atualizar *database-security-group*. No painel de navegação esquerdo, escolha **Grupos de segurança** e, em seguida, selecione *database-security-group* na lista no painel principal. 1. Identifique o ID do grupo de segurança para *database-security-group*, *database-sg-id*. Guarde-o para uso posterior. Na página de detalhes do grupo de segurança, encontre **ID do grupo de segurança**. 1. Altere as regras de entrada para *database-security-group* e adicione uma regra de autorreferência para permitir que os componentes do AWS Glue se comuniquem. Especificamente, adicione ou confirme que existe uma regra em que **Tipo** é `All TCP`, **Protocolo** é `TCP`, **Intervalo de portas** inclui todas as portas e **Origem** é *database-sg-id*. Verifique se o grupo de segurança que você inseriu para **Origem** é o mesmo que o grupo de segurança que você está editando. Na página de detalhes do grupo de segurança, selecione **Editar regras de entrada**. A regra de entrada é semelhante a esta: **** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/setup-vpc-for-glue-access.html) 1. Adicione regras para o tráfego de saída. Na página de detalhes do grupo de segurança, selecione **Editar regras de saída**. Se o grupo de segurança permitir todo o tráfego de saída, você não precisará de regras separadas. Por exemplo: **** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/setup-vpc-for-glue-access.html) Se sua arquitetura de rede foi desenvolvida para que você restrinja o tráfego de saída, crie as seguintes regras de saída: Crie uma regra de autorreferência em que **Tipo** é `All TCP`, **Protocolo** é `TCP`, **Intervalo de portas** inclui todas as portas e **Destino** é *database-sg-id*. Verifique se o grupo de segurança que você inseriu para **Destino** é o mesmo que o grupo de segurança que você está editando. Se você estiver usando um endpoint da VPC do Amazon S3, adicione uma regra de HTTPS para permitir o tráfego da VPC para o Amazon S3. Crie uma regra em que **Tipo** é `HTTPS`, **Protocolo** é `TCP`, **Intervalo de portas** é `443` e **Destino** é o ID da lista de prefixos gerenciados para o endpoint do gateway Amazon S3, *s3-prefix-list-id*. Para obter mais informações sobre listas de prefixos e endpoints de gateway do Amazon S3, consulte [Endpoints de gateway para Amazon S3](https://docs.aws.amazon.com//vpc/latest/privatelink/vpc-endpoints-s3.html) na documentação do Amazon VPC. Por exemplo: **** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/setup-vpc-for-glue-access.html)