# Conexões do Amazon S3
Você pode usar o AWS Glue para Spark para ler e gravar arquivos no Amazon S3. O AWS Glue para Spark é compatível com muitos formatos de dados comuns armazenados no Amazon S3 prontos para uso, incluindo CSV, Avro, JSON, Orc e Parquet. Para obter mais informações sobre os formatos de dados compatíveis, consulte [Opções de formato de dados para entradas e saídas no AWS Glue para Spark](aws-glue-programming-etl-format.md). Cada formato de dados pode ser compatível um conjunto diferente de atributos do AWS Glue. Consulte a página do seu formato de dados para obter os detalhes específicos da compatibilidade com atributos. Além disso, você pode ler e gravar arquivos versionados armazenados nas estruturas de data lake do Hudi, Iceberg e do Delta Lake. Para obter mais informações sobre estruturas de data lake, consulte [Usar estruturas de data lake com trabalhos do AWS Glue ETL](aws-glue-programming-etl-datalake-native-frameworks.md).
Com o AWS Glue, você pode particionar os objetos do Amazon S3 em uma estrutura de pastas durante a gravação e depois recuperá-los por partição para melhorar a performance usando uma configuração simples. Você também pode definir a configuração para agrupar arquivos pequenos ao transformar seus dados, para melhorar a performance. Você pode ler e gravar arquivos `bzip2` e `gzip` no Amazon S3.
**Topics**
+ [Configurar conexões do S3](#aws-glue-programming-etl-connect-s3-configure)
+ [Referência de opções de conexão do Amazon S3](#aws-glue-programming-etl-connect-s3)
+ [Sintaxes de conexão obsoletas para formatos de dados](#aws-glue-programming-etl-connect-legacy-format)
+ [Excluir classes de armazenamento do Amazon S3](aws-glue-programming-etl-storage-classes.md)
+ [Gerenciar partições para saída de ETL no AWS Glue](aws-glue-programming-etl-partitions.md)
+ [Ler arquivos de entrada em grupos maiores](grouping-input-files.md)
+ [Endpoints da Amazon VPC para o Amazon S3](vpc-endpoints-s3.md)
## Configurar conexões do S3
Para se conectar ao Amazon S3 em um trabalho do AWS Glue com Spark, você precisará de alguns pré-requisitos:
+ O trabalho do AWS Glue deve ter permissões do IAM para buckets relevantes do Amazon S3.
Em certos casos, você precisará configurar pré-requisitos adicionais:
+ Ao configurar o acesso entre contas, os controles de acesso apropriados no bucket do Amazon S3.
+ Por motivos de segurança, você pode optar por rotear suas solicitações do Amazon S3 por meio de uma Amazon VPC. Essa abordagem pode introduzir desafios de largura de banda e disponibilidade. Para obter mais informações, consulte [Endpoints da Amazon VPC para o Amazon S3](vpc-endpoints-s3.md).
## Referência de opções de conexão do Amazon S3
Designa uma conexão com o Amazon S3.
Como o Amazon S3 gerencia arquivos em vez de tabelas, além de especificar as propriedades de conexão fornecidas neste documento, você precisará especificar configurações adicionais sobre seu tipo de arquivo. Você especifica essas informações por meio de opções de formato de dados. Para obter mais informações sobre essas opções de formato, consulte [Opções de formato de dados para entradas e saídas no AWS Glue para Spark](aws-glue-programming-etl-format.md). Você também pode especificar essas informações fazendo a integração com o catálogo de dados do AWS Glue.
Para obter um exemplo da distinção entre opções de conexão e opções de formato, considere como o método [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) usa `connection_type`, `connection_options`, `format` e `format_options`. Esta seção discute especificamente os parâmetros fornecidos às `connection_options`.
Use as seguintes opções de conexão com `"connectionType": "s3"`:
+ `"paths"`: (obrigatório) uma lista de caminhos do Amazon S3 dos quais fazer a leitura.
+ `"exclusions"`: (Opcional) Uma string contendo uma lista JSON de padrões glob de estilo Unix padrões para excluir. Por exemplo, `"[\"**.pdf\"]"` exclui todos os arquivos PDF. Para obter mais informações sobre a sintaxe glob compatível com o AWS Glue, consulte [Incluir e excluir padrões](https://docs.aws.amazon.com/glue/latest/dg/define-crawler.html#crawler-data-stores-exclude).
+ `"compressionType"`: ou "`compression`": (opcional) especifica como os dados são compactados. Use `"compressionType"` para fontes do Amazon S3 e `"compression"` para destinos do Amazon S3. Isso geralmente não é necessário se os dados tem uma extensão de arquivo padrão. Os possíveis valores são `"gzip"` e `"bzip2"`). Formatos de compactação adicionais podem ser compatíveis com formatos específicos. Para obter os detalhes específicos da compatibilidade com atributos, consulte a página do seu formato de dados.
+ `"groupFiles"`: (opcional) o agrupamento de arquivos é ativado por padrão quando a entrada contiver mais de 50.000 arquivos. Para habilitar o agrupamento com menos de 50.000 arquivos, defina esse parâmetro como `"inPartition"`. Para desabilitar o agrupamento quando houver mais de 50.000 arquivos, defina esse parâmetro como `"none"`.
+ `"groupSize"`: (Opcional) O tamanho do grupo de destino em bytes. O padrão é calculado com base no tamanho de dados de entrada e o tamanho de seu cluster. Quando há menos de 50.000 arquivos de entrada, `"groupFiles"` deve ser definido como `"inPartition"` para poder entrar em vigor.
+ `"recurse"`: (Opcional) Se definido como verdadeiro, recursivamente lê arquivos em todos os subdiretórios de acordo com os caminhos especificados.
+ `"maxBand"`: (opcional, avançado) essa opção controla a duração, em milissegundos, após a qual a listagem `s3` provavelmente será consistente. Os arquivos com carimbos de data e hora de modificação que estão dentro dos últimos `maxBand` milissegundos são rastreados principalmente ao usar `JobBookmarks` para considerar a consistência final do Amazon S3. A maioria dos usuários não precisa definir essa opção. O valor padrão é 900.000 milissegundos, ou 15 minutos.
+ `"maxFilesInBand"`: (opcional, avançado) essa opção especifica o número máximo de arquivos que devem ser salvos dos últimos `maxBand` segundos. Se esse número for excedido, os arquivos extras são ignorados e apenas processados na próxima execução do trabalho. A maioria dos usuários não precisa definir essa opção.
+ `"isFailFast"`: (opcional) essa opção determina se um trabalho de ETL do AWS Glue lança exceções de análise do leitor. Se definido como `true`, os trabalhos falham rapidamente se quatro tentativas da tarefa do Spark falharem em analisar os dados corretamente.
+ `"catalogPartitionPredicate"`: (opcional) usado para leitura. O conteúdo de uma cláusula SQL `WHERE`. Usado ao ler tabelas do catálogo de dados com uma quantidade muito grande de partições. Recupera partições correspondentes dos índices do catálogo de dados. Usado com `push_down_predicate`, uma opção do método [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) (e outros métodos similares). Para obter mais informações, consulte [Filtragem do lado do servidor usando predicados de partição de catálogo](aws-glue-programming-etl-partitions.md#aws-glue-programming-etl-partitions-cat-predicates).
+ `"partitionKeys"`: (opcional) usado para gravação. Uma matriz de strings de rótulo da coluna. O AWS Glue particionará os dados conforme especificado por essa configuração. Para obter mais informações, consulte [Gravar partições](aws-glue-programming-etl-partitions.md#aws-glue-programming-etl-partitions-writing).
+ `"excludeStorageClasses"`: (opcional) usado para leitura. Uma matriz de strings especificando as classes de armazenamento do Amazon S3. O AWS Glue excluirá objetos do Amazon S3 com base nessa configuração. Para obter mais informações, consulte [Excluir classes de armazenamento do Amazon S3](aws-glue-programming-etl-storage-classes.md).
## Sintaxes de conexão obsoletas para formatos de dados
Certos formatos de dados podem ser acessados usando a sintaxe de um tipo de conexão específico. Essa sintaxe está obsoleta. Em seu lugar, recomendamos que você especifique os formatos usando o tipo de conexão `s3` e as opções de formato fornecidas em [Opções de formato de dados para entradas e saídas no AWS Glue para Spark](aws-glue-programming-etl-format.md).
### “connectionType”: “orc”
Designa uma conexão para arquivos armazenados no Amazon S3 no formato de arquivo [Apache Hive Optimized Row Columnar (ORC)](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+ORC).
Use as seguintes opções de conexão com `"connectionType": "orc"`:
+ `paths`: (obrigatório) uma lista de caminhos do Amazon S3 dos quais fazer a leitura.
+ *(Outras opções de pares de nome/valor)*: qualquer opção adicional, incluindo opções de formatação, são transmitidas diretamente à `DataSource` do SparkSQL.
### "connectionType": "parquet"
Designa uma conexão com arquivos armazenados no Amazon S3 no formato de arquivo [Apache Parquet](https://parquet.apache.org/docs/).
Use as seguintes opções de conexão com `"connectionType": "parquet"`:
+ `paths`: (obrigatório) uma lista de caminhos do Amazon S3 dos quais fazer a leitura.
+ *(Outras opções de pares de nome/valor)*: qualquer opção adicional, incluindo opções de formatação, são transmitidas diretamente à `DataSource` do SparkSQL.
# Excluir classes de armazenamento do Amazon S3
Se você estiver executando trabalhos de ETL do AWS Glue que leiam arquivos ou partições do Amazon Simple Storage Service (Amazon S3), poderá excluir alguns tipos de classe de armazenamento do Amazon S3.
As seguintes classes de armazenamento estão disponíveis no Amazon S3:
+ `STANDARD`: para armazenamento de uso geral de dados acessados com frequência.
+ `INTELLIGENT_TIERING`: para dados com padrões de acesso desconhecidos ou inconstantes.
+ `STANDARD_IA` e `ONEZONE_IA`: para dados de longa duração, mas acessados com menos frequência.
+ `GLACIER`, `DEEP_ARCHIVE` e `REDUCED_REDUNDANCY`: para arquivamento de longo prazo e preservação digital.
Para obter mais informações, consulte [Classes de armazenamento do Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage-class-intro.html) no *Guia do desenvolvedor do Amazon S3*.
Os exemplos nesta seção mostram como excluir as classes de armazenamento `GLACIER` e `DEEP_ARCHIVE`. Essas classes permitem que você liste arquivos, mas elas não permitem que você leia os arquivos, a menos que sejam restaurados. (Para obter mais informações, consulte [Restaurar objetos arquivados](https://docs.aws.amazon.com/AmazonS3/latest/dev/restoring-objects.html) no *Guia do desenvolvedor do Amazon S3*).
Ao usar exclusões de classe de armazenamento, você pode garantir que seus trabalhos do AWS Glue funcionarão em tabelas com partições entre esses níveis de classe de armazenamento. Sem exclusões, os trabalhos que leem dados desses níveis falham com o seguinte erro: AmazonS3Exception: The operation is not valid for the object's storage class (AmazonS3Exception: a operação não é válida para a classe de armazenamento do objeto).
Há diferentes maneiras de filtrar classes de armazenamento do Amazon S3 no AWS Glue.
**Topics**
+ [Excluir classes de armazenamento do Amazon S3 ao criar um quadro dinâmico](#aws-glue-programming-etl-storage-classes-dynamic-frame)
+ [Excluir classes de armazenamento do Amazon S3 em uma tabela do Data Catalog](#aws-glue-programming-etl-storage-classes-table)
## Excluir classes de armazenamento do Amazon S3 ao criar um quadro dinâmico
Para excluir classes de armazenamento do Amazon S3 ao criar um quadro dinâmico, use `excludeStorageClasses` em `additionalOptions`. O AWS Glue usa automaticamente sua própria implementação do `Lister` do Amazon S3 para listar e excluir arquivos correspondentes às classes de armazenamento especificadas.
Os exemplos de Python e Scala a seguir mostram como excluir as classes de armazenamento `GLACIER` e `DEEP_ARCHIVE` ao criar um quadro dinâmico.
Exemplo de Python do:
```
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"]
}
)
```
Exemplo do Scala:
```
val* *df = glueContext.getCatalogSource(
nameSpace, tableName, "", "my_transformation_context",
additionalOptions = JsonOptions(
Map("excludeStorageClasses" -> List("GLACIER", "DEEP_ARCHIVE"))
)
).getDynamicFrame()
```
## Excluir classes de armazenamento do Amazon S3 em uma tabela do Data Catalog
É possível especificar exclusões de classe de armazenamento a serem usadas por um trabalho de ETL do AWS Glue como um parâmetro de tabela no catálogo de dados do Glue da AWS. Você pode incluir esse parâmetro na operação `CreateTable` usando a AWS Command Line Interface (AWS CLI) ou de forma programática com a API. Para obter mais informações, consulte [Estrutura de tabelas](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-tables.html#aws-glue-api-catalog-tables-Table) e [CreateTable](https://docs.aws.amazon.com/glue/latest/webapi/API_CreateTable.html).
Você também pode especificar classes de armazenamento excluídas no console do AWS Glue.
**Como excluir classes de armazenamento do Amazon S3 (console)**
1. Faça login no Console de gerenciamento da AWS e abra o console do AWS Glue em [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. No painel de navegação à esquerda, escolha **Tables (Tabelas)**.
1. Escolha o nome da tabela na lista e, depois, escolha **Edit table (Editar tabela)**.
1. Em **Table properties (Propriedades da tabela)**, adicione **excludeStorageClasses** como uma chave e **[\$1"GLACIER\$1",\$1"DEEP\$1ARCHIVE\$1"]** como um valor.
1. Escolha **Aplicar**.
# Gerenciar partições para saída de ETL no AWS Glue
O particionamento é uma técnica importante para organizar os conjuntos de dados para que possam ser consultados com eficiência. Ele organiza dados em uma estrutura hierárquica de diretórios com base nos valores distintos de uma ou mais colunas.
Por exemplo, você pode decidir particionar os logs da sua aplicação no Amazon Simple Storage Service (Amazon S3) por data, divididos em ano, mês e dia. Os arquivos que correspondem a um único dia de dados são colocados com um prefixo, como `s3://my_bucket/logs/year=2018/month=01/day=23/`. Sistemas como o Amazon Athena, o Amazon Redshift Spectrum e agora o AWS Glue podem usar essas partições para filtrar dados por valor de partição sem precisar ler todos os dados subjacentes do Amazon S3.
Os crawlers não apenas inferem tipos de arquivo e esquemas, como também identificam automaticamente a estrutura da partição do seu conjunto de dados quando eles preenchem o AWS Glue Data Catalog. As colunas resultantes da partição ficam disponíveis para consulta em trabalhos de ETL do AWS Glue ou em mecanismos de consulta, como o Amazon Athena.
Após rastrear uma tabela, você pode visualizar as partições que o crawler criou. No console do AWS Glue, escolha **Tables** (Tabelas) no painel de navegação esquerdo. Escolha a tabela criada pelo crawler e, em seguida, selecione **View Partitions** (Exibir partições).
Para os caminhos particionados do Apache Hive no estilo `key=val`, os crawlers preenchem automaticamente o nome da coluna usando o nome da chave padrão. Caso contrário, ele usa nomes padrão, como `partition_0`, `partition_1` e assim por diante. Você pode alterar os nomes padrão no console. Para fazer isso, navegue até a tabela. Verifique se os índices existem na guia **Índices**. Se for esse o caso, você precisa excluí-las para continuar (você poderá recriá-las posteriormente usando os novos nomes das colunas). Em seguida, escolha **Editar esquema** e modifique os nomes das colunas de partição.
Nos scripts de ETL, você pode filtrar as colunas da partição. Uma vez que as informações de partição são armazenadas no Data Catalog, utilize as chamadas de API `from_catalog` para incluir as colunas de partição no `DynamicFrame`. Por exemplo, use `create_dynamic_frame.from_catalog` em vez de `create_dynamic_frame.from_options`.
Particionamento é uma técnica de otimização que reduz as varreduras de dados. 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/reduce-data-scan.html) no guia *Best practices for performance tuning AWS Glue for Apache Spark jobs* em AWS Prescriptive Guidance.
## Pré-filtragem usando a aplicação de predicados
Em muitos casos, você pode usar uma aplicação de predicado para filtrar partições sem precisar listar e ler todos os arquivos do seu conjunto de dados. Em vez de ler todo o conjunto de dados e, em seguida, filtrá-lo em um DynamicFrame, você pode aplicar o filtro diretamente nos metadados da partição no Data Catalog. Em seguida, você lista e lê somente o que você realmente precisa em um DynamicFrame.
Por exemplo, em Python, você pode gravar o seguinte.
```
glue_context.create_dynamic_frame.from_catalog(
database = "my_S3_data_set",
table_name = "catalog_data_table",
push_down_predicate = my_partition_predicate)
```
Isso cria um DynamicFrame que carrega somente as partições do Data Catalog que satisfazem a expressão do predicado. Dependendo do tamanho do subconjunto dos dados que você está carregando, isso pode economizar muito tempo de processamento.
A expressão do predicado pode ser qualquer expressão booleana compatível com Spark SQL. Tudo que você pode colocar em uma cláusula `WHERE` de uma consulta do SQL Spark funcionará. Por exemplo, a expressão de predicado `pushDownPredicate = "(year=='2017' and month=='04')"` carrega apenas as partições no Data Catalog que tiverem tanto `year` igual a 2017 quanto `month` igual a 04. Para obter mais informações, consulte a [Documentação do Apache Spark SQL](https://spark.apache.org/docs/2.1.1/sql-programming-guide.html) e, em especial, a [Referência das funções SQL em Scala](https://spark.apache.org/docs/2.1.1/api/scala/index.html#org.apache.spark.sql.functions$).
## Filtragem do lado do servidor usando predicados de partição de catálogo
A opção `push_down_predicate` é aplicada depois de listar todas as partições do catálogo e antes de listar arquivos do Amazon S3 para essas partições. Se você tiver muitas partições para uma tabela, a listagem de partições de catálogo ainda poderá incorrer em sobrecarga de tempo adicional. Para resolver essa sobrecarga, você pode usar a remoção de partição do lado do servidor com a opção `catalogPartitionPredicate`, que usa[índices de partição](https://docs.aws.amazon.com/glue/latest/dg/partition-indexes.html) no AWS Glue Data Catalog. Isso torna a filtragem de partição muito mais rápida quando você tem milhões de partições em uma tabela. Você pode usar `push_down_predicate` e `catalogPartitionPredicate` em `additional_options` juntos, se seu `catalogPartitionPredicate` exigir sintaxe de predicado que ainda não é suportada com os índices de partição de catálogo.
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()
```
**nota**
`push_down_predicate` e `catalogPartitionPredicate` usam sintaxes diferentes. O primeiro usa a sintaxe padrão do Spark SQL e o outro usa o analisador JSQL.
## Gravar partições
Por padrão, um DynamicFrame não é particionado quando é gravado. Todos os arquivos de saída são gravados no nível superior do caminho de saída especificado. Até recentemente, a única maneira de gravar um DynamicFrame em partições era convertê-lo em um DataFrame Spark SQL antes da gravação.
No entanto, DynamicFrames agora oferecem suporte ao particionamento nativo usando uma sequência de chaves, usando a opção `partitionKeys` ao criar um depósito. Por exemplo, o seguinte código Python grava um conjunto de dados no Amazon S3 no formato Parquet em diretórios particionados, de acordo com o tipo de campo. A partir daí, você pode processar essas partições usando outros sistemas, como o Amazon Athena.
```
glue_context.write_dynamic_frame.from_options(
frame = projectedEvents,
connection_type = "s3",
connection_options = {"path": "$outpath", "partitionKeys": ["type"]},
format = "parquet")
```
# Ler arquivos de entrada em grupos maiores
Você pode definir as propriedades das tabelas para habilitar um trabalho de ETL do AWS Glue a fim de agrupar arquivos quando eles são lidos em um armazenamento de dados do Amazon S3. Essas propriedades permitem que cada tarefa de ETL leia um grupo de arquivos de entrada em uma única partição na memória. Isso é especialmente útil quando há um grande número de arquivos pequenos no armazenamento de dados do Amazon S3. Ao definir determinadas propriedades, você instrui o AWS Glue a agrupar arquivos em uma partição de dados do Amazon S3 e a definir o tamanho dos grupos a serem lidos. Você também pode definir essas opções durante a leitura em um armazenamento de dados do Amazon S3 com o método `create_dynamic_frame.from_options`.
Para habilitar o agrupamento de arquivos para uma tabela, defina pares de chave/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ê pode usar esse método para habilitar o agrupamento de tabelas no Data Catalog com armazenamentos de dados do Amazon S3.
**groupFiles**
Defina **groupFiles** (agrupar arquivos) como `inPartition` para habilitar o agrupamento de arquivos em uma partição de dados do Amazon S3. O AWS Glue habilitará automaticamente o agrupamento se houver mais de 50.000 arquivos de entrada, como no exemplo a seguir.
```
'groupFiles': 'inPartition'
```
**groupSize**
Defina **groupSize** como o tamanho de destino de grupos em bytes. A propriedade **groupSize** é opcional. Se não for fornecida, o AWS Glue calculará um tamanho para usar todos os núcleos de CPU no cluster e, ao mesmo tempo, ainda reduzindo o número total de tarefas de ETL e partições na memória.
Por exemplo, o seguinte define o tamanho do grupo como 1 MB.
```
'groupSize': '1048576'
```
Observe que o `groupsize` deve ser definido com o resultado de um cálculo. Por exemplo 1024 \$1 1024 = 1048576.
**recurse**
Defina **recursivo** para `True` recursivamente ler arquivos em todos os subdiretórios ao especificar `paths` uma matriz de caminhos. Você não precisará definir **recurse** (recursivo) se `paths` for uma matriz de chaves de objeto no Amazon S3 ou se o formato de entrada for parquet/orc, como no exemplo a seguir.
```
'recurse':True
```
Se você estiver lendo no Amazon S3 diretamente usando o método `create_dynamic_frame.from_options`, adicione estas opções de conexão. Por exemplo, as seguintes tentativas de agrupar arquivos em grupos de 1 MB.
```
df = glueContext.create_dynamic_frame.from_options("s3", {'paths': ["s3://s3path/"], 'recurse':True, 'groupFiles': 'inPartition', 'groupSize': '1048576'}, format="json")
```
**nota**
Há suporte para `groupFiles` para DynamicFrames criados a partir dos seguintes formatos de dados: csv, ion, grokLog, json e xml. Não há suporte dessa opção para avro, parquet e orc.
# Endpoints da Amazon VPC para o Amazon S3
Por motivos de segurança, muitos clientes da AWS executam suas aplicações em um ambiente da Amazon Virtual Private Cloud (Amazon VPC). Com a Amazon VPC, você pode executar instâncias do Amazon EC2 em uma nuvem privada virtual, a qual é isolada logicamente de outras redes, incluindo a Internet pública. Com uma Amazon VPC, você tem controle sobre o intervalo de endereços IP, sub-redes, tabelas de roteamento, gateways de rede e configurações de segurança.
**nota**
Caso tenha criado sua conta da AWS após 4/12/2013, você já tem uma VPC padrão em cada região da AWS. Você pode começar a usar sua VPC padrão imediatamente sem qualquer configuração adicional.
Para obter mais informações, consulte [Suas sub-redes e VPC padrão](https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html) no Manual do usuário da Amazon VPC.
Muitos clientes têm preocupações legítimas com a segurança e a privacidade sobre o envio e o recebimento de dados pela Internet pública. Os clientes podem resolver essas preocupações usando uma rede privada virtual (VPN) para rotear todo o tráfego de rede do Amazon S3 por meio da infraestrutura de rede corporativa deles. No entanto, essa abordagem pode introduzir desafios de largura de banda e disponibilidade.
Os endpoints da VPC para o Amazon S3 podem reduzir esses desafios. Um endpoint da VPC para o Amazon S3 permite ao AWS Glue usar endereços IP privados para acessar o Amazon S3 sem exposição à Internet pública. O AWS Glue não precisa de endereços IP públicos e você não precisa de um gateway da Internet, de um dispositivo NAT ou de um gateway privado virtual na sua VPC. Use as políticas de endpoint para controlar o acesso ao Amazon S3. O tráfego entre sua VPC e o produto da AWS não sai da rede da Amazon.
Ao criar um endpoint da VPC para o Amazon S3, quaisquer solicitações para um endpoint do Amazon S3 dentro da região (por exemplo: *s3.us-west-2.amazonaws.com*) são encaminhadas para um endpoint privado do Amazon S3 dentro da rede da Amazon. Você não precisa modificar suas aplicações em execução em instâncias do Amazon EC2 na VPC. O nome do endpoint permanece o mesmo, mas a rota para o Amazon S3 permanece inteiramente dentro da rede da Amazon e não acessa a Internet pública.
Para obter mais informações sobre o endpoints da VPC, consulte [Endpoints da VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints.html) no Manual do usuário da Amazon VPC.
O diagrama a seguir mostra como o AWS Glue pode usar um endpoint da VPC para acessar o Amazon S3.
![\[Fluxo de tráfego de rede que mostra a conexão da VPC com o Amazon S3.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/PopulateCatalog-vpc-endpoint.png)
**Para configurar o acesso ao Amazon S3**
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 painel de navegação à esquerda, escolha **Endpoints**.
1. Escolha **Create Endpoint** (Criar endpoint) e siga as etapas para criar um endpoint da VPC do Amazon S3 do tipo Gateway.