# Exportar dados de uma instância de banco de dados do RDS para PostgreSQL para o Amazon S3
Consulte dados em um RDS para PostgreSQL instância de banco de dados e exporte-os diretamente para arquivos armazenados em um bucket do Amazon S3. Para fazer isso, primeiro instale a extensão `aws_s3` do RDS para PostgreSQL. Essa extensão fornece as funções usadas para exportar os resultados de consultas para o Amazon S3. A seguir, é possível descobrir como instalar a extensão e exportar dados para o Amazon S3.
**nota**
A exportação entre contas não é compatível com o Amazon S3.
Todas as versões do RDS para PostgreSQL disponíveis no momento são compatíveis com a exportação de dados do Amazon Simple Storage Service. Para obter informações detalhadas sobre as versões, consulte [Atualizações do Amazon RDS para PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/PostgreSQLReleaseNotes/postgresql-versions.html) nas *Notas de lançamento do Amazon RDS para PostgreSQL*.
Se você não tiver um bucket configurado para sua exportação, consulte os tópicos a seguir no *Guia do usuário do Amazon Simple Storage Service*.
+ Configuração do Amazon S3
+ [Como criar um bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html)
Por padrão, os dados exportados do RDS para PostgreSQL ao Amazon S3 usam criptografia do lado do servidor com uma Chave gerenciada pela AWS. Se estiver usando a criptografia do bucket, o bucket do Amazon S3 deverá ser criptografado com uma chave do AWS Key Management Service (AWS KMS) (SSE-KMS). No momento, os buckets criptografados com chaves gerenciadas pelo Amazon S3 (SSE-S3) não são compatíveis.
**nota**
É possível salvar os dados do snapshot do banco de dados no Amazon S3 usando o Console de gerenciamento da AWS, a AWS CLI ou a API do Amazon RDS. Para obter mais informações, consulte [Exportação de dados de snapshot de banco de dados para o Amazon S3 para Amazon RDS](USER_ExportSnapshot.md).
**Topics**
+ [Instalar a extensão aws\$1s3](#USER_PostgreSQL.S3Export.InstallExtension)
+ [Visão geral da exportação de dados para o Amazon S3](#postgresql-s3-export-overview)
+ [Especificar o caminho do arquivo do Amazon S3 para o qual exportar](#postgresql-s3-export-file)
+ [Configurar o acesso a um bucket do Amazon S3](postgresql-s3-export-access-bucket.md)
+ [Exportar dados de consulta usando a função aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-examples.md)
+ [Referência de funções](postgresql-s3-export-functions.md)
+ [Solução de problemas de acesso ao Amazon S3](postgresql-s3-export-troubleshoot.md)
## Instalar a extensão aws\$1s3
Antes de usar o Amazon Simple Storage Service com a sua instância de banco de dados do RDS para PostgreSQL, você precisa instalar a extensão `aws_s3`. Essa extensão fornece funções para exportar dados de uma instância de banco de dados do RDS para PostgreSQL para um bucket do Amazon S3. Também fornece as funções para importar dados do Amazon S3. Para obter mais informações, consulte [Importar dados do Amazon S3 para uma instância de banco de dados do RDS para PostgreSQL](USER_PostgreSQL.S3Import.md). A extensão `aws_s3` depende de algumas das funções auxiliares da extensão `aws_commons`, que é instalada automaticamente quando necessária.
**Como instalar a extensão `aws_s3`**
1. Use psql (ou pgAdmin) para se conectar à instância de banco de dados do RDS para PostgreSQL como um usuário que tem privilégios `rds_superuser`. Se você manteve o nome padrão durante o processo de configuração, se conectará como `postgres`.
```
psql --host=111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password
```
1. Para instalar a extensão, execute o comando a seguir.
```
postgres=> CREATE EXTENSION aws_s3 CASCADE;
NOTICE: installing required extension "aws_commons"
CREATE EXTENSION
```
1. Para verificar se a extensão está instalada, você pode usar o metacomando psql `\dx`.
```
postgres=> \dx
List of installed extensions
Name | Version | Schema | Description
-------------+---------+------------+---------------------------------------------
aws_commons | 1.2 | public | Common data types across AWS services
aws_s3 | 1.1 | public | AWS S3 extension for importing data from S3
plpgsql | 1.0 | pg_catalog | PL/pgSQL procedural language
(3 rows)
```
As funções para importar dados do Amazon S3 e exportar dados para o Amazon S3 agora estão disponíveis para uso.
### Confira se a sua versão do RDS para PostgreSQL permite exportações para o Amazon S3.
Você pode verificar se sua versão do RDS para PostgreSQL oferece suporte à exportação para o Amazon S3 usando o comando `describe-db-engine-versions`. O exemplo a seguir verifica a compatibilidade com a versão 10.14.
```
aws rds describe-db-engine-versions --region us-east-1
--engine postgres --engine-version 10.14 | grep s3Export
```
Se a saída incluir a string `"s3Export"`, o mecanismo é compatível com exportações do Amazon S3. Caso contrário, não há compatibilidade.
## Visão geral da exportação de dados para o Amazon S3
Para exportar dados armazenados em um banco de dados RDS para PostgreSQL para um bucket do Amazon S3, use o procedimento a seguir.
**Para exportar dados do RDS para PostgreSQL para o S3**
1. Identifique um caminho de arquivo do Amazon S3 a ser usado para exportar dados. Para obter detalhes sobre esse processo, consulte [Especificar o caminho do arquivo do Amazon S3 para o qual exportar](#postgresql-s3-export-file).
1. Conceda permissão para acessar o bucket do Amazon S3.
Para exportar dados para um arquivo do Amazon S3, forneça à instância de banco de dados do RDS para PostgreSQL permissão para acessar o bucket do Amazon S3 a ser usado para armazenamento pela exportação. Isso inclui as seguintes etapas:
1. Crie uma política do IAM que forneça acesso a um bucket do Amazon S3 para o qual você deseja exportar.
1. Crie uma função do IAM.
1. Anexe a política criada à função criada.
1. Adicione esse perfil do IAM à instância de banco de dados.
Para obter detalhes sobre esse processo, consulte [Configurar o acesso a um bucket do Amazon S3](postgresql-s3-export-access-bucket.md).
1. Identifique uma consulta de banco de dados para obter os dados. Exporte os dados da consulta chamando a função `aws_s3.query_export_to_s3`.
Após concluir as tarefas de preparação anteriores, use a função [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3) para exportar os resultados da consulta para o Amazon S3. Para obter detalhes sobre esse processo, consulte [Exportar dados de consulta usando a função aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-examples.md).
## Especificar o caminho do arquivo do Amazon S3 para o qual exportar
Especifique as seguintes informações para identificar o local no Amazon S3 para o qual deseja exportar dados:
+ Nome do bucket – um *bucket* é um contêiner para objetos ou arquivos do Amazon S3.
Para ter mais informações sobre como armazenar dados com o Amazon S3, consulte [Criação de um bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html) e [Trabalhar com objetos](https://docs.aws.amazon.com/AmazonS3/latest/userguide/uploading-downloading-objects.html) no *Guia do usuário do Amazon Simple Storage Service*.
+ Caminho do arquivo – o caminho do arquivo identifica onde a exportação é armazenada no bucket do Amazon S3. O caminho do arquivo consiste no seguinte:
+ Um prefixo de caminho opcional que identifica um caminho de pasta virtual.
+ Um prefixo de arquivo que identifica um ou mais arquivos a serem armazenados. Exportações maiores são armazenadas em vários arquivos, cada um com um tamanho máximo de aproximadamente 6 GB. Os nomes de arquivos adicionais têm o mesmo prefixo de arquivo, mas com o acréscimo de `_partXX`. O `XX` representa 2, depois 3 e assim por diante.
Por exemplo, um caminho de arquivo com uma pasta `exports` e um prefixo de arquivo `query-1-export` é `/exports/query-1-export`.
+ Região da AWS (opcional): a região da AWS onde o bucket do Amazon S3 está localizado. Se você não especificar um valor de região da AWS, o Amazon RDS salvará os arquivos no Amazon S3, na mesma região da AWS que o cluster de banco de dados de exportação.
**nota**
Atualmente, a região AWS deve ser a mesma que a região da instância de Bancos de Dados de exportação .
Para obter uma listagem de nomes de regiões da AWS e os valores associados, consulte [Regiões, zonas de disponibilidade e Local Zones](Concepts.RegionsAndAvailabilityZones.md).
Para manter as informações do arquivo do Amazon S3 sobre onde a exportação deve ser armazenada, você pode usar a função [aws\$1commons.create\$1s3\$1uri](postgresql-s3-export-functions.md#aws_commons.create_s3_uri) para criar uma estrutura `aws_commons._s3_uri_1` composta da seguinte forma.
```
psql=> SELECT aws_commons.create_s3_uri(
'amzn-s3-demo-bucket',
'sample-filepath',
'us-west-2'
) AS s3_uri_1 \gset
```
Posteriormente, você fornece esse valor de `s3_uri_1` como um parâmetro na chamada para a função [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3). Para ver exemplos, consulte [Exportar dados de consulta usando a função aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-examples.md).
# Configurar o acesso a um bucket do Amazon S3
Para exportar dados ao Amazon S3, forneça à instância de banco de dados PostgreSQL permissão para acessar o bucket do Amazon S3 para o qual os arquivos serão enviados.
Para fazer isso, use o procedimento a seguir.
**Como conceder acesso a uma instância de banco de dados PostgreSQL ao Amazon S3 por meio de um perfil do IAM**
1. Crie uma política do IAM.
Essa política concede ao bucket e ao objeto as permissões para que a instância de banco de dados PostgreSQL acesse o Amazon S3.
Como parte da criação dessa política, execute as seguintes etapas:
1. Inclua na política as seguintes ações necessárias para permitir a transferência de arquivos da instância de banco de dados PostgreSQL para um bucket do Amazon S3:
+ `s3:PutObject`
+ `s3:AbortMultipartUpload`
1. Inclua o nome do recurso da Amazon (ARN) que identifica o bucket do Amazon S3 e os objetos no bucket. O formato do ARN para acessar o Amazon S3 é: `arn:aws:s3:::amzn-s3-demo-bucket/*`
Para obter mais informações sobre como criar uma política do IAM para o Amazon RDS para PostgreSQL, consulte [Criar e usar uma política do IAM para acesso do banco de dados do IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md). Consulte também [Tutorial: criar e anexar sua primeira política gerenciada pelo cliente](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_managed-policies.html) no *Manual do usuário do IAM*.
O comando da AWS CLI a seguir cria uma política do IAM denominada `rds-s3-export-policy` com essas opções. Ele concede acesso a um bucket denominado *amzn-s3-demo-bucket*.
**Atenção**
Recomendamos configurar o banco de dados em uma VPC privada que tenha políticas de endpoint configuradas para acessar buckets específicos. Para obter mais informações, consulte [Usar políticas de endpoint para o Amazon S3](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints-s3.html#vpc-endpoints-policies-s3) no Manual do usuário da Amazon VPC.
É altamente recomendável não criar uma política com acesso a todos os recursos. Esse acesso pode representar uma ameaça à segurança dos dados. Se você criar uma política que forneça o acesso `S3:PutObject` a todos os recursos usando `"Resource":"*"`, um usuário com privilégios de exportação poderá exportar dados para todos os buckets em sua conta. Além disso, o usuário poderá exportar dados para *qualquer bucket gravável publicamente dentro de sua região daAWS*.
Depois de criar a política, observe o nome do recurso da Amazon (ARN) da política. O ARN será necessário para uma etapa posterior, quando você anexar a política a um perfil do IAM.
```
aws iam create-policy --policy-name rds-s3-export-policy --policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "s3export",
"Action": [
"s3:PutObject*",
"s3:ListBucket",
"s3:GetObject*",
"s3:DeleteObject*",
"s3:GetBucketLocation",
"s3:AbortMultipartUpload"
],
"Effect": "Allow",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/*"
]
}
]
}'
```
1. Crie uma função do IAM.
Faça isso para que o Amazon RDS do possa assumir esse perfil do IAM em seu nome para acessar os buckets do Amazon S3. Para ter mais informações, consulte [Criar um perfil para delegar permissões a um usuário do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html) no *Guia do usuário do IAM*.
Convém usar as chaves de contexto de condição global `[aws:SourceArn](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn)` e `[aws:SourceAccount](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount)` em políticas baseadas em recursos para limitar as permissões do serviço a um recurso específico. Essa é a maneira mais eficiente de se proteger contra o [problema "confused deputy"](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html).
Se você utilizar ambas as chaves de contexto de condição global, e o valor `aws:SourceArn` contiver o ID da conta, o valor `aws:SourceAccount` e a conta no valor `aws:SourceArn` deverão utilizar o mesmo ID de conta quando utilizados na mesma instrução de política.
+ Use `aws:SourceArn` se quiser acesso entre serviços para um único recurso.
+ Use `aws:SourceAccount` se você quiser permitir que qualquer recurso nessa conta seja associado ao uso entre serviços.
Na política, certifique-se de usar a chave de contexto de condição global `aws:SourceArn` com o ARN completo do recurso. O exemplo a seguir mostra como fazer isso utilizando o comando da AWS CLI para criar uma função chamada `rds-s3-export-role`.
**Example**
Para Linux, macOS ou Unix:
```
aws iam create-role \
--role-name rds-s3-export-role \
--assume-role-policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "111122223333",
"aws:SourceArn": "arn:aws:rds:us-east-1:111122223333:db:dbname"
}
}
}
]
}'
```
Para Windows:
```
aws iam create-role ^
--role-name rds-s3-export-role ^
--assume-role-policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "111122223333",
"aws:SourceArn": "arn:aws:rds:us-east-1:111122223333:db:dbname"
}
}
}
]
}'
```
1. Anexe a política do IAM que você criou à função do IAM que você criou.
O comando da AWS CLI a seguir anexa a política criada anteriormente à função chamada `rds-s3-export-role.`. Substitua `your-policy-arn` pelo ARN da política que você anotou na etapa anterior.
```
aws iam attach-role-policy --policy-arn your-policy-arn --role-name rds-s3-export-role
```
1. Adicione o perfil do IAM à instância de banco de dados. Faça isso usando o Console de gerenciamento da AWS ou a AWS CLI, conforme descrito a seguir.
## Console
**Para adicionar um perfil do IAM a uma instância de banco de dados do PostgreSQL usando o console**
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. Escolha o nome da instância de de banco de dados do PostgreSQL para exibir os detalhes.
1. Na guia **Connectivity & security (Conectividade e segurança)**, na seção **Manage IAM roles (Gerenciar perfis do IAM)**, escolha o perfil a ser adicionado em **Add IAM roles to this instance** (Adicionar perfis do IAM a essa instância).
1. Em **Feature (Recurso)**, escolha **s3Export**.
1. Escolha **Add role (adicionar função)**.
## AWS CLI
**Para adicionar um perfil do IAM para uma instância de banco de dados do PostgreSQL usando a CLI**
+ Use o comando a seguir para adicionar a função à instância de banco de dados do PostgreSQL chamada `my-db-instance`. Substitua*`your-role-arn`* pelo ARN da função que você anotou em uma etapa anterior. Use `s3Export` para o valor da opção `--feature-name`.
**Example**
Para Linux, macOS ou Unix:
```
aws rds add-role-to-db-instance \
--db-instance-identifier my-db-instance \
--feature-name s3Export \
--role-arn your-role-arn \
--region your-region
```
Para Windows:
```
aws rds add-role-to-db-instance ^
--db-instance-identifier my-db-instance ^
--feature-name s3Export ^
--role-arn your-role-arn ^
--region your-region
```
# Exportar dados de consulta usando a função aws\$1s3.query\$1export\$1to\$1s3
Exporte os dados do PostgreSQL para o Amazon S3 chamando a função [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3).
**Topics**
+ [Pré-requisitos](#postgresql-s3-export-examples-prerequisites)
+ [Chamar aws\$1s3.query\$1export\$1to\$1s3](#postgresql-s3-export-examples-basic)
+ [Exportar para um arquivo CSV que usa um delimitador personalizado](#postgresql-s3-export-examples-custom-delimiter)
+ [Exportar para um arquivo binário com codificação](#postgresql-s3-export-examples-encoded)
## Pré-requisitos
Antes de usar a função `aws_s3.query_export_to_s3`, verifique se você concluiu os seguintes pré-requisitos:
+ Instalar as extensões do PostgreSQL necessárias, conforme descrito em [Visão geral da exportação de dados para o Amazon S3](postgresql-s3-export.md#postgresql-s3-export-overview).
+ Determinar para onde exportar os dados para o Amazon S3, conforme descrito em [Especificar o caminho do arquivo do Amazon S3 para o qual exportar](postgresql-s3-export.md#postgresql-s3-export-file).
+ Verifique se a instância de banco de dados tem acesso ao Amazon S3 conforme descrito em [Configurar o acesso a um bucket do Amazon S3](postgresql-s3-export-access-bucket.md).
Os exemplos a seguir usam uma tabela de banco de dados chamada `sample_table`. Esses exemplos exportam os dados para um bucket chamado *amzn-s3-demo-bucket*. A tabela e os dados de exemplo são criados com as seguintes instruções SQL no psql.
```
psql=> CREATE TABLE sample_table (bid bigint PRIMARY KEY, name varchar(80));
psql=> INSERT INTO sample_table (bid,name) VALUES (1, 'Monday'), (2,'Tuesday'), (3, 'Wednesday');
```
## Chamar aws\$1s3.query\$1export\$1to\$1s3
Veja a seguir as formas básicas de chamar a função [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3).
Esses exemplos usam a variável `s3_uri_1` para identificar uma estrutura que contém as informações que identificam o arquivo do Amazon S3. Use a função [aws\$1commons.create\$1s3\$1uri](postgresql-s3-export-functions.md#aws_commons.create_s3_uri) para criar a estrutura.
```
psql=> SELECT aws_commons.create_s3_uri(
'amzn-s3-demo-bucket',
'sample-filepath',
'us-west-2'
) AS s3_uri_1 \gset
```
Embora os parâmetros variem para as duas chamadas de função `aws_s3.query_export_to_s3` a seguir, os resultados são os mesmos para esses exemplos. Todas as linhas da tabela `sample_table` são exportadas para um bucket chamado *amzn-s3-demo-bucket*.
```
psql=> SELECT * FROM aws_s3.query_export_to_s3('SELECT * FROM sample_table', :'s3_uri_1');
psql=> SELECT * FROM aws_s3.query_export_to_s3('SELECT * FROM sample_table', :'s3_uri_1', options :='format text');
```
Os parâmetros são descritos da seguinte forma:
+ `'SELECT * FROM sample_table'` – o primeiro parâmetro é uma string de texto necessária que contém uma consulta SQL. O mecanismo PostgreSQL executa essa consulta. Os resultados da consulta são copiados no bucket do S3 identificado em outros parâmetros.
+ `:'s3_uri_1'` – esse parâmetro é uma estrutura que identifica o arquivo do Amazon S3. Esse exemplo usa uma variável para identificar a estrutura criada anteriormente. Em vez disso, você pode criar a estrutura incluindo a chamada de função `aws_commons.create_s3_uri` em linha dentro da chamada de função `aws_s3.query_export_to_s3` da seguinte forma.
```
SELECT * from aws_s3.query_export_to_s3('select * from sample_table',
aws_commons.create_s3_uri('amzn-s3-demo-bucket', 'sample-filepath', 'us-west-2')
);
```
+ `options :='format text'` – o parâmetro `options` é uma string de texto opcional que contém argumentos `COPY` do PostgreSQL. O processo de cópia usa os argumentos e o formato do comando [COPY PostgreSQL](https://www.postgresql.org/docs/current/sql-copy.html).
Se o arquivo especificado não existir no bucket do Amazon S3, ele será criado. Se o arquivo já existir, ele será substituído. A sintaxe para acessar os dados exportados no Amazon S3 é a seguinte.
```
s3-region://bucket-name[/path-prefix]/file-prefix
```
Exportações maiores são armazenadas em vários arquivos, cada um com um tamanho máximo de aproximadamente 6 GB. Os nomes de arquivos adicionais têm o mesmo prefixo de arquivo, mas com o acréscimo de `_partXX`. O `XX` representa 2, depois 3 e assim por diante. Por exemplo, suponha que você especifique o caminho onde armazena arquivos de dados como o seguinte.
```
s3-us-west-2://amzn-s3-demo-bucket/my-prefix
```
Se a exportação precisar criar três arquivos de dados, o bucket do Amazon S3 conterá os seguintes arquivos de dados.
```
s3-us-west-2://amzn-s3-demo-bucket/my-prefix
s3-us-west-2://amzn-s3-demo-bucket/my-prefix_part2
s3-us-west-2://amzn-s3-demo-bucket/my-prefix_part3
```
Para obter a referência completa para esta função e as formas adicionais de chamá-la, consulte [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3). Para obter mais informações sobre como acessar arquivos no Amazon S3, consulte [Visualização de um objeto](https://docs.aws.amazon.com/AmazonS3/latest/userguide/OpeningAnObject.html) no *Guia do usuário do Amazon Simple Storage Service*.
## Exportar para um arquivo CSV que usa um delimitador personalizado
O exemplo a seguir mostra como chamar a função [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3) para exportar dados para um arquivo que usa um delimitador personalizado. O exemplo usa argumentos do comando [COPY do PostgreSQL](https://www.postgresql.org/docs/current/sql-copy.html) para especificar o formato de valor separado por vírgula (CSV) e um delimitador de dois pontos (:).
```
SELECT * from aws_s3.query_export_to_s3('select * from basic_test', :'s3_uri_1', options :='format csv, delimiter $$:$$');
```
## Exportar para um arquivo binário com codificação
O exemplo a seguir mostra como chamar a função [aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-functions.md#aws_s3.export_query_to_s3) para exportar dados para um arquivo binário que tenha a codificação Windows-1253.
```
SELECT * from aws_s3.query_export_to_s3('select * from basic_test', :'s3_uri_1', options :='format binary, encoding WIN1253');
```
# Referência de funções
**Topics**
+ [aws\$1s3.query\$1export\$1to\$1s3](#aws_s3.export_query_to_s3)
+ [aws\$1commons.create\$1s3\$1uri](#aws_commons.create_s3_uri)
## aws\$1s3.query\$1export\$1to\$1s3
Exporta um resultado de consulta do PostgreSQL para um bucket do Amazon S3. A extensão `aws_s3` fornece a função `aws_s3.query_export_to_s3`.
Os dois parâmetros necessários são `query` e `s3_info`. Eles definem a consulta a ser exportada e identificam o bucket do Amazon S3 para o qual exportar. Um parâmetro opcional chamado `options` fornece a definição de vários parâmetros de exportação. Para obter exemplos de como usar a função `aws_s3.query_export_to_s3`, consulte [Exportar dados de consulta usando a função aws\$1s3.query\$1export\$1to\$1s3](postgresql-s3-export-examples.md).
**Sintaxe**
```
aws_s3.query_export_to_s3(
query text,
s3_info aws_commons._s3_uri_1,
options text,
kms_key text
)
```Parâmetros de entrada
*query*
Uma string de texto necessária que contém uma consulta SQL executada pelo mecanismo do PostgreSQL. Os resultados dessa consulta são copiados em um bucket do S3 identificado no parâmetro `s3_info`.
*s3\$1info*
Um tipo composto `aws_commons._s3_uri_1` contendo as seguintes informações sobre o objeto do S3:
+ `bucket` – o nome do bucket do Amazon S3 que deve conter o arquivo.
+ `file_path` – o nome e o caminho do arquivo do Amazon S3.
+ `region`: a região da AWS na qual o bucket se encontra. Para obter uma listagem de nomes de regiões da AWS e os valores associados, consulte [Regiões, zonas de disponibilidade e Local Zones](Concepts.RegionsAndAvailabilityZones.md).
Atualmente, esse valor deve ser a mesma região da AWS que a instância de Bancos de Dados de exportação . O padrão é a região da AWS para exportação da instância de Bancos de Dados .
Para criar uma estrutura `aws_commons._s3_uri_1` composta, consulte a função [aws\$1commons.create\$1s3\$1uri](#aws_commons.create_s3_uri).
*options*
Uma string de texto opcional que contém argumentos para o comando `COPY` do PostgreSQL. Esses argumentos especificam como os dados devem ser copiados quando exportados. Para obter mais detalhes, consulte [Documentação de COPY do PostgreSQL](https://www.postgresql.org/docs/current/sql-copy.html).
*kms\$1key text*
Uma string de texto opcional contendo a chave do KMS gerenciada pelo cliente do bucket do S3 para o qual exportar os dados.
### Parâmetros de entrada alternativos
Para ajudar nos testes, você pode usar um conjunto expandido de parâmetros em vez do parâmetro `s3_info`. Veja a seguir as variações adicionais de sintaxe da função `aws_s3.query_export_to_s3`.
Em vez de usar o parâmetro `s3_info` para identificar um arquivo do Amazon S3, use a combinação dos parâmetros `bucket`, `file_path` e `region`.
```
aws_s3.query_export_to_s3(
query text,
bucket text,
file_path text,
region text,
options text,
kms_key text
)
```
*query*
Uma string de texto necessária que contém uma consulta SQL executada pelo mecanismo do PostgreSQL. Os resultados dessa consulta são copiados em um bucket do S3 identificado no parâmetro `s3_info`.
*bucket*
Uma string de texto necessária que contém o nome do bucket do Amazon S3 que contém o arquivo.
*file\$1path*
Uma string de texto necessária contendo o nome do arquivo do Amazon S3, incluindo o caminho do arquivo.
*region*
Uma string de texto opcional que contém a região da AWS na qual o bucket se contra. Para obter uma listagem de nomes de regiões da AWS e os valores associados, consulte [Regiões, zonas de disponibilidade e Local Zones](Concepts.RegionsAndAvailabilityZones.md).
Atualmente, esse valor deve ser a mesma região da AWS que a instância de Bancos de Dados de exportação . O padrão é a região da AWS para exportação da instância de Bancos de Dados .
*options*
Uma string de texto opcional que contém argumentos para o comando `COPY` do PostgreSQL. Esses argumentos especificam como os dados devem ser copiados quando exportados. Para obter mais detalhes, consulte [Documentação de COPY do PostgreSQL](https://www.postgresql.org/docs/current/sql-copy.html).
*kms\$1key text*
Uma string de texto opcional contendo a chave do KMS gerenciada pelo cliente do bucket do S3 para o qual exportar os dados.
### Parâmetros de saída
```
aws_s3.query_export_to_s3(
OUT rows_uploaded bigint,
OUT files_uploaded bigint,
OUT bytes_uploaded bigint
)
```
*rows\$1uploaded*
O número de linhas da tabela que foram carregadas com êxito no Amazon S3 para a determinada consulta.
*files\$1uploaded*
O número de arquivos carregados no Amazon S3. Os arquivos são criados em tamanhos de aproximadamente 6 GB. Cada arquivo adicional criado tem `_partXX` acrescentado ao nome. O `XX` representa 2, depois 3 e assim por diante, conforme necessário.
*bytes\$1uploaded*
O número total de bytes carregados no Amazon S3.
### Exemplos
```
psql=> SELECT * from aws_s3.query_export_to_s3('select * from sample_table', 'amzn-s3-demo-bucket', 'sample-filepath');
psql=> SELECT * from aws_s3.query_export_to_s3('select * from sample_table', 'amzn-s3-demo-bucket', 'sample-filepath','us-west-2');
psql=> SELECT * from aws_s3.query_export_to_s3('select * from sample_table', 'amzn-s3-demo-bucket', 'sample-filepath','us-west-2','format text');
```
## aws\$1commons.create\$1s3\$1uri
Cria uma estrutura `aws_commons._s3_uri_1` para comportar informações do arquivo do Amazon S3. Use os resultados da função `aws_commons.create_s3_uri` no parâmetro `s3_info` da função [aws\$1s3.query\$1export\$1to\$1s3](#aws_s3.export_query_to_s3). Para obter um exemplo de uso da função `aws_commons.create_s3_uri`, consulte [Especificar o caminho do arquivo do Amazon S3 para o qual exportar](postgresql-s3-export.md#postgresql-s3-export-file).
**Sintaxe**
```
aws_commons.create_s3_uri(
bucket text,
file_path text,
region text
)
```Parâmetros de entrada
*Bucket de*
Uma string de texto necessária contendo o nome do bucket do Amazon S3 para o arquivo.
*file\$1path*
Uma string de texto necessária contendo o nome do arquivo do Amazon S3, incluindo o caminho do arquivo.
*region*
Uma string de texto necessária que contém a região da AWS na qual o arquivo se encontra. Para obter uma listagem de nomes de regiões da AWS e os valores associados, consulte [Regiões, zonas de disponibilidade e Local Zones](Concepts.RegionsAndAvailabilityZones.md).
# Solução de problemas de acesso ao Amazon S3
Se você encontrar problemas de conexão ao tentar exportar dados para o Amazon S3, primeiro confirme se as regras de acesso de saída para o grupo de segurança da VPC associado à sua instância de banco de dados permitem conectividade de rede. Especificamente, o grupo de segurança deve ter uma regra que permita que a instância de banco de dados envie tráfego TCP para a porta 443 e para todos os endereços IPv4 (0.0.0.0/0). Para obter mais informações, consulte [Fornecer acesso à instância de banco de dados na VPC criando um grupo de segurança](CHAP_SettingUp.md#CHAP_SettingUp.SecurityGroup).
Veja também as seguintes recomendações:
+ [Solução de problemas de identidade e acesso do Amazon RDS](security_iam_troubleshoot.md)
+ [Solução de problemas do Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/troubleshooting.html) no *Guia do usuário do Amazon Simple Storage Service*
+ [Troubleshooting Amazon S3 and IAM (Solucionar problemas no Amazon S3 e no IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/troubleshoot_iam-s3.html) no *Guia do usuário do IAM*