# Como importar dados no PostgreSQL do Amazon RDS Vamos supor que você tenha uma implantação do PostgreSQL que deseja mover para o Amazon RDS. A complexidade da tarefa dependerá do tamanho do banco de dados e dos tipos de objetos de banco de dados a serem transferidos. Por exemplo, considere um banco de dados que contenha conjuntos de dados na ordem de gigabytes, juntamente com gatilhos e procedimentos armazenados. Esse banco de dados será mais complexo do que um banco de dados simples com apenas alguns megabytes de dados de teste e sem gatilhos e procedimentos armazenados. Recomendamos que você use ferramentas nativas de migração do banco de dados PostgreSQL nas seguintes condições: + Quando há uma migração homogênea, em que você está migrando de um banco de dados com o mesmo mecanismo de banco de dados que o de destino. + Quando for migrar um banco de dados inteiro. + As ferramentas nativas permitirem que você migre o sistema com um tempo mínimo de inatividade. Na maioria dos outros casos, executar uma migração de banco de dados usando o AWS Database Migration Service (AWS DMS) é a melhor abordagem. AWS O DMS pode migrar bancos de dados sem o tempo de inatividade e, para muitos mecanismos de banco de dados, continua a replicação contínua até que você esteja pronto para mudar para o banco de dados de destino. Você pode migrar para o mesmo mecanismo de banco de dados ou um mecanismo de banco de dados diferente usando o AWS DMS. Se você estiver migrando para um mecanismo de banco de dados diferente do seu banco de dados de origem, poderá usar a AWS Schema Conversion Tool (AWS SCT). Use o AWS SCT para migrar os objetos de esquema que não são migrados pelo AWS DMS. Para obter mais informações sobre como usar o AWS DMS, consulte [ O que é o AWS Database Migration Service?](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html). Modifique o grupo de parâmetros do banco de dados para incluir as seguintes configurações *somente na sua importação*. Você deve testar as configurações dos parâmetros para encontrar as que forem mais eficientes para o tamanho da instância do banco de dados. Você também precisará reverter esses parâmetros aos seus valores de produção após a conclusão da importação. Modifique as configurações da instância de banco de dados da seguinte forma: + Desabilite os backups de instâncias de banco de dados (defina backup\$1retention como 0). + Desabilite o multi-AZ. Modifique o grupo de parâmetros de banco de dados para incluir as seguintes configurações. Você só deve usar essas configurações para importar dados. Você deve testar as configurações dos parâmetros para encontrar as que forem mais eficientes para o tamanho da instância do banco de dados. Você também precisará reverter esses parâmetros aos seus valores de produção após a conclusão da importação. | Parâmetro | Valor recomendado para importação | Descrição | | --- | --- | --- | | `maintenance_work_mem` | 524288, 1048576, 2097152 ou 4194304 (em KB). Essas configurações são comparáveis a 512 MB, 1 GB, 2 GB e 4 GB. | O valor desta configuração depende do tamanho do host. Este parâmetro é usado durante instruções CREATE INDEX e cada comando paralelo pode usar essa quantidade de memória. Calcule o valor mais apropriado para não ajustá-lo tão alto resultando na falta de memória. | | `max_wal_size` | 256 (para a versão 9.6), 4096 (para as versões 10 e posteriores) | Tamanho máximo para deixar o WAL aumentar durante os pontos de verificação automáticos. Aumentar esse parâmetro pode aumentar a quantidade de tempo necessária para a recuperação de falhas. Esse parâmetro substitui `checkpoint_segments` para o PostgreSQL 9.6 e posteriores. Para o PostgreSQL versão 9.6, esse valor está em unidades de 16 MB. Para versões posteriores, o valor está em unidades de 1 MB. Por exemplo, na versão 9.6, 128 significa 128 blocos, cada um com tamanho de 16 MB. Na versão 12.4, 2048 significa 2048 blocos, cada um com tamanho de 1 MB. | | `checkpoint_timeout` | 1800 | O valor desta configuração permite um revezamento menos frequente de WAL. | | `synchronous_commit` | Desativado | Desabilite essa configuração para acelerar a gravação. Desativar esse parâmetro pode aumentar o risco de perda de dados em caso de uma falha no servidor (não desative o FSYNC) | | `wal_buffers` | 8192 | Este valor está em unidades de 8 KB. Reforçando, isso ajuda na velocidade de geração WAL | | `autovacuum` | 0 | Desative o parâmetro de autovacuum do PostgreSQL enquanto estiver carregando dados para que ele não use os recursos | Use os comandos `pg_dump -Fc` (compactado) ou `pg_restore -j` (paralelo) com essas configurações. **nota** O comando do PostgreSQL `pg_dumpall` requer permissões de super\$1user que não são concedidas ao criar uma instância de banco de dados, por isso ele não pode ser usado para importação de dados. **Topics** + [Importar um banco de dados PostgreSQL de uma instância do Amazon EC2](PostgreSQL.Procedural.Importing.EC2.md) + [Uso do comando \$1copy para importar dados em uma tabela em uma instância de banco de dados PostgreSQL](PostgreSQL.Procedural.Importing.Copy.md) + [Importar dados do Amazon S3 para uma instância de banco de dados do RDS para PostgreSQL](USER_PostgreSQL.S3Import.md) + [Como transportar bancos de dados PostgreSQL entre instâncias de banco de dados](PostgreSQL.TransportableDB.md) # Importar um banco de dados PostgreSQL de uma instância do Amazon EC2 Se houver dados em um servidor do PostgreSQL em uma instância do Amazon EC2 e você quiser movê-los para uma instância de banco de dados do PostgreSQL, você poderá seguir este processo para migrar os dados. 1. Crie um arquivo usando o pg\$1dump que contenha os dados a serem carregados 1. Crie a instância de banco de dados de destino 1. Use o *psql* para criar o banco de dados na instância de banco de dados e carregá-los 1. Crie um snapshot de banco de dados da instância de banco de dados As seções a seguir apresentam mais detalhes sobre cada etapa listada acima. ## Etapa 1: Criar um arquivo usando o pg\$1dump que contenha os dados a serem carregados O utilitário `pg_dump` usa o comando COPY para criar um esquema e uma despejo de dados de um banco de dados PostgreSQL. O script de despejo gerado pelo `pg_dump` carrega os dados em um banco de dados com o mesmo nome e recreia as tabelas, os índices e as chaves externas. Você pode usar o comando `pg_restore` e o parâmetro `-d` para recuperar os dados em um banco de dados com um nome diferente. Antes de criar o despejo de dados, você deve consultar as tabelas a serem despejadas para obter uma contagem de linhas, assim você pode confirmar a contagem na instância de banco de dados de destino. O comando a seguir cria um arquivo de despejo denominado mydb2dump.sql para um banco de dados denominado mydb2. ``` prompt>pg_dump dbname=mydb2 -f mydb2dump.sql ``` ## Etapa 2: crie a instância de banco de dados de destino Crie a instância de banco de dados PostgreSQL de destino usando o console, a AWS CLI ou a API do Amazon RDS. Crie a instância com a configuração de retenção de backup definida como 0 e desative o multi-AZ. Isso permite uma importação de dados mais rápida. Você deve criar um banco de dados na instância antes de poder despejar os dados. O banco de dados pode ter o mesmo nome que o banco de dados que contém os dados de despejo. Se preferir, você pode criar um banco de dados com um nome diferente. Nesse caso, use o comando `pg_restore` e o parâmetro `-d` para restaurar os dados para o banco de dados recém-nomeado. Por exemplo, os seguintes comandos podem ser usados para despejar, restaurar e renomear um banco de dados. ``` pg_dump -Fc -v -h [endpoint of instance] -U [master username] [database] > [database].dump createdb [new database name] pg_restore -v -h [endpoint of instance] -U [master username] -d [new database name] [database].dump ``` ## Etapa 3: Usar o psql para criar o banco de dados na instância de banco de dados e carregá-los É possível usar a mesma conexão que você usou para executar o comando pg\$1dump para se conectar à instância de banco de dados de destino e recriar o banco de dados. Com o *psql*, use o nome de usuário mestre e a senha mestre para criar o banco de dados na instância de banco de dados O exemplo a seguir usa o *psql* e um arquivo de despejo denominado mydb2dump.sql para criar um banco de dados denominado mydb2 em uma instância de banco de dados PostgreSQL chamada mypginstance: Para Linux, macOS ou Unix: ``` psql \ -f mydb2dump.sql \ --host mypginstance.555555555555.aws-region.rds.amazonaws.com \ --port 8199 \ --username myawsuser \ --password password \ --dbname mydb2 ``` Para Windows: ``` psql ^ -f mydb2dump.sql ^ --host mypginstance.555555555555.aws-region.rds.amazonaws.com ^ --port 8199 ^ --username myawsuser ^ --password password ^ --dbname mydb2 ``` **nota** Especifique uma senha diferente do prompt mostrado aqui como prática recomendada de segurança. ## Etapa 4: crie um DB snapshot da instância de banco de dados Após confirmar que os dados foram carregados na instância de banco de dados, recomendamos que você crie um snapshot de banco de dados da instância de banco de dados PostgreSQL de destino. Os snapshot de banco de dadoss são backups completos de sua instância de banco de dados que podem ser usados para restaurá-la em um estado conhecido. Um snapshot de banco de dados feito imediatamente após a carga evita que você tenha que carregar os dados novamente caso ocorra um problema. Você também pode usar esse snapshot para propagar as novas instâncias de banco de dados. Para obter informações sobre como criar um snapshot de banco de dados, consulte [Criar um snapshot de banco de dados para uma instância de banco de dados single-AZ para o Amazon RDS](USER_CreateSnapshot.md). # Uso do comando \$1copy para importar dados em uma tabela em uma instância de banco de dados PostgreSQL O comando `\copy` do PostgreSQL é um meta-comando disponível a partir da ferramenta cliente interativa `psql`. Você pode usar `\copy` para importar dados para uma tabela na instância de banco de dados do RDS para PostgreSQL Para usar o comando `\copy`, você precisa primeiro criar a estrutura da tabela na instância de banco de dados de destino para que `\copy` tenha um destino para os dados que estão sendo copiados. Você pode usar `\copy` para carregar dados de um arquivo de valores separados por vírgulas (CSV), como um que foi exportado e salvo na estação de trabalho do cliente. Para importar os dados CSV para a instância de banco de dados do RDS para PostgreSQL de destino, primeiro conecte-se à instância de banco de dados de destino usando `psql`. ``` psql --host=db-instance.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password --dbname=target-db ``` Você então executa `\copy` com os parâmetros a seguir para identificar o destino para os dados e seu formato. + `target_table` – O nome da tabela que deve receber os dados que estão sendo copiados do arquivo CSV. + `column_list` – Especificações da coluna para a tabela. + `'filename'` – O caminho completo para o arquivo CSV na estação de trabalho local. ``` \copy target_table from '/path/to/local/filename.csv' WITH DELIMITER ',' CSV; ``` Se o arquivo CSV tiver informações de cabeçalho de coluna, você poderá usar esta versão do comando e dos parâmetros. ``` \copy target_table (column-1, column-2, column-3, ...) from '/path/to/local/filename.csv' WITH DELIMITER ',' CSV HEADER; ``` Se o comando `\copy` falhar, o PostgreSQL gera mensagens de erro. Criar uma instância de banco de dados no comando `psql` do Ambiente de Pré-visualização do Banco de Dados com o metacomando `\copy`, conforme mostrado nos exemplos a seguir. Este exemplo usa *source-table* como o nome da tabela de origem, *source-table.csv* como o arquivo .csv e *target-db* como o banco de dados de destino: Para Linux, macOS ou Unix: ``` $psql target-db \ -U \ -p \ -h \ -c "\copy source-table from 'source-table.csv' with DELIMITER ','" ``` Para Windows: ``` $psql target-db ^ -U ^ -p ^ -h ^ -c "\copy source-table from 'source-table.csv' with DELIMITER ','" ``` Para obter detalhes completos sobre o comando `\copy`, consulte a página [psql](http://www.postgresql.org/docs/current/static/app-psql.html) na documentação do PostgreSQL, na seção *Meta-comandos*. # Importar dados do Amazon S3 para uma instância de banco de dados do RDS para PostgreSQL Você pode importar dados que foram armazenados usando o Amazon Simple Storage Service em uma tabela em uma instância de banco de dados do RDS para PostgreSQL. Para fazer isso, primeiro instale a extensão `aws_s3` do RDS para PostgreSQL. Essa extensão fornece as funções usadas para importar dados de um bucket do Amazon S3. Um *bucket* é um contêiner do Amazon S3 para objetos e arquivos. Os dados podem estar em um arquivo de valores separados por vírgula (CSV), em um arquivo de texto ou em um arquivo compactado (gzip). Veja a seguir como instalar a extensão e importar dados do Amazon S3 para uma tabela. Seu banco de dados deve estar executando o PostgreSQL versão 10.7 ou superior para importar do Amazon S3 para o RDS for PostgreSQL. Se você não tiver dados armazenados no Amazon S3, crie um bucket e armazene os dados. Para ter mais informações, consulte os tópicos a seguir no *Guia do usuário do Amazon Simple Storage Service*. + [Criar um bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html#creating-bucket) + [Adicionar um objeto a um bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html#uploading-an-object-bucket) A importação entre contas do Amazon S3 é compatível. Para ter mais informações, consulte [Conceder permissões entre contas](https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-walkthroughs-managing-access-example2.html) no *Guia do usuário do Amazon Simple Storage Service*. Você pode usar a chave gerenciada pelo cliente para criptografia ao importar dados do S3. Para ter mais informações, consulte [Chaves do KMS armazenadas no AWS KMS](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html) no *Guia do usuário do Amazon Simple Storage Service*. **Topics** + [Instalar a extensão aws\$1s3](USER_PostgreSQL.S3Import.InstallExtension.md) + [Visão geral da importação de dados do Amazon S3](USER_PostgreSQL.S3Import.Overview.md) + [Configurar o acesso a um bucket do Amazon S3](USER_PostgreSQL.S3Import.AccessPermission.md) + [Importar dados do Amazon S3 para uma instância de banco de dados do RDS para PostgreSQL](USER_PostgreSQL.S3Import.FileFormats.md) + [Referência de funções](USER_PostgreSQL.S3Import.Reference.md) # Instalar a extensão aws\$1s3 Antes de usar o Amazon S3 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 as funções para importar dados do Amazon S3. Ela também fornece funções para exportar dados de uma instância de banco de dados do RDS para PostgreSQL para um bucket do Amazon S3. Para ter mais informações, consulte [Exportar dados de uma instância de banco de dados do RDS para PostgreSQL para o Amazon S3](postgresql-s3-export.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. # Visão geral da importação de dados do Amazon S3 **Para importar dados do S3 para o Amazon RDS do** Primeiro, reúna os detalhes que você precisa fornecer à função. Isso inclui o nome da tabela na sua instância de banco de dados do RDS para PostgreSQL, e o nome do bucket, o caminho do arquivo, o tipo de arquivo e a Região da AWS em que os dados do Amazon S3 estão armazenados. Para ter mais informações, consulte [Visualizar um objeto](https://docs.aws.amazon.com/AmazonS3/latest/userguide/OpeningAnObject.html) no *Guia do usuário do Amazon Simple Storage Service*. **nota** A importação de dados multipart do Amazon S3 não é compatível atualmente. 1. Obtenha o nome da tabela para a qual a função `aws_s3.table_import_from_s3` deverá importar os dados. Por exemplo, o comando a seguir cria uma tabela `t1` que pode ser utilizada em etapas posteriores. ``` postgres=> CREATE TABLE t1 (col1 varchar(80), col2 varchar(80), col3 varchar(80)); ``` 1. Veja os detalhes sobre o bucket do Amazon S3 e os dados a importar. Para fazer isso, abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) e escolha **Buckets**. Encontre o bucket que contém seus dados na lista. Escolha o bucket, abra a página Object overview (Visão geral do objeto) e escolha Properties (Propriedades). Anote o nome do bucket, o caminho, a Região da AWS e o tipo de arquivo. Posteriormente, você precisará do nome do recurso da Amazon (ARN) para configurar o acesso ao Amazon S3 por meio de um perfil do IAM. Para ter mais informações, consulte [Configurar o acesso a um bucket do Amazon S3](USER_PostgreSQL.S3Import.AccessPermission.md). A imagem a seguir mostra um exemplo. ![\[Imagem de um objeto de arquivo em um bucket do Amazon S3.\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/aws_s3_import-export_s3_bucket-info.png) 1. Você pode verificar o caminho dos dados no bucket do Amazon S3 usando o comando `aws s3 cp` da AWS CLI. Se as informações estiverem corretas, esse comando baixará uma cópia do arquivo do Amazon S3. ``` aws s3 cp s3://amzn-s3-demo-bucket/sample_file_path ./ ``` 1. Configure permissões em sua instância de banco de dados do RDS para PostgreSQLpara permitir acesso ao arquivo no bucket do Amazon S3. Para fazer isso, use um perfil AWS Identity and Access Management (do IAM) ou credenciais de segurança. Para ter mais informações, consulte [Configurar o acesso a um bucket do Amazon S3](USER_PostgreSQL.S3Import.AccessPermission.md). 1. Forneça o caminho e outros detalhes do objeto do Amazon S3 coletados (consulte a etapa 2) para a função `create_s3_uri` a fim de construir um objeto URI do Amazon S3. Para saber mais sobre essa função, consulte [aws\$1commons.create\$1s3\$1uri](USER_PostgreSQL.S3Import.Reference.md#USER_PostgreSQL.S3Import.create_s3_uri). Veja a seguir um exemplo de como construir esse objeto durante uma sessão psql. ``` postgres=> SELECT aws_commons.create_s3_uri( 'docs-lab-store-for-rpg', 'versions_and_jdks_listing.csv', 'us-west-1' ) AS s3_uri \gset ``` Na próxima etapa, passe esse objeto (`aws_commons._s3_uri_1`) para a função `aws_s3.table_import_from_s3` a fim de importar os dados para a tabela. 1. Invoque a função `aws_s3.table_import_from_s3` para importar os dados do Amazon S3 para a sua tabela. Para obter informações de referência, consulte [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3). Para obter exemplos, consulte [Importar dados do Amazon S3 para uma instância de banco de dados do RDS para PostgreSQL](USER_PostgreSQL.S3Import.FileFormats.md). # Configurar o acesso a um bucket do Amazon S3 Para importar dados de um arquivo do Amazon S3, conceda à instância de banco de dados do RDS for PostgreSQL permissão para acessar o bucket do Amazon S3 no qual o arquivo se encontra. Conceda acesso a um bucket do Amazon S3 de uma das duas maneiras, conforme descrito nos tópicos a seguir. **Topics** + [Usar uma função do IAM para acessar um bucket do Amazon S3](#USER_PostgreSQL.S3Import.ARNRole) + [Usar credenciais de segurança para acessar um bucket do Amazon S3](#USER_PostgreSQL.S3Import.Credentials) + [Solução de problemas de acesso ao Amazon S3](#USER_PostgreSQL.S3Import.troubleshooting) ## Usar uma função do IAM para acessar um bucket do Amazon S3 Antes de carregar dados de um arquivo do Amazon S3, conceda à instância de banco de dados do RDS para PostgreSQL permissão para acessar o bucket do Amazon S3 no qual o arquivo está. Dessa forma, não é necessário gerenciar informações adicionais de credenciais ou fornecê-las na chamada da função [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3). Para fazer isso, crie uma política do IAM que conceda acesso ao bucket do Amazon S3. Crie uma função do IAM e associe a política a ela. Depois, atribua uma função do IAM à instância de banco de dados. **Para oferecer ao Amazon S3 acesso a uma instância de banco de dados RDS for PostgreSQL do por meio de uma função 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 do RDS para PostgreSQL acesse o Amazon S3. Inclua na política as seguintes ações necessárias para permitir a transferência de arquivos de um bucket do Amazon S3 para o Amazon RDS do : + `s3:GetObject` + `s3:ListBucket` Inclua na política os recursos a seguir para identificar o bucket e os objetos do Amazon S3 no bucket. Isso mostra o formato do nome de recurso da Amazon (ARN) para acessar o Amazon S3. + arn:aws:s3:::*amzn-s3-demo-bucket* + arn:aws:s3:::*amzn-s3-demo-bucket*/\$1 Para ter mais informações sobre como criar uma política do IAM para o 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 *Guia do usuário do IAM*. O comando da AWS CLI a seguir cria uma política do IAM denominada `rds-s3-import-policy` com essas opções. Ele concede acesso a um bucket denominado *amzn-s3-demo-bucket*. **nota** Anote o nome do recurso da Amazon (ARN) da política que é retornado por esse comando. O ARN será necessário para uma etapa posterior, quando você anexar a política a um perfil do IAM. **Example** Para Linux, macOS ou Unix: ``` aws iam create-policy \ --policy-name rds-s3-import-policy \ --policy-document '{ "Version": "2012-10-17", "Statement": [ { "Sid": "s3import", "Action": [ "s3:GetObject", "s3:ListBucket" ], "Effect": "Allow", "Resource": [ "arn:aws:s3:::amzn-s3-demo-bucket", "arn:aws:s3:::amzn-s3-demo-bucket/*" ] } ] }' ``` Para Windows: ``` aws iam create-policy ^ --policy-name rds-s3-import-policy ^ --policy-document '{ "Version": "2012-10-17", "Statement": [ { "Sid": "s3import", "Action": [ "s3:GetObject", "s3:ListBucket" ], "Effect": "Allow", "Resource": [ "arn:aws:s3:::amzn-s3-demo-bucket", "arn:aws:s3:::amzn-s3-demo-bucket/*" ] } ] }' ``` 1. Criar um perfil do IAM. Faça isso para que o Amazon RDS possa assumir essa função do IAM 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-import-role`. **Example** Para Linux, macOS ou Unix: ``` aws iam create-role \ --role-name rds-s3-import-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-import-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 ao perfil do IAM que você criou. O comando da AWS CLI a seguir vincula a política criada na etapa anterior à função `rds-s3-import-role`. Substitua `your-policy-arn` pelo ARN da política que você anotou naquela ocasião. **Example** Para Linux, macOS ou Unix: ``` aws iam attach-role-policy \ --policy-arn your-policy-arn \ --role-name rds-s3-import-role ``` Para Windows: ``` aws iam attach-role-policy ^ --policy-arn your-policy-arn ^ --role-name rds-s3-import-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 funções do IAM), escolha a função a ser adicionada sob **Add IAM roles to this instance** (Adicionar funções do IAM a este cluster/esta instância). 1. Em **Feature (Recurso)**, escolha **s3Import**. 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 `s3Import` 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 s3Import \ --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 s3Import ^ --role-arn your-role-arn ^ --region your-region ``` ### API do RDS Para adicionar um perfil do IAM a uma instância de banco de dados do PostgreSQL utilizando a API do Amazon RDS, chame a operação [AddRoleToDBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_AddRoleToDBInstance.html). ## Usar credenciais de segurança para acessar um bucket do Amazon S3 Se preferir, você poderá usar credenciais de segurança para conceder acesso a um bucket do Amazon S3 em vez de conceder acesso com uma função do IAM. Faça isso especificando o parâmetro `credentials` na chamada da função [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3). O parâmetro `credentials` é uma estrutura do tipo `aws_commons._aws_credentials_1`, que contém credenciais da AWS. Use a função [aws\$1commons.create\$1aws\$1credentials](USER_PostgreSQL.S3Import.Reference.md#USER_PostgreSQL.S3Import.create_aws_credentials) para definir a chave de acesso e a chave secreta em uma estrutura `aws_commons._aws_credentials_1`, conforme mostrado a seguir. ``` postgres=> SELECT aws_commons.create_aws_credentials( 'sample_access_key', 'sample_secret_key', '') AS creds \gset ``` Depois de criar a estrutura `aws_commons._aws_credentials_1 `, use a função [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3) com o parâmetro `credentials` para importar os dados, conforme mostrado a seguir. ``` postgres=> SELECT aws_s3.table_import_from_s3( 't', '', '(format csv)', :'s3_uri', :'creds' ); ``` Outra opção é incluir a chamada de função [aws\$1commons.create\$1aws\$1credentials](USER_PostgreSQL.S3Import.Reference.md#USER_PostgreSQL.S3Import.create_aws_credentials) em linha dentro da chamada de função `aws_s3.table_import_from_s3`. ``` postgres=> SELECT aws_s3.table_import_from_s3( 't', '', '(format csv)', :'s3_uri', aws_commons.create_aws_credentials('sample_access_key', 'sample_secret_key', '') ); ``` ## Solução de problemas de acesso ao Amazon S3 Se você encontrar problemas de conexão ao tentar importar dados do Amazon S3, consulte o seguinte para obter 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 *Manual do usuário do IAM* # Importar dados do Amazon S3 para uma instância de banco de dados do RDS para PostgreSQL Importe dados do bucket do Amazon S3 usando a função `table_import_from_s3` da extensão aws\$1s3. Para obter informações de referência, consulte [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3). **nota** Os exemplos a seguir usam o método de perfil do IAM para conceder acesso ao bucket do Amazon S3. Assim, as chamadas de função do `aws_s3.table_import_from_s3` não incluem parâmetros de credenciais. Veja a seguir um exemplo típico. ``` postgres=> SELECT aws_s3.table_import_from_s3( 't1', '', '(format csv)', :'s3_uri' ); ``` Os parâmetros são os seguintes: + `t1` – o nome da tabela na instância de banco de dados do PostgreSQL na qual os dados devem ser copiados. + `''` – uma lista opcional de colunas na tabela de banco de dados. É possível usar esse parâmetro para indicar quais colunas dos dados do S3 devem ser inseridos em quais colunas da tabela. Se nenhuma coluna for especificada, todas as colunas serão copiadas para a tabela. Para obter um exemplo de uso de uma lista de colunas, consulte [Importar um arquivo do Amazon S3 que usa um delimitador personalizado](#USER_PostgreSQL.S3Import.FileFormats.CustomDelimiter). + `(format csv)` – 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) para importar os dados. As opções de formato incluem valores separados por vírgula (CSV), conforme mostrado neste exemplo, texto e binário. O padrão é texto. + `s3_uri` – uma estrutura que contém as informações que identificam o arquivo do Amazon S3. Para obter um exemplo de como usar a função [aws\$1commons.create\$1s3\$1uri](USER_PostgreSQL.S3Import.Reference.md#USER_PostgreSQL.S3Import.create_s3_uri) para criar uma estrutura `s3_uri`, consulte [Visão geral da importação de dados do Amazon S3](USER_PostgreSQL.S3Import.Overview.md). Para ter mais informações sobre essa função, consulte [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3). A função `aws_s3.table_import_from_s3` retorna texto. Para especificar outros tipos de arquivos para importação de um bucket do Amazon S3, veja um dos exemplos a seguir. **nota** Importar 0 byte causará um erro. **Topics** + [Importar um arquivo do Amazon S3 que usa um delimitador personalizado](#USER_PostgreSQL.S3Import.FileFormats.CustomDelimiter) + [Importar um arquivo do Amazon S3 compactado (gzip)](#USER_PostgreSQL.S3Import.FileFormats.gzip) + [Importar um arquivo do Amazon S3 codificado](#USER_PostgreSQL.S3Import.FileFormats.Encoded) ## Importar um arquivo do Amazon S3 que usa um delimitador personalizado O exemplo a seguir mostra como importar um arquivo que usa um delimitador personalizado. Ele também mostra como controlar onde colocar os dados na tabela de banco de dados usando o parâmetro `column_list` da função [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3). Para este exemplo, suponha que as informações a seguir estejam organizadas em colunas delimitadas por barras verticais no arquivo do Amazon S3. ``` 1|foo1|bar1|elephant1 2|foo2|bar2|elephant2 3|foo3|bar3|elephant3 4|foo4|bar4|elephant4 ... ``` **Como importar um arquivo que usa um delimitador personalizado** 1. Crie uma tabela no banco de dados para os dados importados. ``` postgres=> CREATE TABLE test (a text, b text, c text, d text, e text); ``` 1. Use o seguinte formato da função [aws\$1s3.table\$1import\$1from\$1s3](USER_PostgreSQL.S3Import.Reference.md#aws_s3.table_import_from_s3) para importar dados do arquivo do Amazon S3. Você pode incluir a chamada de função [aws\$1commons.create\$1s3\$1uri](USER_PostgreSQL.S3Import.Reference.md#USER_PostgreSQL.S3Import.create_s3_uri) em linha dentro da chamada de função `aws_s3.table_import_from_s3` para especificar o arquivo. ``` postgres=> SELECT aws_s3.table_import_from_s3( 'test', 'a,b,d,e', 'DELIMITER ''|''', aws_commons.create_s3_uri('amzn-s3-demo-bucket', 'pipeDelimitedSampleFile', 'us-east-2') ); ``` Os dados estão agora na tabela nas colunas a seguir. ``` postgres=> SELECT * FROM test; a | b | c | d | e ---+------+---+---+------+----------- 1 | foo1 | | bar1 | elephant1 2 | foo2 | | bar2 | elephant2 3 | foo3 | | bar3 | elephant3 4 | foo4 | | bar4 | elephant4 ``` ## Importar um arquivo do Amazon S3 compactado (gzip) O exemplo a seguir mostra como importar um arquivo do Amazon S3 compactado com gzip. O arquivo que você importa precisa ter os seguintes metadados do Simple Storage Service (Amazon S3): + Chave: `Content-Encoding` + Valor:: `gzip` Se você carregar o arquivo usando o Console de gerenciamento da AWS, os metadados geralmente são aplicados pelo sistema. Para obter informações sobre o carregamento de arquivos para o Simple Storage Service (Amazon S3) usando o Console de gerenciamento da AWS, a AWS CLI ou a API, consulte [Carregar objetos](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) no *Guia do usuário do Amazon Simple Storage Service*. Para ter mais informações sobre metadados do Simple Storage Service (Amazon S3) e detalhes sobre metadados fornecidos pelo sistema, consulte [Editar metadados de objeto no console do Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/add-object-metadata.html) no *Guia do usuário do Amazon Simple Storage Service*. Importe o arquivo gzip para a sua instância de banco de dados do RDS for PostgreSQL do , conforme mostrado a seguir. ``` postgres=> CREATE TABLE test_gzip(id int, a text, b text, c text, d text); postgres=> SELECT aws_s3.table_import_from_s3( 'test_gzip', '', '(format csv)', 'amzn-s3-demo-bucket', 'test-data.gz', 'us-east-2' ); ``` ## Importar um arquivo do Amazon S3 codificado O exemplo a seguir mostra como importar um arquivo do Amazon S3 que tenha codificação Windows-1252. ``` postgres=> SELECT aws_s3.table_import_from_s3( 'test_table', '', 'encoding ''WIN1252''', aws_commons.create_s3_uri('amzn-s3-demo-bucket', 'SampleFile', 'us-east-2') ); ``` # Referência de funções **Topics** + [aws\$1s3.table\$1import\$1from\$1s3](#aws_s3.table_import_from_s3) + [aws\$1commons.create\$1s3\$1uri](#USER_PostgreSQL.S3Import.create_s3_uri) + [aws\$1commons.create\$1aws\$1credentials](#USER_PostgreSQL.S3Import.create_aws_credentials) ## aws\$1s3.table\$1import\$1from\$1s3 Importa dados do Amazon S3 para uma tabela doAmazon RDS do . A extensão `aws_s3` fornece a função `aws_s3.table_import_from_s3`. O valor de retorno é texto. ### Sintaxe Os parâmetros necessários são `table_name`, `column_list` e `options`. Eles identificam a tabela do banco de dados e especificam como os dados são copiados nessa tabela. Você também pode usar os seguintes parâmetros: + O parâmetro `s3_info` especifica o arquivo do Amazon S3 a ser importado. Quando você usa esse parâmetro, o acesso ao Amazon S3 é fornecido por uma função do IAM para a instância do de banco de dados do PostgreSQL. ``` aws_s3.table_import_from_s3 ( table_name text, column_list text, options text, s3_info aws_commons._s3_uri_1 ) ``` + O parâmetro `credentials` especifica as credenciais para acessar o Amazon S3. Ao usar esse parâmetro, você não usa uma função do IAM. ``` aws_s3.table_import_from_s3 ( table_name text, column_list text, options text, s3_info aws_commons._s3_uri_1, credentials aws_commons._aws_credentials_1 ) ``` ### Parâmetros *table\$1name* Uma string de texto necessária contendo o nome da tabela de banco de dados PostgreSQL para a qual importar os dados. *column\$1list* Uma string de texto necessária contendo uma lista opcional das colunas da tabela de banco de dados PostgreSQL para a qual copiar os dados. Se a string estiver vazia, todas as colunas da tabela serão usadas. Para ver um exemplo, consulte [Importar um arquivo do Amazon S3 que usa um delimitador personalizado](USER_PostgreSQL.S3Import.FileFormats.md#USER_PostgreSQL.S3Import.FileFormats.CustomDelimiter). *Opções do* Uma string de texto necessária contendo argumentos para o comando PostgreSQL `COPY`. Esses argumentos especificam como os dados devem ser copiados para a tabela do PostgreSQL. Para obter mais detalhes, consulte [Documentação de COPY do PostgreSQL](https://www.postgresql.org/docs/current/sql-copy.html). *s3\$1info* Um tipo composto `aws_commons._s3_uri_1` contendo as seguintes informações sobre o objeto do S3: + `bucket` – O nome do Amazon S3 bucket que contém o arquivo. + `file_path` – o nome do Amazon S3 arquivo, incluindo o caminho do arquivo. + `region`: a região da AWS em que 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). *credenciais* Um tipo composto `aws_commons._aws_credentials_1` contendo as seguintes credenciais a serem usadas para a operação de importação: + Chave de acesso + Chave secreta + Token de sessão Para obter informações sobre como criar uma estrutura `aws_commons._aws_credentials_1` composta, consulte [aws\$1commons.create\$1aws\$1credentials](#USER_PostgreSQL.S3Import.create_aws_credentials). ### Sintaxe alternativa Para ajudar nos testes, você pode usar um conjunto expandido de parâmetros em vez dos parâmetros `s3_info` e `credentials`. Veja a seguir as variações acionais da sintaxe da função `aws_s3.table_import_from_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`. Com essa forma da função, o acesso ao Amazon S3 é fornecido por uma função do IAM na instância de banco de dados do PostgreSQL. ``` aws_s3.table_import_from_s3 ( table_name text, column_list text, options text, bucket text, file_path text, region text ) ``` + Em vez de usar o parâmetro `credentials` para especificar o acesso ao Amazon S3, use a combinação dos parâmetros `access_key`, `session_key` e `session_token`. ``` aws_s3.table_import_from_s3 ( table_name text, column_list text, options text, bucket text, file_path text, region text, access_key text, secret_key text, session_token text ) ``` ### Parâmetros alternativos *Bucket de* Uma string de texto contendo o nome do bucket do Amazon S3 que contém o arquivo. *file\$1path* Uma string de texto contendo o nome do arquivo do Amazon S3, incluindo o caminho do arquivo. *region* Uma string de texto que identifica a Região da AWS do arquivo. Para obter uma listagem de nomes de Região da AWS e os valores associados, consulte [Regiões, zonas de disponibilidade e Local Zones](Concepts.RegionsAndAvailabilityZones.md). *access\$1key* Uma string de texto contendo a chave de acesso a ser usada para a operação de importação. O padrão é NULL. *secret\$1key* Uma string de texto contendo a chave secreta a ser usada para a operação de importação. O padrão é NULL. *session\$1token* (Opcional) Uma string de texto contendo a chave de sessão a ser usada para a operação de importação. O padrão é NULL. ## 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.table\$1import\$1from\$1s3](#aws_s3.table_import_from_s3). ### Sintaxe ``` aws_commons.create_s3_uri( bucket text, file_path text, region text ) ``` ### Parâmetros *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ão da AWS e os valores associados, consulte [Regiões, zonas de disponibilidade e Local Zones](Concepts.RegionsAndAvailabilityZones.md). ## aws\$1commons.create\$1aws\$1credentials Define uma chave de acesso e uma chave secreta em uma estrutura `aws_commons._aws_credentials_1`. Use os resultados da função `aws_commons.create_aws_credentials` no parâmetro `credentials` da função [aws\$1s3.table\$1import\$1from\$1s3](#aws_s3.table_import_from_s3). ### Sintaxe ``` aws_commons.create_aws_credentials( access_key text, secret_key text, session_token text ) ``` ### Parâmetros *access\$1key* Uma string de texto necessária contendo a chave de acesso a ser usada para importar um arquivo do Amazon S3. O padrão é NULL. *secret\$1key* Uma string de texto necessária contendo a chave secreta a ser usada para importar um arquivo do Amazon S3. O padrão é NULL. *session\$1token* Uma string de texto opcional contendo o token de sessão a ser usado para importar um arquivo do Amazon S3. O padrão é NULL. Se você fornecer um `session_token` opcional, poderá usar credenciais temporárias. # Como transportar bancos de dados PostgreSQL entre instâncias de banco de dados Usando os bancos de dados PostgreSQL transportáveis para Amazon RDS, você pode mover um banco de dados PostgreSQL entre duas instâncias de banco de dados. Essa é uma maneira muito rápida de migrar bancos de dados grandes entre diferentes instâncias de banco de dados. Para usar essa abordagem, suas instâncias de banco de dados devem executar a mesma versão principal do PostgreSQL. Esse recurso requer que você instale a extensão `pg_transport` nas instâncias de banco de dados de origem e de destino. A extensão `pg_transport` fornece um mecanismo de transporte físico que move os arquivos de banco de dados com o mínimo de processamento. Esse mecanismo move os dados muito mais rapidamente que os processos tradicionais de despejo e carregamento, com menos tempo de inatividade. **nota** Os bancos de dados PostgreSQL transportáveis estão disponíveis no RDS para PostgreSQL versões 11.5 e posteriores e 10.10 e posteriores. Para transportar uma instância de banco de dados PostgreSQL de uma instância de banco de dados do RDS for PostgreSQL para outra, você primeiro configura as instâncias de origem e de destino, conforme detalhado em [ Configurar uma instância de banco de dados para transporte](PostgreSQL.TransportableDB.Setup.md). Em seguida, você pode transportar o banco de dados usando a função descrita em [ Como transportar um banco de dados PostgreSQL](PostgreSQL.TransportableDB.Transporting.md). **Topics** + [O que acontece durante o transporte do banco de dados](#PostgreSQL.TransportableDB.DuringTransport) + [Limitações para o uso de bancos de dados PostgreSQL transportáveis](#PostgreSQL.TransportableDB.Limits) + [Configurar o transporte de um banco de dados PostgreSQL](PostgreSQL.TransportableDB.Setup.md) + [Transportar um banco de dados PostgreSQL para o destino a partir da origem](PostgreSQL.TransportableDB.Transporting.md) + [Referência de funções de bancos de dados transportáveis](PostgreSQL.TransportableDB.transport.import_from_server.md) + [Referência de parâmetros de bancos de dados transportáveis](PostgreSQL.TransportableDB.Parameters.md) ## O que acontece durante o transporte do banco de dados O recurso de bancos de dados PostgreSQL transportáveis usa um modelo pull para importar o banco de dados da instância de banco de dados de origem para a de destino. A função `transport.import_from_server` cria o banco de dados em trânsito na instância de banco de dados de destino. O banco de dados em trânsito está inacessível na instância de banco de dados de destino durante o transporte. Quando o transporte começa, todas as sessões atuais no banco de dados de origem são encerradas. Quaisquer bancos de dados que não sejam o banco de dados de origem na instância de banco de dados de origem não são afetados pelo transporte. O banco de dados de origem é colocado em um modo somente leitura especial. Enquanto estiver nesse modo, você pode se conectar ao banco de dados de origem e executar consultas somente leitura. No entanto, as consultas habilitadas para gravação e alguns outros tipos de comandos estão bloqueados. Somente o banco de dados de origem específico que está sendo transportado é afetado por essas restrições. Durante o transporte, você não pode restaurar a instância do banco de dados de destino em um determinado momento. Isso ocorre porque o transporte não é transacional e não usa o log de gravação antecipada do PostgreSQL para registrar as alterações. Se a instância de banco de dados de destino tiver backups automáticos ativados, um backup será feito automaticamente após a conclusão do transporte. As restaurações em um ponto anterior no tempo ficam disponíveis por algumas horas *após* a conclusão do backup. Se o transporte falhar, a extensão `pg_transport` tenta desfazer todas as alterações nas instâncias de banco de dados de origem e destino. Isso inclui a remoção do banco de dados parcialmente transportado do destino. Dependendo do tipo de falha, o banco de dados de origem pode continuar a rejeitar consultas habilitadas para gravação. Se isso acontecer, use o comando a seguir para permitir consultas habilitadas para gravação. ``` ALTER DATABASE db-name SET default_transaction_read_only = false; ``` ## Limitações para o uso de bancos de dados PostgreSQL transportáveis Os bancos de dados transportáveis têm as seguintes limitações: + **Réplicas de leitura ** – não é possível usar bancos de dados transportáveis em réplicas de leitura nem em instâncias pai de réplicas de leitura. + **Tipos de coluna não compatíveis** – não é possível usar os tipos de dados `reg` em nenhuma tabela de banco de dados que você planeja transportar com esse método. Esses tipos dependem dos IDs de objeto (OIDs) do catálogo do sistema, que geralmente são alterados durante o transporte. + **Espaços de tabela** – todos os objetos do banco de dados de origem devem estar no espaço de tabela `pg_default` padrão. + **Compatibilidade** – as instâncias de banco de dados de origem e destino devem executar a mesma versão principal do PostgreSQL. + **Extensões**: a instância de banco de dados de origem pode ter apenas a extensão `pg_transport` instalada. + **Funções e ACLs** – os privilégios de acesso e as informações de propriedade do banco de dados de origem não são transferidos para o banco de dados de destino. Todos os objetos de banco de dados são criados e pertencentes ao usuário de destino local do transporte. + **Transportes simultâneos**: uma única instância de banco de dados pode aceitar até 32 transportes simultâneos, incluindo importações e exportações, se os processos do operador tiverem sido configurados corretamente. + **Somente para instâncias de banco de dados do RDS for PostgreSQL**: os bancos de dados transportáveis do PostgreSQL são compatíveis apenas com instâncias de banco de dados do RDS for PostgreSQL. Não é possível utilizá-los com bancos de dados locais ou bancos de dados em execução no Amazon EC2. # Configurar o transporte de um banco de dados PostgreSQL Antes de começar, certifique-se de que as instâncias de banco de dados do RDS for PostgreSQL atendam aos seguintes requisitos: + As instâncias de banco de dados do RDS for PostgreSQL para a origem e o destino devem ser executadas na mesma versão do PostgreSQL. + O banco de dados de destino não pode ter um banco de dados com o mesmo nome do banco de dados de origem que você deseja transportar. + A conta que você usa para executar o transporte precisa dos privilégios `rds_superuser` nos bancos de dados de origem e de destino. + O grupo de segurança da instância de banco de dados de origem deve permitir acesso de entrada da instância de banco de dados de destino. Isso pode já ser o caso se as instâncias de banco de dados de origem e de destino estiverem localizadas na VPC. Para obter mais informações sobre grupo de seguranças, consulte [Controlar acesso com grupos de segurança](Overview.RDSSecurityGroups.md). O transporte de bancos de dados de uma instância de banco de dados de origem para uma instância de banco de dados de destino requer várias alterações no grupo de parâmetros de banco de dados associado a cada instância. Isso significa que você deve criar um grupo de parâmetros de banco de dados personalizado para a instância de banco de dados de origem e criar um grupo de parâmetros de banco de dados personalizado para a instância de banco de dados de destino. **nota** Se suas instâncias de banco de dados já estiverem configuradas usando grupos de parâmetros de banco de dados personalizados, você poderá começar com a etapa 2 no procedimento a seguir. **Para configurar os parâmetros de grupos de banco de dados personalizados para o transporte de bancos de dados** Para as etapas a seguir, use uma conta que tenha os privilégios `rds_superuser`. 1. Se as instâncias de banco de dados de origem e de destino usarem um grupo de parâmetros de banco de dados padrão, você precisará criar um grupo de parâmetros de banco de dados personalizado usando a versão apropriada para suas instâncias. Você faz isso para poder alterar valores para vários parâmetros. Para obter mais informações, consulte [Grupos de parâmetros para Amazon RDS](USER_WorkingWithParamGroups.md). 1. No grupo de parâmetros de banco de dados personalizado, altere os valores dos seguintes parâmetros: + `shared_preload_libraries`: adicionar `pg_transport` à lista de bibliotecas. + `pg_transport.num_workers`: o valor padrão é 3. Aumente ou reduza esse valor conforme necessário para o banco de dados. Para um banco de dados de 200 GB, recomendamos não mais que 8. Tenha em mente que, se você aumentar o valor padrão desse parâmetro, você também deverá aumentar o valor de `max_worker_processes`. + `pg_transport.work_mem`: o valor padrão é 128 MB ou 256 MB, dependendo da versão do PostgreSQL. A configuração padrão geralmente pode ser deixada inalterada. + `max_worker_processes`: o valor desse parâmetro precisa ser definido usando o seguinte cálculo: ``` (3 * pg_transport.num_workers) + 9 ``` Esse valor é obrigatório no destino para lidar com vários processos de operador em segundo plano envolvidos no transporte. Para saber mais sobre `max_worker_processes,` consulte [Consumo de recursos](https://www.postgresql.org/docs/current/runtime-config-resource.html) na documentação do PostgreSQL. Para obter mais informações sobre parâmetros do `pg_transport`, consulte [Referência de parâmetros de bancos de dados transportáveis](PostgreSQL.TransportableDB.Parameters.md). 1. Reinicialize a instância de banco de dados do RDS for PostgreSQL de origem e a instância de destino para que as configurações dos parâmetros entrem em vigor. 1. Conecte-se à sua instância de banco de dados do RDS for PostgreSQL de origem. ``` psql --host=source-instance.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password ``` 1. Remova extensões estranhas do esquema público da instância de banco de dados. Somente a extensão `pg_transport` é permitida durante a operação de transporte real. 1. Instale a extensão `pg_transport` da seguinte forma: ``` postgres=> CREATE EXTENSION pg_transport; CREATE EXTENSION ``` 1. Conecte-se à sua instância de banco de dados do RDS for PostgreSQL de destino. Remova qualquer extensão estranha e, em seguida, instale a extensão `pg_transport`. ``` postgres=> CREATE EXTENSION pg_transport; CREATE EXTENSION ``` # Transportar um banco de dados PostgreSQL para o destino a partir da origem Depois de concluir o processo descrito em [Configurar o transporte de um banco de dados PostgreSQL](PostgreSQL.TransportableDB.Setup.md), você pode iniciar o transporte. Para fazer isso, execute a função `transport.import_from_server` na instância de banco de dados de destino. Na sintaxe a seguir, você pode encontrar os parâmetros da função. ``` SELECT transport.import_from_server( 'source-db-instance-endpoint', source-db-instance-port, 'source-db-instance-user', 'source-user-password', 'source-database-name', 'destination-user-password', false); ``` O valor `false` mostrado no exemplo diz à função que esta não é uma simulação. Para testar sua configuração de transporte, você pode especificar `true` para `dry_run` quando você chama a função, conforme mostrado a seguir: ``` postgres=> SELECT transport.import_from_server( 'docs-lab-source-db.666666666666aws-region.rds.amazonaws.com', 5432, 'postgres', '********', 'labdb', '******', true); INFO: Starting dry-run of import of database "labdb". INFO: Created connections to remote database (took 0.03 seconds). INFO: Checked remote cluster compatibility (took 0.05 seconds). INFO: Dry-run complete (took 0.08 seconds total). import_from_server -------------------- (1 row) ``` As linhas INFO são emitidas porque o parâmetro `pg_transport.timing` está definido como seu valor padrão, `true`. Defina `dry_run` para `false` quando você executa o comando e o banco de dados de origem é importado para o destino, conforme mostrado a seguir: ``` INFO: Starting import of database "labdb". INFO: Created connections to remote database (took 0.02 seconds). INFO: Marked remote database as read only (took 0.13 seconds). INFO: Checked remote cluster compatibility (took 0.03 seconds). INFO: Signaled creation of PITR blackout window (took 2.01 seconds). INFO: Applied remote database schema pre-data (took 0.50 seconds). INFO: Created connections to local cluster (took 0.01 seconds). INFO: Locked down destination database (took 0.00 seconds). INFO: Completed transfer of database files (took 0.24 seconds). INFO: Completed clean up (took 1.02 seconds). INFO: Physical transport complete (took 3.97 seconds total). import_from_server -------------------- (1 row) ``` Esta função requer que você forneça senhas de usuário do banco de dados. Portanto, recomendamos que você altere as senhas das funções de usuário usadas após a conclusão do transporte. Ou você pode usar variáveis de ligação do SQL para criar funções de usuário temporárias. Use essas funções temporárias para o transporte e descarte as funções posteriormente. Quando o transporte não for bem-sucedido, talvez você veja uma mensagem de erro semelhante à seguinte: ``` pg_transport.num_workers=8 25% of files transported failed to download file data ``` A mensagem de erro “falha ao baixar dados do arquivo” indica que o número de processos de trabalho não está definido corretamente para o tamanho do banco de dados. Talvez seja necessário aumentar ou diminuir o valor definido para `pg_transport.num_workers`. Cada falha informa a porcentagem de conclusão, para que você possa ver o impacto de suas alterações. Por exemplo, alterar a configuração de 8 para 4 em um caso resultou no seguinte: ``` pg_transport.num_workers=4 75% of files transported failed to download file data ``` Lembre-se de que o parâmetro `max_worker_processes` também é levado em consideração durante o processo de transporte. Em outras palavras, talvez seja necessário modificar `pg_transport.num_workers` e `max_worker_processes` para transportar o banco de dados com êxito. O exemplo mostrado finalmente funcionou quando `pg_transport.num_workers` foi definido como 2: ``` pg_transport.num_workers=2 100% of files transported ``` Para obter mais informações sobre a função `transport.import_from_server` seus respectivos parâmetros de configuração, consulte [Referência de funções de bancos de dados transportáveis](PostgreSQL.TransportableDB.transport.import_from_server.md). # Referência de funções de bancos de dados transportáveis A função `transport.import_from_server` transporta um banco de dados PostgreSQL importando-o de uma instância de banco de dados de origem para uma instância de banco de dados de destino. Isso é feito usando um mecanismo de transporte de conexão de banco de dados físico. Antes de iniciar o transporte, essa função verifica se as instâncias de banco de dados de origem e de destino são da mesma versão e são compatíveis com a migração. Também confirma que a instância de banco de dados de destino tem espaço suficiente para a origem. **Sintaxe** ``` transport.import_from_server( host text, port int, username text, password text, database text, local_password text, dry_run bool ) ``` **Valor de retorno** Nenhum. **Parâmetros** Você pode encontrar descrições dos parâmetros da função `transport.import_from_server` na tabela a seguir. **** | Parâmetro | Descrição | | --- | --- | | host | O endpoint da instância de banco de dados de origem. | | port | Um número inteiro que representa a porta da instância de banco de dados de origem. As instâncias de banco de dados do PostgreSQL costumam usar a porta 5432. | | username | O usuário da instância de banco de dados de origem. Este usuário deve ser um membro da função `rds_superuser`. | | password | A senha da instância de banco de dados de origem. | | database | O nome do banco de dados na instância do banco de dados de origem a ser transportada. | | local\$1password | A senha local do usuário atual para a instância de banco de dados de destino. Este usuário deve ser um membro da função `rds_superuser`. | | dry\$1run | Um valor booleano opcional que especifica se é necessário executar uma simulação. O padrão é `false`, o que significa que o transporte continua.Para confirmar a compatibilidade entre as instâncias de banco de dados de origem e destino sem executar o transporte real, configure dry\$1run como true. | **Exemplo** Para ver um exemplo, consulte [Transportar um banco de dados PostgreSQL para o destino a partir da origem](PostgreSQL.TransportableDB.Transporting.md). # Referência de parâmetros de bancos de dados transportáveis Vários parâmetros controlam o comportamento da extensão `pg_transport`. A seguir, você pode encontrar as descrições desses parâmetros. **`pg_transport.num_workers`** O número de operadores a serem usados para o processo de transporte. O padrão é 3. Os valores válidos são 1–32. Geralmente, mesmo os maiores transportes de banco de dados exigem menos de oito operadores. O valor dessa configuração na instância de banco de dados de destino é usada pelo destino e pela origem durante o transporte. **`pg_transport.timing` ** Especifica se é necessário relatar informações de tempo durante o transporte. O padrão é `true`, o que significa que as informações de tempo são relatadas. Recomendamos deixar esse parâmetro definido como `true` para que você possa monitorar o progresso. Veja um exemplo de resultado em [Transportar um banco de dados PostgreSQL para o destino a partir da origem](PostgreSQL.TransportableDB.Transporting.md). **`pg_transport.work_mem`** A quantidade máxima de memória a ser alocada para cada operador. O padrão é 131.072 kilobytes (KB) ou 262.144 KB (256 MB), dependendo da versão do PostgreSQL. O valor mínimo é de 64 megabytes (65.536 KB). Os valores válidos estão em kilobytes (KBs) como unidades binárias de base 2, em que 1 KB = 1.024 bytes. O transporte pode usar menos memória que o especificado neste parâmetro. Geralmente, mesmo transportes grandes de banco de dados exigem menos de 256 MB (262.144 KB) de memória por operador.