# Importar e exportar bancos de dados do SQL Server usando backup e restauração nativos
O Amazon RDS suporta backup e restauração nativos para bancos de dados do Microsoft SQL Server usando arquivos de backup completo (arquivos .bak). Ao usar o RDS, acesse arquivos armazenados no Amazon S3, em vez de usar o sistema de arquivos local no servidor de banco de dados.
Por exemplo, crie um backup completo no servidor local, armazene-o no S3 e o restaure em uma instância de banco de dados do Amazon RDS existente. Também faça backups do RDS, armazene-os no S3 e os restaure sempre que quiser.
O backup e a restauração nativos estão disponíveis em todas as regiões da AWS para as instâncias de banco de dados Mono-AZ e multi-AZ, incluindo instâncias de banco de dados multi-AZ com réplicas de leitura. O backup e a restauração nativos estão disponíveis para todas as edições do Microsoft SQL Server compatíveis com o Amazon RDS.
O diagrama a seguir mostra os cenários compatíveis.
![\[Arquitetura de backup e restauração nativos\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/SQL-bak-file.png)
Usar arquivos .bak nativos para fazer backup e restaurar bancos de dados costuma ser a maneira mais rápida de se fazer backup e restauração de bancos de dados. Há muitas vantagens adicionais em se usar o backup e a restauração nativos. Por exemplo, você pode fazer o seguinte:
+ Migrar bancos de dados para ou de Amazon RDS.
+ Movimentação de bancos de dados entre instâncias de banco de dados do RDS for SQL Server.
+ Migrar dados, esquemas, procedimentos armazenados, disparadores e outros códigos de banco de dados dentro de um arquivo .bak.
+ Fazer backup e restauração de bancos de dados únicos, em vez de instâncias de banco de dados inteiras.
+ Criar cópias de bancos de dados para desenvolvimento, testes, treinamento e demonstrações.
+ Armazenar e transferir arquivos de backup com o Amazon S3, para uma camada adicional de proteção para recuperação de desastres.
+ Crie backups nativos de bancos de dados com Transparent Data Encryption (TDE) ativada e restaure esses backups em bancos de dados on-premises. Para obter mais informações, consulte [Suporte para criptografia de dados transparente no SQL Server](Appendix.SQLServer.Options.TDE.md).
+ Restaure backups nativos de bancos de dados on-premises que têm o TDE ativado para instâncias de banco de dados do RDS para SQL Server. Para obter mais informações, consulte [Suporte para criptografia de dados transparente no SQL Server](Appendix.SQLServer.Options.TDE.md).
**Contents**
+ [Limitações e recomendações](#SQLServer.Procedural.Importing.Native.Limitations)
+ [Configurar o backup e a restauração nativos](SQLServer.Procedural.Importing.Native.Enabling.md)
+ [Criar manualmente uma função do IAM para backup e restauração nativos](SQLServer.Procedural.Importing.Native.Enabling.md#SQLServer.Procedural.Importing.Native.Enabling.IAM)
+ [Usar o backup e restauração nativos](SQLServer.Procedural.Importing.Native.Using.md)
+ [Realização de backup de um banco de dados](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Using.Backup)
+ [Usage](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Backup.Syntax)
+ [Exemplos](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Backup.Examples)
+ [Restaurar um banco de dados](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Using.Restore)
+ [Usage](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Restore.Syntax)
+ [Exemplos](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Restore.Examples)
+ [Restaurar um log](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Restore.Log)
+ [Usage](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Restore.Log.Syntax)
+ [Exemplos](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Restore.Log.Examples)
+ [Concluir uma restauração de banco de dados](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Finish.Restore)
+ [Usage](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Finish.Restore.Syntax)
+ [Como trabalhar com bancos de dados parcialmente restaurados](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Partially.Restored)
+ [Descartando um banco de dados parcialmente restaurado](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Drop.Partially.Restored)
+ [Restauração de snapshot e comportamento de recuperação em um ponto anterior no tempo para bancos de dados parcialmente restaurados](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Snapshot.Restore)
+ [Cancelar uma tarefa](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Using.Cancel)
+ [Usage](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Cancel.Syntax)
+ [Acompanhar o status de tarefas](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Tracking)
+ [Usage](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Tracking.Syntax)
+ [Exemplos](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Tracking.Examples)
+ [Resposta](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Tracking.Response)
+ [Compactar arquivos de backup](SQLServer.Procedural.Importing.Native.Compression.md)
+ [Solução de problemas](SQLServer.Procedural.Importing.Native.Troubleshooting.md)
+ [Importar e exportar dados do SQL Server usando outros métodos](SQLServer.Procedural.Importing.Snapshots.md)
+ [Importar dados para o RDS para SQL Server usando um snapshot](SQLServer.Procedural.Importing.Snapshots.md#SQLServer.Procedural.Importing.Procedure)
+ [Importar os dados](SQLServer.Procedural.Importing.Snapshots.md#ImportData.SQLServer.Import)
+ [Assistente para gerar e publicar scripts](SQLServer.Procedural.Importing.Snapshots.md#ImportData.SQLServer.MgmtStudio.ScriptWizard)
+ [Assistente de importação e exportação](SQLServer.Procedural.Importing.Snapshots.md#ImportData.SQLServer.MgmtStudio.ImportExportWizard)
+ [Cópia em massa](SQLServer.Procedural.Importing.Snapshots.md#ImportData.SQLServer.MgmtStudio.BulkCopy)
+ [Exportar dados do RDS para SQL Server](SQLServer.Procedural.Importing.Snapshots.md#SQLServer.Procedural.Exporting)
+ [Assistente de importação e exportação do SQL Server](SQLServer.Procedural.Importing.Snapshots.md#SQLServer.Procedural.Exporting.SSIEW)
+ [Utilitário bcp e Assistente para gerar e publicar scripts do SQL Server](SQLServer.Procedural.Importing.Snapshots.md#SQLServer.Procedural.Exporting.SSGPSW)
+ [Usar o utilitário BCP do Linux para importar e exportar dados](SQLServer.Procedural.Importing.BCP.Linux.md)
+ [Pré-requisitos](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Prerequisites)
+ [Instalar ferramentas de linha de comandos do SQL Server no Linux](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Installing)
+ [Exportar dados do RDS para SQL Server](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Exporting)
+ [Sintaxe básica de exportação](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Exporting.Basic)
+ [Exemplo de exportação](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Exporting.Example)
+ [Importar dados para o RDS para SQL Server](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Importing)
+ [Sintaxe básica de importação](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Importing.Basic)
+ [Exemplo de importação](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Importing.Example)
+ [Opções comuns do BCP](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Options)
+ [Práticas recomendadas e considerações](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.BestPractices)
+ [Solução de problemas comuns do](SQLServer.Procedural.Importing.BCP.Linux.md#SQLServer.Procedural.Importing.BCP.Linux.Troubleshooting)
## Limitações e recomendações
A seguir estão algumas limitações para o uso de backup e restauração nativos:
+ Você não pode fazer backup ou restaurar de um bucket do Amazon S3 em uma região da AWS diferente de sua instância de banco de dados do Amazon RDS.
+ Não é possível restaurar um banco de dados com o mesmo nome de um banco de dados já existente. Os nomes de banco de dados são exclusivos.
+ Recomendamos que não restaure backups de um fuso horário em um fuso horário diferente. Se você restaurar backups de um fuso horário em outro fuso horário, deverá auditar as consultas e aplicativos para verificar os efeitos da alteração do fuso horário.
+ O RDS para Microsoft SQL Server tem um limite de tamanho de 5 TB por arquivo. Para backups nativos de bancos de dados maiores, você pode usar o backup de vários arquivos.
+ O tamanho máximo do banco de dados que pode ser feito backup no S3 depende da memória, CPU, E/S e recursos de rede disponíveis na instância de banco de dados. Quanto maior o banco de dados, mais memória o agente de backup consome.
+ Não é possível fazer backup ou restaurar mais de 10 arquivos de backup ao mesmo tempo.
+ Um backup diferencial baseia-se no último backup completo. Para que os backups diferenciais funcionem, você não pode obter um snapshot entre o último backup completo e o backup diferencial. Se desejar um backup diferencial, mas houver um snapshot manual ou automatizado, faça outro backup completo antes de continuar com o backup diferencial.
+ Restaurações diferenciais e de log não são compatíveis com bancos de dados com arquivos que têm seu file\$1guid (identificador exclusivo) definido como `NULL`.
+ Você pode executar até duas tarefas de backup ou restauração ao mesmo tempo.
+ Não é possível executar backups de log nativo do SQL Server no Amazon RDS.
+ O RDS oferece suporte a restaurações nativas de bancos de dados de até 64 TiB. Restaurações nativas de bancos de dados no SQL Server Express Edition estão limitadas a 10 GB.
+ Não é possível fazer backup de um banco de dados durante a janela de manutenção, nem enquanto o Amazon RDS estiver no processo de tirar um snapshot do banco de dados. Se uma tarefa nativa de backup se sobrepor à janela diária de backup do RDS, a tarefa nativa de backup será cancelada.
+ Em instâncias de banco de dados multi-AZ, você só pode restaurar de forma nativa os bancos de dados com backup feito no modelo de recuperação completo.
+ Não há suporte para a chamada dos procedimentos do RDS para backup/restauração dentro de uma transação.
+ Use uma AWS KMS key de criptografia simétrica para criptografar seus backups. O Amazon RDS não oferece suporte para chaves do KMS assimétricas. Para obter mais informações, consulte [Criar chaves do KMS simétricas](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) no *Guia do desenvolvedor da AWS Key Management Service*.
+ Os arquivos de backup nativo são criptografados com a chave do KMS especificada usando o modo de criptografia "Encryption-Only". Ao restaurar arquivos de backup criptografados, saiba que eles foram criptografados com o modo de criptografia "Encryption-Only".
+ Não é possível restaurar um banco de dados que contenha um grupo de arquivos FILESTREAM.
+ A criptografia do lado do servidor do Amazon S3 com o AWS KMS (SSE-KMS) é aceita por meio da configuração de criptografia padrão do bucket do S3 quando você transmite o `@enable_bucket_default_encryption=1` para o procedimento armazenado de backup. Por padrão, a restauração aceita a criptografia do lado do servidor do objeto do S3.
Quando você fornece uma chave do KMS a um procedimento armazenado, quaisquer restaurações e backups nativos são criptografados e descriptografados no lado do cliente com a chave do KMS. A AWS armazena os backups no bucket do S3 com SSE-S3 quando `@enable_bucket_default_encryption=0` ou com a chave padrão configurada do seu bucket do S3 quando `@enable_bucket_default_encryption=1`.
+ Quando você usa pontos de acesso do S3, o ponto de acesso não pode ser configurado para usar uma VPC interna do RDS.
+ Para obter o melhor desempenho, recomendamos usar buckets de diretório ou pontos de acesso para buckets de diretório, caso estejam disponíveis na sua região.
Se o banco de dados estiver offline enquanto o arquivo de backup for criado, copiado e restaurado, recomendamos que você use o backup e a restauração nativos para migrar seu banco de dados para o RDS. Se o banco de dados on-premises não puder ficar offline, recomendamos que você use o AWS Database Migration Service para migrar seu banco de dados para o Amazon RDS. Para obter mais informações, consulte [O que é o AWS Database Migration Service?](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html)
O backup e a restauração nativos não se destinam a substituir os recursos de recuperação de dados do recurso de cópia de snapshot entre regiões. Recomendamos que você use uma cópia do snapshot para copiar o snapshot do banco de dados em outra região da AWS para recuperação de desastres entre regiões no Amazon RDS. Para obter mais informações, consulte [Copiar um snapshot de banco de dados para o Amazon RDS](USER_CopySnapshot.md).
# Configurar o backup e a restauração nativos
Para configurar o backup e a restauração nativos, você precisará de três componentes:
1. Um bucket do Amazon S3 para armazenar seus arquivos de backup.
É necessário ter um bucket do S3 para usar nos arquivos de backup e fazer upload dos backups que deseja migrar para o RDS. Se você já tiver um bucket do Amazon S3, você pode usá-lo. Do contrário, [ crie um bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingaBucket.html). Como alternativa, opte por criar um novo bucket ao adicionar a opção `SQLSERVER_BACKUP_RESTORE` usando o Console de gerenciamento da AWS.
Para obter informações sobre como usar o S3, consulte o [Guia do usuário do Amazon Simple Storage Service](https://docs.aws.amazon.com/AmazonS3/latest/userguide/).
1. Uma função do AWS Identity and Access Management (IAM) para acessar o bucket.
Se você já tiver uma função do IAM, você pode usá-la. Você pode optar por criar uma nova função do IAM ao adicionar a opção `SQLSERVER_BACKUP_RESTORE` usando o Console de gerenciamento da AWS. Você também pode criar uma nova manualmente.
Se você quiser criar uma nova função do IAM manualmente, siga a abordagem discutida na próxima seção. Faça o mesmo se quiser associar relações de confiança e políticas de permissões a uma função existente do IAM.
1. A opção `SQLSERVER_BACKUP_RESTORE` adicionada a um grupo de opções em sua instância de banco de dados.
Para habilitar o backup e restauração nativos em sua instância de banco de dados, adicione a opção `SQLSERVER_BACKUP_RESTORE` a um grupo de opções em sua instância de banco de dados. Para mais informações e instruções, consulte [Suporte para backup e restauração nativos no SQL Server](Appendix.SQLServer.Options.BackupRestore.md).
## Criar manualmente uma função do IAM para backup e restauração nativos
Se você quiser criar manualmente uma nova função do IAM para usar com backup e restauração nativos, poderá fazê-lo. Nesse caso, você criará uma função para delegar permissões do serviço do Amazon RDS ao seu bucket do Amazon S3. Ao criar uma função do IAM, associe uma relação de fidedignidade e uma política de permissões. A relação de confiança permite que o RDS assuma essa função. A política de permissões define as ações que essa função pode executar. Para obter mais informações sobre como criar a função, consulte [Criar uma função para delegar permissões a um AWSserviço da ](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html).
Para o recurso de backup e restauração nativo, use políticas de confiança e permissões semelhantes aos exemplos nesta seção. No exemplo a seguir, usamos o nome principal do serviço `rds.amazonaws.com` como um alias para todas as contas de serviço. Em outros exemplos, especificamos um nome de recurso da Amazon (ARN) para identificar outra conta, usuário ou função para a qual estejamos concedendo acesso na política de confiança.
Recomendamos usar as chaves de contexto de condição global [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn) e [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount) em relações 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).
Você pode usar as duas chaves de contexto de condição global e fazer com que o valor `aws:SourceArn` contenha o ID da conta. Nesses casos, verifique se o valor `aws:SourceAccount` e a conta no `aws:SourceArn` usa o mesmo ID de conta quando eles são usados na mesma instrução.
+ 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 relação de confiança, certifique-se de usar a chave de contexto de condição global `aws:SourceArn` com o ARN completo dos recursos que acessam a função. Para backup e restauração nativos, certifique-se de incluir o grupo de opções de banco de dados e as instâncias de banco de dados, conforme mostrado no exemplo a seguir.
**Example de relação de confiança com a chave de contexto de condição global para backup e restauração nativos**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceArn": [
"arn:aws:rds:Region:0123456789:db:db_instance_identifier",
"arn:aws:rds:Region:0123456789:og:option_group_name"
],
"aws:SourceAccount": "0123456789"
}
}
}
]
}
```
O exemplo a seguir usa um ARN para especificar um recurso. Para obter mais informações sobre como usar ARNs, consulte [Nomes de recurso da Amazon (ARNs)](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html).
**Example de política de permissões para fazer backup e restauração nativos sem suporte de criptografia**
****
```
{
"Version":"2012-10-17",
"Statement":
[
{
"Effect": "Allow",
"Action":
[
"s3:ListBucket",
"s3:GetBucketLocation"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket"
},
{
"Effect": "Allow",
"Action":
[
"s3:GetObjectAttributes",
"s3:GetObject",
"s3:PutObject",
"s3:ListMultipartUploadParts",
"s3:AbortMultipartUpload"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
}
]
}
```
**Example política de permissões para fazer backup e restauração nativos com suporte de criptografia**
Se quiser criptografar seus arquivos de backup, inclua uma chave de criptografia em sua política de permissões. Para obter mais informações sobre as chaves de criptografia, consulte [Getting started](https://docs.aws.amazon.com/kms/latest/developerguide/getting-started.html) (Conceitos básicos) no *Guia do desenvolvedor do AWS Key Management Service*.
É necessário usar uma chave do KMS de criptografia simétrica para criptografar seus backups. O Amazon RDS não oferece suporte para chaves do KMS assimétricas. Para obter mais informações, consulte [Criar chaves do KMS simétricas](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) no *Guia do desenvolvedor da AWS Key Management Service*.
A função do IAM também deve ser um usuário de chave e administrador de chave para a chave do KMS, ou seja, ela deve ser especificada na política de chaves. Para obter mais informações, consulte [Criar chaves do KMS simétricas](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) no *Guia do desenvolvedor da AWS Key Management Service*.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowAccessToKey",
"Effect": "Allow",
"Action": [
"kms:DescribeKey",
"kms:GenerateDataKey",
"kms:Encrypt",
"kms:Decrypt"
],
"Resource": "arn:aws:kms:us-east-1:123456789012:key/key-id"
},
{
"Sid": "AllowAccessToS3",
"Effect": "Allow",
"Action": [
"s3:ListBucket",
"s3:GetBucketLocation"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket"
},
{
"Sid": "GetS3Info",
"Effect": "Allow",
"Action": [
"s3:GetObjectAttributes",
"s3:GetObject",
"s3:PutObject",
"s3:ListMultipartUploadParts",
"s3:AbortMultipartUpload"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
}
]
}
```
**Example política de permissões para backup e restauração nativos usando pontos de acesso sem suporte à criptografia**
As ações necessárias para usar os pontos de acesso do S3 são as mesmas dos buckets do S3. O caminho do recurso é atualizado para corresponder ao padrão do ARN do ponto de acesso do S3.
Os pontos de acesso devem ser configurados para usar a **origem da rede: Internet**, pois o RDS não publica VPCs privadas. O tráfego do S3 das instâncias do RDS não passa pela Internet pública, pois passa por VPCs privadas.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:ListBucket",
"s3:GetBucketLocation"
],
"Resource": [
"arn:aws:s3:us-east-1:111122223333:accesspoint/amzn-s3-demo-ap",
"arn:aws:s3:::underlying-bucket"
]
},
{
"Effect": "Allow",
"Action": [
"s3:GetObjectAttributes",
"s3:GetObject",
"s3:PutObject",
"s3:ListMultipartUploadParts",
"s3:AbortMultipartUpload"
],
"Resource": [
"arn:aws:s3:us-east-1:111122223333:accesspoint/amzn-s3-demo-ap/*",
"arn:aws:s3:::underlying-bucket/*"
]
}
]
}
```
**Example : política de permissões para backup e restauração nativos usando pontos de acesso para buckets de diretório sem suporte a criptografia**
Como os buckets de diretório usam um [mecanismo de autorização baseado em sessão](https://docs.aws.amazon.com//AmazonS3/latest/userguide/s3-express-authenticating-authorizing.html) diferente dos buckets de uso geral, a única permissão necessária para a restauração de backup nativa é a “s3express:CreateSession” em nível de bucket. Para configurar o acesso em nível de objeto, é necessário usar [pontos de acesso para buckets de diretório](https://docs.aws.amazon.com//AmazonS3/latest/userguide/access-points-directory-buckets-policies.html).
Os pontos de acesso devem ser configurados para usar a **origem da rede: Internet**, pois o RDS não publica VPCs privadas. O tráfego do S3 das instâncias do RDS não passa pela Internet pública, pois passa por VPCs privadas.
****
```
{
"Version":"2012-10-17",
"Statement":
[
{
"Effect": "Allow",
"Action": "s3express:CreateSession",
"Resource":
[
"arn:aws:s3express:us-east-1:111122223333:accesspoint/amzn-s3-demo-accesspoint--use1-az6--xa-s3",
"arn:aws:s3express:us-east-1:111122223333:bucket/amzn-s3-demo-bucket--use1-az6--x-s3"
]
}
]
}
```
# Usar o backup e restauração nativos
Depois de habilitar e configurar o backup e a restauração nativos, você pode começar a usá-los. Primeiro, conecte-se ao banco de dados do Microsoft SQL Server e chame um procedimento armazenado do Amazon RDS para fazer o trabalho. Para obter instruções sobre como se conectar ao banco de dados, consulte [Conectar-se à instância de banco de dados do Microsoft SQL Server](USER_ConnectToMicrosoftSQLServerInstance.md).
Alguns dos procedimentos armazenados exigem que você forneça um nome de recurso da Amazon (ARN) ao bucket e arquivo do Amazon S3. O formato do ARN é `arn:aws:s3:::bucket_name/file_name.extension`. O Amazon S3 não exige um número de conta ou região da AWS nos ARNs.
Se você também fornecer uma chave do KMS opcional, o formato do ARN da chave será `arn:aws:kms:region:account-id:key/key-id`. Para obter mais informações, consulte [Nomes de recurso da Amazon (ARNs) e namespaces de serviço da AWS](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html). É necessário usar uma chave do KMS de criptografia simétrica para criptografar seus backups. O Amazon RDS não oferece suporte para chaves do KMS assimétricas. Para obter mais informações, consulte [Criar chaves do KMS simétricas](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) no *Guia do desenvolvedor da AWS Key Management Service*.
**nota**
Independentemente de você usar ou não uma chave do KMS, as tarefas nativas de backup e restauração habilitam a criptografia Advanced Encryption Standard (AES) de 256 bits no lado do servidor por padrão por meio da SSE-S3 para arquivos carregados no S3. A transmissão de `@enable_bucket_default_encryption=1` para o procedimento armazenado de backup usa a chave de criptografia padrão configurada do bucket do S3.
Para instruções sobre como chamar cada procedimento armazenado, consulte os tópicos a seguir:
+ [Realização de backup de um banco de dados](#SQLServer.Procedural.Importing.Native.Using.Backup)
+ [Restaurar um banco de dados](#SQLServer.Procedural.Importing.Native.Using.Restore)
+ [Restaurar um log](#SQLServer.Procedural.Importing.Native.Restore.Log)
+ [Concluir uma restauração de banco de dados](#SQLServer.Procedural.Importing.Native.Finish.Restore)
+ [Como trabalhar com bancos de dados parcialmente restaurados](#SQLServer.Procedural.Importing.Native.Partially.Restored)
+ [Cancelar uma tarefa](#SQLServer.Procedural.Importing.Native.Using.Cancel)
+ [Acompanhar o status de tarefas](#SQLServer.Procedural.Importing.Native.Tracking)
## Realização de backup de um banco de dados
Para fazer backup de seu banco de dados, use o procedimento armazenado `rds_backup_database`.
**nota**
Você não pode fazer backup de um banco de dados durante a janela de manutenção ou enquanto o Amazon RDS está tirando um snapshot.
### Usage
```
exec msdb.dbo.rds_backup_database
@source_db_name='database_name',
@s3_arn_to_backup_to='arn:aws:s3:::bucket_name/file_name.extension',
[@kms_master_key_arn='arn:aws:kms:region:account-id:key/key-id'],
[@overwrite_s3_backup_file=0|1],
[@block_size=512|1024|2048|4096|8192|16384|32768|65536],
[@max_transfer_size=n],
[@buffer_count=n],
[@type='DIFFERENTIAL|FULL'],
[@number_of_files=n],
[@enable_bucket_default_encryption=0|1];
```
Os seguintes parâmetros são obrigatórios:
+ `@source_db_name` – o nome do banco de dados do qual deve ser feito backup
+ `@s3_arn_to_backup_to`: o ARN que indica o bucket do Amazon S3, o ponto de acesso, o bucket de diretório ou o ponto de acesso para o bucket de diretório a ser usado no backup e o nome do arquivo de backup.
O arquivo pode ter qualquer extensão, mas a extensão `.bak` costuma ser usada. Observe que os ARNs dos pontos de acesso devem ter o formato`arn:aws:s3:us-east-1:111122223333:access-point-name/object/key`.
Os seguintes parâmetros são opcionais:
+ `@kms_master_key_arn`: o ARN da chave do KMS simétrica a ser usada para criptografar o item.
+ Não é possível usar a chave de criptografia padrão. Se você usar a chave padrão, não será feito backup do banco de dados.
+ Se você não especificar um identificador de chave KMS, o arquivo de backup não será criptografado. Para ter mais informações, consulte [Criptografar recursos do Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Overview.Encryption.html).
+ Quando você especifica uma chave do KMS, é usada a criptografia no lado do cliente.
+ O Amazon RDS não oferece suporte para chaves do KMS assimétricas. Para obter mais informações, consulte [Criar chaves do KMS simétricas](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html#create-symmetric-cmk) no *Guia do desenvolvedor da AWS Key Management Service*.
+ `@overwrite_s3_backup_file` – um valor que indica se deseja substituir um arquivo de backup existente.
+ `0` – não substitui um arquivo existente. Esse valor é o padrão.
Definir `@overwrite_s3_backup_file` como 0 retornará um erro se o arquivo já existir.
+ `1` – substitui um arquivo existente que tenha o nome especificado, ainda que ele não seja um arquivo de backup.
+ `@type` – o tipo de backup.
+ `DIFFERENTIAL` – faz backup diferencial.
+ `FULL` – faz backup completo. Esse valor é o padrão.
Um backup diferencial baseia-se no último backup completo. Para que os backups diferenciais funcionem, você não pode obter um snapshot entre o último backup completo e o backup diferencial. Se desejar um backup diferencial, mas houver um snapshot, faça outro backup completo antes de continuar com o backup diferencial.
É possível procurar o último backup ou snapshot completo usando o seguinte exemplo de consulta SQL:
```
select top 1
database_name
, backup_start_date
, backup_finish_date
from msdb.dbo.backupset
where database_name='mydatabase'
and type = 'D'
order by backup_start_date desc;
```
+ `@number_of_files` – O número de arquivos em que o backup será dividido (em blocos). O número máximo é 10.
+ O backup de vários arquivos é compatível com backups completos e diferenciais.
+ Se você inserir um valor de 1 ou omitir o parâmetro, um único arquivo de backup será criado.
Forneça o prefixo que os arquivos têm em comum e depois o sufixo com um asterisco (`*`). O asterisco pode estar em qualquer lugar na parte *file\$1name* do ARN do S3. O asterisco é substituído por uma série de strings alfanuméricas nos arquivos gerados, começando com `1-of-number_of_files`.
Por exemplo, se os nomes de arquivo no ARN do S3 forem `backup*.bak` e você definir `@number_of_files=4`, os arquivos de backup gerados serão `backup1-of-4.bak`, `backup2-of-4.bak`, `backup3-of-4.bak` e `backup4-of-4.bak`.
+ Se algum dos nomes de arquivo já existir e `@overwrite_s3_backup_file` for 0, um erro será retornado.
+ Os backups de vários arquivos só podem ter um asterisco na parte *file\$1name* do ARN do S3.
+ Os backups de arquivo único podem ter qualquer número de asteriscos na parte *file\$1name* do ARN do S3. Os asteriscos não são removidos do nome do arquivo gerado.
+ `@block_size`: tamanho do bloco (em bytes) especificando o tamanho do bloco físico para operações de backup. Os valores válidos são 512, 1.024, 2.048, 4.096, 8.192, 16.384, 32.768 e 65.536
+ `@max_transfer_size`: o tamanho máximo de transferência indica o limite máximo do volume de dados (em bytes) transmitido por operação de E/S durante o processo de backup. Os valores válidos são múltiplos de 65536 bytes (64 KB) até 4194304 bytes (4 MB).
+ `@buffer_count`: número total de buffers de E/S a serem usados no processo de backup.
+ `@enable_bucket_default_encryption`: um valor que indica se a configuração de criptografia padrão do bucket do S3 deve ser usada para criptografia do lado do servidor no S3. Os buckets de diretório sempre usam a configuração de criptografia padrão do bucket, independentemente dessa configuração.
+ `0`: a criptografia do lado do servidor usa o Advanced Encryption Standard (AES) de 256 bits por meio da SSE-S3.
+ `1`: a criptografia do lado do servidor usa a [criptografia padrão](https://docs.aws.amazon.com//AmazonS3/latest/userguide/bucket-encryption.html) configurada do bucket do S3.
### Exemplos
**Example de backup diferencial**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup1.bak',
@overwrite_s3_backup_file=1,
@type='DIFFERENTIAL';
```
**Example de backup completo com criptografia do lado do cliente**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup1.bak',
@kms_master_key_arn='arn:aws:kms:us-east-1:123456789012:key/AKIAIOSFODNN7EXAMPLE',
@overwrite_s3_backup_file=1,
@type='FULL';
```
**Example de backup de vários arquivos**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@number_of_files=4;
```
**Example de backup diferencial de vários arquivos**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@type='DIFFERENTIAL',
@number_of_files=4;
```
**Example de backup de vários arquivos com criptografia**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@kms_master_key_arn='arn:aws:kms:us-east-1:123456789012:key/AKIAIOSFODNN7EXAMPLE',
@number_of_files=4;
```
**Example de backup de vários arquivos com substituição do S3**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@overwrite_s3_backup_file=1,
@number_of_files=4;
```
**Example de backup com tamanho de bloco**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@block_size=512;
```
**Example de backup de vários arquivos com `@max_transfer_size` e `@buffer_count`**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@number_of_files=4,
@max_transfer_size=4194304,
@buffer_count=10;
```
**Example de backup de arquivo único com o parâmetro @number\$1of\$1files**
Este exemplo gera um arquivo de backup chamado `backup*.bak`.
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@number_of_files=1;
```
**Example de backup completo com criptografia do lado do servidor**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:::mybucket/backup*.bak',
@overwrite_s3_backup_file=1,
@type='FULL',
@enable_bucket_default_encryption=1;
```
**Example de backup completo usando um ponto de acesso**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:us-east-1:111122223333:accesspoint/my-access-point/object/backup1.bak',
@overwrite_s3_backup_file=1,
@type='FULL';
```
**Example de backup completo usando um ponto de acesso para um bucket de diretório**
```
exec msdb.dbo.rds_backup_database
@source_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3express:us-east-1:123456789012:accesspoint/my-access-point--use1-az6--xa-s3/object/backup1.bak',
@overwrite_s3_backup_file=1,
@type='FULL';
```
## Restaurar um banco de dados
Para fazer restaurar seu banco de dados, chame o procedimento armazenado `rds_restore_database`. O Amazon RDS cria um snapshot inicial do banco de dados após a conclusão da tarefa de restauração, e o banco de dados é aberto.
### Usage
```
exec msdb.dbo.rds_restore_database
@restore_db_name='database_name',
@s3_arn_to_restore_from='arn:aws:s3:::bucket_name/file_name.extension',
@with_norecovery=0|1,
[@keep_cdc=0|1],
[@data_file_volume='D:|H:|I:|J:'],
[@log_file_volume='D:|H:|I:|J:'],
[@kms_master_key_arn='arn:aws:kms:region:account-id:key/key-id'],
[@block_size=512|1024|2048|4096|8192|16384|32768|65536],
[@max_transfer_size=n],
[@buffer_count=n],
[@type='DIFFERENTIAL|FULL'];
```
Os seguintes parâmetros são obrigatórios:
+ `@restore_db_name` – o nome do banco de dados a ser restaurado. Os nomes de banco de dados são exclusivos. Não é possível restaurar um banco de dados com o mesmo nome de um banco de dados já existente.
+ `@s3_arn_to_restore_from` – o ARN que indica o prefixo do Amazon S3 e os nomes dos arquivos de backup usados para restaurar o banco de dados.
+ Para o backup de um único arquivo, forneça o nome inteiro do arquivo.
+ Para um backup de vários arquivos, forneça o prefixo que os arquivos têm em comum e depois acrescente um sufixo com um asterisco (`*`).
+ Se estiver usando um bucket de diretório, o ARN deverá terminar com `/*` devido às [diferenças entre os buckets de diretório](https://docs.aws.amazon.com//AmazonS3/latest/userguide/s3-express-differences.html).
+ Se `@s3_arn_to_restore_from` estiver vazio, a seguinte mensagem de erro será retornada: O prefixo do ARN do S3 não pode estar vazio.
O seguinte parâmetro é necessário para restaurações diferenciais, mas opcional para restaurações completas:
+ `@with_norecovery` – a cláusula de recuperação a ser usada para a operação de restauração.
+ Defina como `0` para restauração com RECOVERY. Nesse caso, o banco de dados está on-line após a restauração.
+ Defina como `1` para restauração com NORECOVERY. Nesse caso, o banco de dados permanece no estado RESTORING após a conclusão da tarefa de restauração. Com essa abordagem, você pode fazer restaurações diferenciais posteriores.
+ Para restaurações DIFFERENTIAL, especifique `0` ou `1`.
+ Para restaurações `FULL`, esse valor padrão é `0`.
Os seguintes parâmetros são opcionais:
+ `@keep_cdc`: indica se a configuração de Change Data Capture (CDC) deve ser retida no banco de dados restaurado. Defina como `1` para habilitar KEEP\$1CDC, `0` para desabilitar. O valor padrão é `0`.
+ `@data_file_volume`: especifica a letra da unidade para arquivos de dados do banco de dados. O valor padrão é `D:`.
+ `@log_file_volume`: especifica a letra da unidade para arquivos de log do banco de dados. O valor padrão é `D:`.
+ `@kms_master_key_arn`: se você criptografou o arquivo de backup, será a chave do KMS a ser usada para descriptografar o arquivo.
Quando você especifica uma chave do KMS, é usada a criptografia no lado do cliente.
+ `@type` – o tipo de restauração. Os tipos válidos são `DIFFERENTIAL` e `FULL`. O valor padrão é `FULL`.
+ `@block_size`: tamanho do bloco (em bytes) especificando o tamanho do bloco físico para operações de backup. Os valores válidos são 512, 1.024, 2.048, 4.096, 8.192, 16.384, 32.768 e 65.536
+ `@max_transfer_size`: o tamanho máximo de transferência indica o limite máximo do volume de dados (em bytes) transmitido por operação de E/S durante o processo de backup. Os valores válidos são múltiplos de 65536 bytes (64 KB) até 4194304 bytes (4 MB).
+ `@buffer_count`: número total de buffers de E/S a serem usados no processo de backup.
**nota**
Para restaurações diferenciais, o banco de dados deve estar no estado RESTORING ou uma tarefa de restauração com NORECOVERY já deve existir.
Você não pode restaurar backups diferenciais posteriores enquanto o banco de dados estiver on-line.
Não é possível enviar uma tarefa de restauração para um banco de dados que já tenha uma tarefa de restauração pendente com RECOVERY.
As restaurações completas com NORECOVERY e KEEP\$1CDC não são aceitas.
Não há suporte para nenhuma restauração nativa em instâncias que têm réplicas de leitura entre regiões.
Para configurações compatíveis, restaurar um banco de dados em uma instância multi-AZ com réplicas de leitura é semelhante a restaurar um banco de dados em uma instância multi-AZ. Você não precisa executar nenhuma ação adicional para restaurar um banco de dados em uma réplica.
### Exemplos
**Example de restauração de único arquivo**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak';
```
**Example de restauração de vários arquivos**
Para evitar erros ao restaurar vários arquivos, certifique-se de que todos os arquivos de backup tenham o mesmo prefixo e que nenhum outro arquivo use esse prefixo.
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup*';
```
**Example de restauração completa de banco de dados com RECOVERY**
Os três exemplos a seguir executam a mesma tarefa, restauração completa com RECOVERY.
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak';
```
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
[@type='DIFFERENTIAL|FULL'];
```
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@type='FULL',
@with_norecovery=0;
```
**Example de restauração completa de banco de dados com criptografia**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@kms_master_key_arn='arn:aws:kms:us-east-1:123456789012:key/AKIAIOSFODNN7EXAMPLE';
```
**Example de restauração com tamanho de bloco**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@block_size=512;
```
**Example da restauração de vários arquivos com @max\$1transfer\$1size e @buffer\$1count**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup*',
@max_transfer_size=4194304,
@buffer_count=10;
```
**Example de restauração completa de banco de dados com NORECOVERY**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@type='FULL',
@with_norecovery=1;
```
**Example de restauração diferencial com NORECOVERY**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@type='DIFFERENTIAL',
@with_norecovery=1;
```
**Example de restauração diferencial com RECOVERY**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@type='DIFFERENTIAL',
@with_norecovery=0;
```
**Example de restauração completa de banco de dados com RECOVERY usando um ponto de acesso**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_backup_to='arn:aws:s3:us-east-1:111122223333:accesspoint/my-access-point/object/backup1.bak',
@with_norecovery=0;
```
**Example de restauração completa de banco de dados com KEEP-CDC**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@keep_cdc=1;
```
## Restaurar um log
Para restaurar seu log, chame o procedimento armazenado `rds_restore_log`.
### Usage
```
exec msdb.dbo.rds_restore_log
@restore_db_name='database_name',
@s3_arn_to_restore_from='arn:aws:s3:::bucket_name/log_file_name.extension',
[@kms_master_key_arn='arn:aws:kms:region:account-id:key/key-id'],
[@with_norecovery=0|1],
[@keep_cdc=0|1],
[@stopat='datetime'],
[@block_size=512|1024|2048|4096|8192|16384|32768|65536],
[@max_transfer_size=n],
[@buffer_count=n];
```
Os seguintes parâmetros são obrigatórios:
+ `@restore_db_name` – o nome do banco de dados cujo log deve ser restaurado.
+ `@s3_arn_to_restore_from` – o ARN indicando o prefixo do Amazon S3 e o nome do arquivo de log usado para restaurar o log. O arquivo pode ter qualquer extensão, mas a extensão `.trn` costuma ser usada.
Se `@s3_arn_to_restore_from` estiver vazio, a seguinte mensagem de erro será retornada: O prefixo do ARN do S3 não pode estar vazio.
Os seguintes parâmetros são opcionais:
+ `@keep_cdc`: indica se a configuração de Change Data Capture (CDC) deve ser retida no banco de dados restaurado. Defina como 1 para habilitar KEEP\$1CDC, 0 para desabilitar. O valor padrão é 0.
+ `@kms_master_key_arn`: se você criptografou o log, será a chave do KMS a ser usada para descriptografar o log.
+ `@with_norecovery` – a cláusula de recuperação a ser usada para a operação de restauração. Esse valor padrão é `1`.
+ Defina como `0` para restauração com RECOVERY. Nesse caso, o banco de dados está on-line após a restauração. Você não pode restaurar backups de log adicionais enquanto o banco de dados estiver on-line.
+ Defina como `1` para restauração com NORECOVERY. Nesse caso, o banco de dados permanece no estado RESTORING após a conclusão da tarefa de restauração. Com essa abordagem, você pode fazer restaurações de log posteriores.
+ `@stopat` – um valor que especifica que o banco de dados seja restaurado ao seu estado na data e hora especificadas (no formato de data e hora). Somente registros de log de transações gravados antes da data e hora especificadas são aplicados ao banco de dados.
Se esse parâmetro não for especificado (é NULL), o log completo será restaurado.
+ `@block_size`: tamanho do bloco (em bytes) especificando o tamanho do bloco físico para operações de backup. Os valores válidos são 512, 1.024, 2.048, 4.096, 8.192, 16.384, 32.768 e 65.536
+ `@max_transfer_size`: o tamanho máximo de transferência indica o limite máximo do volume de dados (em bytes) transmitido por operação de E/S durante o processo de backup. Os valores válidos são múltiplos de 65536 bytes (64 KB) até 4194304 bytes (4 MB).
+ `@buffer_count`: número total de buffers de E/S a serem usados no processo de backup.
**nota**
Para restaurações de log, o banco de dados deve estar em um estado de restauração ou uma tarefa de restauração com NORECOVERY já deve existir.
Você não pode restaurar backups de log enquanto o banco de dados estiver on-line.
Não é possível enviar uma tarefa de restauração de log em um banco de dados que já tenha uma tarefa de restauração pendente com RECOVERY.
### Exemplos
**Example de restauração de log**
```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn';
```
**Example de restauração de log com criptografia**
```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn',
@kms_master_key_arn='arn:aws:kms:us-east-1:123456789012:key/AKIAIOSFODNN7EXAMPLE';
```
**Example de restauração de log com NORECOVERY**
Os dois exemplos a seguir executam a mesma tarefa, restauração de log com NORECOVERY.
```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn',
@with_norecovery=1;
```
```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn';
```
**Example de restauração com tamanho de bloco**
```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn',
@block_size=512;
```
**Example de restauração de log com RECOVERY**
```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn',
@with_norecovery=0;
```
**Example de restauração de log com cláusula STOPAT**
```
exec msdb.dbo.rds_restore_log
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/mylog.trn',
@with_norecovery=0,
@stopat='2019-12-01 03:57:09';
```
**Example de restauração de log com KEEP\$1CDC**
```
exec msdb.dbo.rds_restore_database
@restore_db_name='mydatabase',
@s3_arn_to_restore_from='arn:aws:s3:::mybucket/backup1.bak',
@keep_cdc=1;
```
## Concluir uma restauração de banco de dados
Se a última tarefa de restauração no banco de dados tiver sido executada usando `@with_norecovery=1`, o estado do banco de dados será RESTORING. Abra esse banco de dados para operação normal usando o procedimento armazenado `rds_finish_restore`.
### Usage
```
exec msdb.dbo.rds_finish_restore @db_name='database_name';
```
**nota**
Para usar essa abordagem, o estado do banco de dados deve ser RESTORING sem nenhuma tarefa de restauração pendente.
Para concluir a restauração do banco de dados, use o login mestre. Ou use o login do usuário que realizou a última restauração do banco de dados ou faça login com NORECOVERY.
## Como trabalhar com bancos de dados parcialmente restaurados
### Descartando um banco de dados parcialmente restaurado
Para descartar um banco de dados parcialmente restaurado (deixado no estado RESTORING), use o procedimento armazenado `rds_drop_database`.
```
exec msdb.dbo.rds_drop_database @db_name='database_name';
```
**nota**
Não é possível enviar uma solicitação de banco de dados DROP para um banco de dados que já tenha uma tarefa de restauração pendente, tampouco concluir a tarefa de restauração.
Para descartar o banco de dados, use o login mestre: Ou use o login do usuário que realizou a última restauração do banco de dados ou faça login com NORECOVERY.
### Restauração de snapshot e comportamento de recuperação em um ponto anterior no tempo para bancos de dados parcialmente restaurados
Os bancos de dados parcialmente restaurados na instância de origem (deixados no estado RESTORING) são descartados da instância de destino durante a restauração do snapshot e a recuperação em um ponto anterior no tempo.
## Cancelar uma tarefa
Para cancelar uma tarefa de backup ou restauração, chame o procedimento armazenado `rds_cancel_task`.
**nota**
Você não pode cancelar uma tarefa FINISH\$1RESTORE.
### Usage
```
exec msdb.dbo.rds_cancel_task @task_id=ID_number;
```
O seguinte parâmetro é obrigatório:
+ `@task_id` – o ID da tarefa a ser cancelada. Você pode obter o ID da tarefa chamando `rds_task_status`.
## Acompanhar o status de tarefas
Para acompanhar o status de suas tarefas de backup e restauração, chame o procedimento armazenado `rds_task_status`. Se você não fornecer nenhum parâmetro, o procedimento armazenado retornará o status de todas as tarefas. O status das tarefas é atualizado aproximadamente a cada dois minutos. O histórico de tarefas é mantido por 36 dias.
### Usage
```
exec msdb.dbo.rds_task_status
[@db_name='database_name'],
[@task_id=ID_number];
```
Os seguintes parâmetros são opcionais:
+ `@db_name` – o nome do banco de dados do qual o status será exibido.
+ `@task_id` – o nome do ID da tarefa do qual o status será exibido.
### Exemplos
**Example de listagem do status de uma tarefa específica**
```
exec msdb.dbo.rds_task_status @task_id=5;
```
**Example de listagem do status de uma tarefa e banco de dados específicos**
```
exec msdb.dbo.rds_task_status
@db_name='my_database',
@task_id=5;
```
**Example de listagem de todas as tarefas e seus status em um banco de dados específico**
```
exec msdb.dbo.rds_task_status @db_name='my_database';
```
**Example de listagem de todas as tarefas e seus status na instância atual**
```
exec msdb.dbo.rds_task_status;
```
### Resposta
O procedimento armazenado `rds_task_status` retorna as colunas a seguir.
****
| Coluna | Descrição |
| --- | --- |
| `task_id` | O ID da tarefa. |
| `task_type` | Tipo de tarefa, dependendo dos parâmetros de entrada, conforme segue: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/SQLServer.Procedural.Importing.Native.Using.html) Amazon RDS cria um snapshot inicial do banco de dados após ser aberto mediante a conclusão das seguintes tarefas de restauração: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/SQLServer.Procedural.Importing.Native.Using.html) |
| `database_name` | O nome do banco de dados ao qual a tarefa está associada. |
| `% complete` | O progresso da tarefa em valor de porcentagem. |
| `duration (mins)` | A quantidade de tempo gasta na tarefa, em minutos. |
| `lifecycle` | O status da tarefa. Os possíveis status são os seguintes: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/SQLServer.Procedural.Importing.Native.Using.html) |
| `task_info` | Informações adicionais sobre a tarefa. No caso de erro durante o backup ou a restauração de um banco de dados, esta coluna contém as informações sobre o erro. Para obter uma lista de possíveis erros e estratégias de mitigação, consulte [Solução de problemas](SQLServer.Procedural.Importing.Native.Troubleshooting.md). |
| `last_updated` | A data e hora em que o status da tarefa foi atualizado pela última vez. O status é atualizado a cada 5% de progresso. |
| `created_at` | A data e hora em que a tarefa foi criada. |
| S3\$1object\$1arn | O ARN indicando o prefixo do Amazon S3 e o nome do arquivo que está sendo copiado ou restaurado. |
| `overwrite_s3_backup_file` | O valor do parâmetro `@overwrite_s3_backup_file` especificado ao chamar uma tarefa de backup. Para obter mais informações, consulte [Realização de backup de um banco de dados](#SQLServer.Procedural.Importing.Native.Using.Backup). |
| KMS\$1master\$1key\$1arn | O ARN para a chave do KMS usada para criptografia (para backup) e descriptografia (para restauração). |
| filepath | Não aplicável a tarefas de backup e restauração nativos |
| overwrite\$1file | Não aplicável a tarefas de backup e restauração nativos |
# Compactar arquivos de backup
Para economizar espaço no bucket do Amazon S3, você pode compactar seus arquivos de backup. Para obter mais informações sobre como compactar arquivos de backup, consulte [Compactação de backup](https://msdn.microsoft.com/en-us/library/bb964719.aspx) na documentação da Microsoft.
As seguintes edições de banco de dados oferecem suporte à compactação de arquivos de backup:
+ Microsoft SQL Server Enterprise Edition
+ Microsoft SQL Server Standard Edition
Para verificar a opção de compactação dos arquivos de backup, execute o seguinte código:
```
1. exec rdsadmin.dbo.rds_show_configuration 'S3 backup compression';
```
Para ativar a compactação dos arquivos de backup, execute o seguinte código:
```
1. exec rdsadmin.dbo.rds_set_configuration 'S3 backup compression', 'true';
```
Para desativar a compactação dos arquivos de backup, execute o seguinte código:
```
1. exec rdsadmin.dbo.rds_set_configuration 'S3 backup compression', 'false';
```
# Solução de problemas
Os problemas a seguir podem ocorrer ao usar o backup e a restauração nativos.
****
| Problema | Sugestões de solução de problemas |
| --- | --- |
| A opção de backup/restauração do banco de dados ainda não está habilitada ou está em processo de habilitação. Tente novamente mais tarde. | Verifique se você adicionou a opção `SQLSERVER_BACKUP_RESTORE` ao grupo de opções de banco de dados associado à sua instância de banco de dados. Para obter mais informações, consulte [Adicionar a opção de backup e restauração nativos](Appendix.SQLServer.Options.BackupRestore.md#Appendix.SQLServer.Options.BackupRestore.Add). |
| A permissão EXECUTE foi negada no objeto “*rds\$1backup\$1database*”, no banco de dados “msdb” e no esquema “dbo”. | Verifique se você está usando o usuário mestre ao executar o procedimento armazenado. Se você encontrar esse erro mesmo depois de fazer login como usuário mestre, pode ser que as permissões do usuário administrador estejam desalinhadas. Para redefinir o usuário mestre, use o Console de gerenciamento da AWS. Consulte [Redefinir a associação ao perfil db\$1owner para o usuário principal no Amazon RDS para SQL Server](Appendix.SQLServer.CommonDBATasks.ResetPassword.md). |
| A permissão EXECUTE foi negada no objeto “*rds\$1restore\$1database*”, no banco de dados “msdb” e no esquema “dbo”. | Verifique se você está usando o usuário mestre ao executar o procedimento armazenado. Se você encontrar esse erro mesmo depois de fazer login como usuário mestre, pode ser que as permissões do usuário administrador estejam desalinhadas. Para redefinir o usuário mestre, use o Console de gerenciamento da AWS. Consulte [Redefinir a associação ao perfil db\$1owner para o usuário principal no Amazon RDS para SQL Server](Appendix.SQLServer.CommonDBATasks.ResetPassword.md). |
| Acesso negado | O processo de backup ou restauração não pode acessar o arquivo de backup. Isso geralmente é causado por problemas como o seguinte: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/SQLServer.Procedural.Importing.Native.Troubleshooting.html) |
| O BANCO DE DADOS DE BACKUP COM COMPACTAÇÃO não tem suporte na edição | A compactação de arquivos de backup só tem suporte no Microsoft SQL Server Enterprise Edition e Standard Edition. Para obter mais informações, consulte [Compactar arquivos de backup](SQLServer.Procedural.Importing.Native.Compression.md). |
| A chave não existe | Você tentou restaurar um backup criptografado, mas não forneceu uma chave de criptografia válida. Confira sua chave de criptografia e tente novamente. Para obter mais informações, consulte [Restaurar um banco de dados](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Using.Restore). |
| Reemita a tarefa com o tipo correto e sobrescreva a propriedade | Se você tentar fazer backup de seu banco de dados e fornecer o nome de um arquivo que já existe, mas definir a propriedade de substituição como falso, a operação de salvar falhará. Para corrigir esse erro, forneça o nome de um arquivo que ainda não exista ou defina a propriedade de substituição como verdadeira. Para obter mais informações, consulte [Realização de backup de um banco de dados](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Using.Backup). Há casos em que você desejava restaurar seu banco de dados, mas chamou o procedimento armazenado `rds_backup_database` por engano. Nesse caso, chame o procedimento armazenado `rds_restore_database`. Para obter mais informações, consulte [Restaurar um banco de dados](SQLServer.Procedural.Importing.Native.Using.md#SQLServer.Procedural.Importing.Native.Using.Restore). Se você pretendia restaurar seu banco de dados e chamou o procedimento armazenado `rds_restore_database`, confira se você forneceu o nome de um arquivo de backup válido. Para obter mais informações, consulte [Usar o backup e restauração nativos](SQLServer.Procedural.Importing.Native.Using.md). |
| Especifique um bucket que esteja na mesma região que a instância do RDS | Você não pode fazer backup ou restaurar de um bucket do Amazon S3 em uma região da AWS diferente de sua instância de banco de dados do Amazon RDS. Você pode usar a replicação do Amazon S3 para copiar o arquivo de backup na região da AWS correta. Para obter mais informações, consulte [Replicação entre regiões](https://docs.aws.amazon.com/AmazonS3/latest/userguide/crr.html) na documentação do Amazon S3. |
| O bucket especificado não existe | Confirme que você forneceu um o ARN correto para o bucket e o arquivo, no formato correto. Para obter mais informações, consulte [Usar o backup e restauração nativos](SQLServer.Procedural.Importing.Native.Using.md). |
| O usuário não está autorizado a executar no recurso | Você solicitou uma operação criptografada, mas não forneceu as permissões de AWS KMS corretas;. Verifique se você tem as permissões corretas, ou adicione-as caso não tenha. Para obter mais informações, consulte [Configurar o backup e a restauração nativos](SQLServer.Procedural.Importing.Native.Enabling.md). |
| A tarefa Restore (Restaurar) não restaura mais de 10 arquivos de backup). Reduza o número de arquivos correspondentes e tente novamente. | Reduza o número de arquivos a partir dos quais você está tentando fazer a restauração. Você poderá tornar cada arquivo individual maior, se for necessário. |
| O banco de dados “*database\$1name*” já existe. Dois bancos de dados que diferem apenas por caso ou acento não são permitidos. Escolha um nome de banco de dados diferente. | Não é possível restaurar um banco de dados com o mesmo nome de um banco de dados já existente. Os nomes de banco de dados são exclusivos. |
# Importar e exportar dados do SQL Server usando outros métodos
Em seguida, você pode encontrar informações sobre o uso de snapshots para importar seus dados do Microsoft SQL Server para o Amazon RDS. Você também pode encontrar informações sobre o uso de snapshots para exportar seus dados de uma instância de banco de dados do RDS executando o SQL Server.
Se o seu cenário oferecer suporte, é mais fácil mover dados dentro e fora do Amazon RDS usando a funcionalidade nativa de backup e restauração. Para obter mais informações, consulte[Importar e exportar bancos de dados do SQL Server usando backup e restauração nativos](SQLServer.Procedural.Importing.md)
**nota**
O Amazon RDS para Microsoft SQL Server não é compatível com a importação de dados no banco de dados do `msdb`.
## Importar dados para o RDS para SQL Server usando um snapshot
**Para importar dados para uma instância de banco de dados SQL Server usando um snapshot**
1. Criar uma instância de banco de dados. Para obter mais informações, consulte [Criar uma instância de banco de dados do Amazon RDS](USER_CreateDBInstance.md).
1. Evite que os aplicativos acessem a instância de banco de dados de destino.
Se você impedir o acesso à sua instância de banco de dados enquanto estiver importando dados, a transferência de dados será mais rápida. Além disso, você não precisa se preocupar com conflitos enquanto os dados estão sendo carregados se outros aplicativos não puderem gravar na instância de banco de dados ao mesmo tempo. Se algo der errado e você tiver que reverter para um snapshot anterior do banco de dados, as únicas alterações que você perderá serão os dados importados. Você poderá importar esses dados novamente depois de resolver o problema.
Para obter informações sobre como controlar o acesso à sua instância de banco de dados, consulte [Controlar acesso com grupos de segurança](Overview.RDSSecurityGroups.md).
1. Crie um snapshot do banco de dados de destino.
Se o banco de dados de destino já estiver preenchido com dados, recomendamos que você tire um snapshot dele antes de importar os dados. Se algo der errado com a importação de dados ou se quiser descartar as alterações, você poderá restaurar o banco de dados para seu estado anterior usando esse snapshot. Para obter informações sobre snapshots 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).
**nota**
Quando você tira um snapshot de banco de dados, as operações de E/S nesse banco de dados são suspensas por um momento (milissegundos) enquanto o backup está em andamento.
1. Desabilite os backups automatizados no banco de dados de destino.
Desabilitar backups automatizados na instância de banco de dados de destino melhora a performance enquanto você estiver importando seus dados, pois o Amazon RDS não registra transações quando backups automáticos estão desabilitados. No entanto, existem algumas coisas a considerar. Backups automatizados são necessários para executar uma recuperação point-in-time. Portanto, você não poderá restaurar o banco de dados para um ponto específico ao mesmo tempo em que estiver importando dados. Além disso, todos os backups automatizados que foram criados na instância de banco de dados serão apagados, a menos que você opte por mantê-los.
Escolher manter os backups automatizados pode ajudar a proteger contra a exclusão acidental de dados. O Amazon RDS também salva as propriedades da instância de banco de dados juntamente com cada backup automatizado para facilitar a recuperação. Usar essa opção permite que você restaure uma instância de banco de dados excluída até um ponto específico no período de retenção do backup mesmo depois de excluí-la. Os backups automatizados são excluídos automaticamente ao final da janela de backup especificada, da mesma forma que para uma instância de banco de dados ativa.
Você ainda poderá usar os snapshots anteriores para recuperar o banco de dados, e todos os snapshots que tiverem sido tirados permanecem disponíveis. Para obter informações sobre backups automatizados, consulte [Introdução aos backups](USER_WorkingWithAutomatedBackups.md).
1. Desabilite restrições de chaves estrangeiras, se aplicável.
Se você precisar desabilitar restrições de chaves estrangeiras, poderá fazê-lo com o seguinte script.
```
--Disable foreign keys on all tables
DECLARE @table_name SYSNAME;
DECLARE @cmd NVARCHAR(MAX);
DECLARE table_cursor CURSOR FOR SELECT name FROM sys.tables;
OPEN table_cursor;
FETCH NEXT FROM table_cursor INTO @table_name;
WHILE @@FETCH_STATUS = 0 BEGIN
SELECT @cmd = 'ALTER TABLE '+QUOTENAME(@table_name)+' NOCHECK CONSTRAINT ALL';
EXEC (@cmd);
FETCH NEXT FROM table_cursor INTO @table_name;
END
CLOSE table_cursor;
DEALLOCATE table_cursor;
GO
```
1. Descarte índices, se aplicável.
1. Desabilite triggers, se aplicável.
Se precisar desabilitar triggers, faça isso com o seguinte script.
```
--Disable triggers on all tables
DECLARE @enable BIT = 0;
DECLARE @trigger SYSNAME;
DECLARE @table SYSNAME;
DECLARE @cmd NVARCHAR(MAX);
DECLARE trigger_cursor CURSOR FOR SELECT trigger_object.name trigger_name,
table_object.name table_name
FROM sysobjects trigger_object
JOIN sysobjects table_object ON trigger_object.parent_obj = table_object.id
WHERE trigger_object.type = 'TR';
OPEN trigger_cursor;
FETCH NEXT FROM trigger_cursor INTO @trigger, @table;
WHILE @@FETCH_STATUS = 0 BEGIN
IF @enable = 1
SET @cmd = 'ENABLE ';
ELSE
SET @cmd = 'DISABLE ';
SET @cmd = @cmd + ' TRIGGER dbo.'+QUOTENAME(@trigger)+' ON dbo.'+QUOTENAME(@table)+' ';
EXEC (@cmd);
FETCH NEXT FROM trigger_cursor INTO @trigger, @table;
END
CLOSE trigger_cursor;
DEALLOCATE trigger_cursor;
GO
```
1. Consulte a instância SQL Server de origem para quaisquer logons que você queira importar para a instância de banco de dados de destino.
O SQL Server armazena logons e senhas no banco de dados `master`. Como o Amazon RDS não concede acesso ao banco de dados `master`, não é possível importar logins e senhas diretamente para a sua instância de banco de dados de destino. Em vez disso, você deve consultar o banco de dados `master` na instância do SQL Server de origem para gerar um arquivo de linguagem de definição de dados (DDL). Esse arquivo deve incluir todos os logins e senhas que você queira adicionar à instância de banco de dados de destino. Esse arquivo também deve incluir associações de funções e permissões que você deseja transferir.
Para ter informações sobre como consultar o banco de dados `master`, consulte [ Transfer logins and passwords between instances of SQL Server](https://learn.microsoft.com/en-us/troubleshoot/sql/database-engine/security/transfer-logins-passwords-between-instances), na Base de Conhecimento da Microsoft.
A saída do script é outro script que você pode executar na instância de banco de dados de destino. O script no artigo da base de dados de conhecimento possui o seguinte código:
```
p.type IN
```
Sem que `p.type` aparecer, use o seguinte código em vez disso:
```
p.type = 'S'
```
1. Importe os dados usando o método em [Importar os dados](#ImportData.SQLServer.Import).
1. Conceda acesso para aplicativos à instância de banco de dados de destino.
Quando a importação de dados estiver concluída, você poderá conceder acesso para a instância de banco de dados aos aplicativos que você foram bloqueados durante a importação. Para obter informações sobre como controlar o acesso à sua instância de banco de dados, consulte [Controlar acesso com grupos de segurança](Overview.RDSSecurityGroups.md).
1. Habilite backups automatizados na instância de banco de dados de destino.
Para obter informações sobre backups automatizados, consulte [Introdução aos backups](USER_WorkingWithAutomatedBackups.md).
1. Habilite restrições de chaves estrangeiras.
Se você tiver desabilitado restrições de chaves estrangeiras anteriormente, agora poderá habilitá-las com o seguinte script.
```
--Enable foreign keys on all tables
DECLARE @table_name SYSNAME;
DECLARE @cmd NVARCHAR(MAX);
DECLARE table_cursor CURSOR FOR SELECT name FROM sys.tables;
OPEN table_cursor;
FETCH NEXT FROM table_cursor INTO @table_name;
WHILE @@FETCH_STATUS = 0 BEGIN
SELECT @cmd = 'ALTER TABLE '+QUOTENAME(@table_name)+' CHECK CONSTRAINT ALL';
EXEC (@cmd);
FETCH NEXT FROM table_cursor INTO @table_name;
END
CLOSE table_cursor;
DEALLOCATE table_cursor;
```
1. Habilite índices, se aplicável.
1. Habilite triggers, se aplicável.
Se você tiver desabilitado triggers anteriormente, agora poderá habilitá-los com o seguinte script.
```
--Enable triggers on all tables
DECLARE @enable BIT = 1;
DECLARE @trigger SYSNAME;
DECLARE @table SYSNAME;
DECLARE @cmd NVARCHAR(MAX);
DECLARE trigger_cursor CURSOR FOR SELECT trigger_object.name trigger_name,
table_object.name table_name
FROM sysobjects trigger_object
JOIN sysobjects table_object ON trigger_object.parent_obj = table_object.id
WHERE trigger_object.type = 'TR';
OPEN trigger_cursor;
FETCH NEXT FROM trigger_cursor INTO @trigger, @table;
WHILE @@FETCH_STATUS = 0 BEGIN
IF @enable = 1
SET @cmd = 'ENABLE ';
ELSE
SET @cmd = 'DISABLE ';
SET @cmd = @cmd + ' TRIGGER dbo.'+QUOTENAME(@trigger)+' ON dbo.'+QUOTENAME(@table)+' ';
EXEC (@cmd);
FETCH NEXT FROM trigger_cursor INTO @trigger, @table;
END
CLOSE trigger_cursor;
DEALLOCATE trigger_cursor;
```
### Importar os dados
O Microsoft SQL Server Management Studio é um cliente SQL Server gráfico que está incluído em todas as edições do Microsoft SQL Server, exceto a Express Edition. O SQL Server Management Studio Express está disponível na Microsoft como download gratuito. Para encontrar esse download, consulte o [site da Microsoft](https://www.microsoft.com/en-us/download).
**nota**
O SQL Server Management Studio está disponível apenas como um aplicativo baseado no Windows.
O SQL Server Management Studio inclui as seguintes ferramentas, que são úteis na importação de dados para uma instância de banco de dados SQL Server:
+ Assistente para gerar e publicar scripts
+ Assistente de importação e exportação
+ Cópia em massa
#### Assistente para gerar e publicar scripts
O Assistente para gerar e publicar scripts cria um script que contém o esquema de um banco de dados, os dados propriamente ditos ou ambos. Você pode gerar um script para um banco de dados na sua implantação local do SQL Server. Em seguida, pode executar esse script para transferir as informações que ele contém para uma instância de banco de dados do Amazon RDS.
**nota**
Para bancos de dados de 1 GiB ou maiores, é mais eficiente definir scripts apenas para o esquema de banco de dados. Depois, use o Assistente de importação e exportação ou o recurso de cópia em massa do SQL Server para transferir os dados.
Para obter informações detalhadas sobre o Assistente para gerar e publicar scripts, consulte a [documentação do Microsoft SQL Server](http://msdn.microsoft.com/en-us/library/ms178078%28v=sql.105%29.aspx).
No assistente, preste especial atenção às opções avançadas na página **Definir Opções de Script** para garantir que tudo o que você deseja que o script inclua esteja selecionado. Por exemplo, por padrão, triggers de banco de dados não estão incluídos no script.
Quando o script for gerado e salvo, você poderá usar o SQL Server Management Studio para se conectar à sua instância de banco de dados e executar o script.
#### Assistente de importação e exportação
O Assistente de importação e exportação cria um pacote especial de Serviços de integração, que você pode usar para copiar dados do seu banco de dados SQL Server local para a instância de banco de dados de destino. O assistente pode filtrar quais tabelas e até mesmo quais tuplas em uma tabela são copiadas para a instância de banco de dados de destino.
**nota**
O Assistente de importação e exportação funciona bem para conjuntos de dados grandes, mas talvez não seja a maneira mais rápida de exportar dados remotamente da sua implantação local. Para uma maneira ainda mais rápida, considere o recurso de cópia em massa do SQL Server.
Para obter informações detalhadas sobre o Assistente de importação e exportação, consulte a [documentação do Microsoft SQL Server](http://msdn.microsoft.com/en-us/library/ms140052%28v=sql.105%29.aspx).
No assistente, na página **Choose a Destination (Selecionar um destino)**, faça o seguinte:
+ Em **Server Name (Nome do servidor)**, digite o nome do endpoint da sua instância de banco de dados.
+ Para o modo de autenticação do servidor, escolha **Use SQL Server Authentication (Usar autenticação do SQL Server)**.
+ Em **User name (Nome do usuário)** e **Password (Senha)**, digite as credenciais do usuário mestre criado para a instância de banco de dados.
#### Cópia em massa
O recurso de cópia em massa do SQL Server é um meio eficiente de copiar dados de um banco de dados de origem para a sua instância de banco de dados. A cópia em massa grava os dados que você especifica em um arquivo de dados, como um arquivo ASCII. Você pode então executar cópias em massa novamente para gravar o conteúdo do arquivo na instância de banco de dados de destino.
Esta seção usa o utilitário **bcp**, que está incluído em todas as edições do SQL Server. Para obter informações detalhadas sobre operações de importação e exportação em massa, consulte [a documentação do Microsoft SQL Server](http://msdn.microsoft.com/en-us/library/ms187042%28v=sql.105%29.aspx).
**nota**
Antes de usar a cópia em massa, você deve importar seu esquema de banco de dados para a instância de banco de dados de destino. O Assistente para gerar e publicar scripts, descrito anteriormente neste tópico, é uma excelente ferramenta para esse propósito.
O comando a seguir se conecta à instância local do SQL Server. Ele gera um arquivo delimitado por tabulação de uma tabela especificada no diretório raiz C:\$1 da sua implantação SQL Server existente. A tabela é especificada pelo nome totalmente qualificado e o arquivo de texto tem o mesmo nome que a tabela que está sendo copiada.
```
bcp dbname.schema_name.table_name out C:\table_name.txt -n -S localhost -U username -P password -b 10000
```
O código anterior inclui as seguintes opções:
+ `-n` especifica que a cópia em massa usa os tipos de dados nativos dos dados a serem copiados.
+ `-S` especifica a instância SQL Server com a qual o utilitário *bcp* se conecta.
+ `-U` especifica o nome de usuário da conta que faz login na instância SQL Server.
+ `-P` especifica a senha para o usuário especificada por `-U`.
+ `-b` especifica o número de linhas por lote de dados importados.
**nota**
Pode haver outros parâmetros importantes para a sua situação de importação. Por exemplo, talvez você precise do parâmetro `-E` que pertence a valores de identidade. Para obter mais informações; consulte a descrição completa da sintaxe da linha de comando para o utilitário **bcp** na [documentação do Microsoft SQL Server](http://msdn.microsoft.com/en-us/library/ms162802%28v=sql.105%29.aspx).
Por exemplo, suponha que um banco de dados chamado `store`, que usa o esquema padrão, `dbo`, contém uma tabela chamada `customers`. A conta de usuário `admin`, com a senha `insecure`, copia 10.000 linhas da tabela `customers` para um arquivo chamado `customers.txt`.
```
bcp store.dbo.customers out C:\customers.txt -n -S localhost -U admin -P insecure -b 10000
```
Depois de gerar o arquivo de dados, você poderá fazer upload dos dados para a sua instância de banco de dados usando um comando semelhante. Antes disso, crie o banco de dados e o esquema na instância de banco de dados de destino. Em seguida, use o argumento `in` para especificar um arquivo de entrada em vez de `out` para especificar um arquivo de saída. Em vez de usar localhost para especificar a instância local SQL Server, especifique o endpoint da sua instância de banco de dados. Se você usar uma porta diferente de 1433, especifique isso também. O nome de usuário e a senha serão aqueles do usuário mestre e a senha da sua instância de banco de dados. A sintaxe é a seguinte.
```
bcp dbname.schema_name.table_name
in C:\table_name.txt -n -S endpoint,port -U master_user_name -P master_user_password -b 10000
```
Para continuar com o exemplo anterior, suponha que o nome do usuário mestre seja `admin` e a senha seja `insecure`. O endpoint da instância de banco de dados é `rds.ckz2kqd4qsn1.us-east-1.rds.amazonaws.com`, e você usa a porta 4080. O comando é o seguinte.
```
bcp store.dbo.customers in C:\customers.txt -n -S rds.ckz2kqd4qsn1.us-east-1.rds.amazonaws.com,4080 -U admin -P insecure -b 10000
```
**nota**
Especifique uma senha diferente do prompt mostrado aqui como prática recomendada de segurança.
## Exportar dados do RDS para SQL Server
Você pode escolher uma das seguintes opções para exportar dados de uma instância de banco de dados RDS for SQL Server:
+ **Backup de banco de dados nativo usando um arquivo de backup completo (.bak)** – o uso de arquivos .bak para bancos de dados de backup é fortemente otimizado e geralmente é a maneira mais rápida de exportar dados. Para obter mais informações, consulte [Importar e exportar bancos de dados do SQL Server usando backup e restauração nativos](SQLServer.Procedural.Importing.md).
+ **Assistente de importação e exportação do SQL Server** – para obter mais informações, consulte [Assistente de importação e exportação do SQL Server](#SQLServer.Procedural.Exporting.SSIEW).
+ **Utilitário bcp e Assistente para gerar e publicar scripts do SQL Server** – para obter mais informações, consulte [Utilitário bcp e Assistente para gerar e publicar scripts do SQL Server](#SQLServer.Procedural.Exporting.SSGPSW).
### Assistente de importação e exportação do SQL Server
Você pode usar o Assistente de importação e exportação do SQL Server para copiar uma ou mais tabelas, visualizações ou consultas da sua instância de banco de dados do RDS for SQL Server para outro armazenamento de dados. Essa será a melhor escolha se o armazenamento de dados de destino não for o SQL Server. Para obter mais informações, consulte [Assistente de importação e exportação do SQL Server](http://msdn.microsoft.com/en-us/library/ms141209%28v=sql.110%29.aspx) na documentação do SQL Server.
O Assistente de importação e exportação do SQL Server está disponível como parte do Microsoft SQL Server Management Studio. Esse cliente SQL Server gráfico está incluído em todas as edições do Microsoft SQL Server, exceto a Express Edition. O SQL Server Management Studio está disponível apenas como um aplicativo baseado no Windows. O SQL Server Management Studio Express está disponível na Microsoft como download gratuito. Para encontrar esse download, consulte o [site da Microsoft](http://www.microsoft.com/en-us/search/Results.aspx?q=sql%20server%20management%20studio).
**Para usar o Assistente de importação e exportação do SQL Server para exportar dados**
1. No SQL Server Management Studio, conecte-se à sua instância de banco de dados do RDS for SQL Server. Para obter detalhes sobre como fazer isso, consulte [Conectar-se à instância de banco de dados do Microsoft SQL Server](USER_ConnectToMicrosoftSQLServerInstance.md).
1. No **Object Explorer (Navegador de objetos)**, expanda **Databases (Bancos de dados)**, abra o menu de contexto (botão direito do mouse) para o banco de dados de origem, escolha **Tasks (Tarefas)** e depois escolha **Export Data (Exportar dados)**. O assistente é exibido.
1. Na página **Choose a Data Source (Selecionar uma fonte de dados)**, faça o seguinte:
1. Em **Data source (Fonte de dados)**, selecione **SQL Server Native Client 11.0**.
1. Verifique se o campo **Server name** (Nome do servidor) mostra o endpoint da sua instância de banco de dados RDS for SQL Server.
1. Selecione **Use SQL Server Authentication (Usar autenticação do SQL Server)**. Em **User name** (Nome do usuário) e **Password** (Senha), digite o nome do usuário mestre e a senha da instância do banco de dados.
1. Verifique se a caixa **Database (Banco de dados)** mostra o banco de dados a partir do qual você deseja exportar dados.
1. Escolha **Next (Próximo)**.
1. Na página **Choose a Destination (Selecionar um destino)**, faça o seguinte:
1. Em **Destination (Destino)**, selecione **SQL Server Native Client 11.0**.
**nota**
Outras fontes de dados de destino estão disponíveis. Elas incluem provedores de dados .NET Framework, provedor de banco de dados OLE, provedores SQL Server Native Client, provedores ADO.NET, Microsoft Office Excel, Microsoft Office Access e a origem de arquivo simples. Se você optar por uma dessas fontes de dados, ignore o restante da etapa 4. Para obter detalhes sobre as informações de conexão a serem fornecidas a seguir, consulte [Escolher um destino](http://msdn.microsoft.com/en-us/library/ms178430%28v=sql.110%29.aspx), na documentação do SQL Server.
1. Para **Server name (Nome do servidor)**, digite o nome do servidor da instância de banco de dados SQL Server de destino.
1. Escolha o tipo de autenticação apropriado. Digite um nome de usuário e uma senha, se necessário.
1. Para **Database (Banco de dados)**, escolha o nome do banco de dados de destino ou escolha **New (Novo)** para criar um novo banco de dados para conter os dados exportados.
Se você escolher **New (Novo)**, consulte [Criar um banco de dados](http://msdn.microsoft.com/en-us/library/ms183323%28v=sql.110%29.aspx), na documentação do SQL Server, para obter detalhes sobre as informações de banco de dados que devem ser fornecidas.
1. Escolha **Next (Próximo)**.
1. Na página **Table Copy or Query (Cópia ou consulta da tabela)**, escolha **Copy data from one or more tables or views (Copiar dados de uma ou mais tabelas ou visualizações)** ou **Write a query to specify the data to transfer (Gravar uma consulta para especificar os dados a serem transferidos)**. Escolha **Next (Próximo)**.
1. Se você escolher **Write a query to specify the data to transfer (Gravar uma consulta para especificar os dados a serem transferidos)**, verá a página **Provide a Source Query (Fornecer uma consulta da fonte)**. Digite ou cole uma consulta SQL e escolha **Parse (Analisar)** para verificá-la. Quando a consulta for validada, escolha **Next (Próximo)**.
1. Na página **Select Source Tables and Views (Selecionar tabelas e visualizações da fonte)**, faça o seguinte:
1. Selecione as tabelas e as visualizações que você deseja exportar ou verifique se a consulta fornecida está selecionada.
1. Escolha **Edit Mappings (Editar mapeamentos)** e especifique informações de mapeamento de banco de dados e colunas. Para obter mais informações, consulte [Mapeamentos de colunas](http://msdn.microsoft.com/en-us/library/ms189660%28v=sql.110%29.aspx) na documentação do SQL Server.
1. (Opcional) Para ver uma visualização dos dados a serem exportados, selecione a tabela, exibição ou consulta e escolha **Preview (Visualizar)**.
1. Escolha **Next (Próximo)**.
1. Na página **Run Package (Executar pacote)**, verifique se a opção **Run immediately (Executar imediatamente)** está selecionada. Escolha **Next (Próximo)**.
1. Na página **Complete the Wizard (Concluir o assistente)**, verifique se os detalhes da exportação de dados são os esperados. Escolha **Terminar**.
1. Na página **The execution was successful (A execução foi bem-sucedida)**, escolha **Close (Fechar)**.
### Utilitário bcp e Assistente para gerar e publicar scripts do SQL Server
Você pode usar o Assistente para gerar e publicar scripts do SQL Server para criar scripts para um banco de dados inteiro ou apenas para objetos selecionados. Você pode executar esses scripts em uma instância de banco de dados SQL Server de destino para recriar os objetos com scripts. Em seguida, você pode usar o utilitário bcp para exportar em massa os dados dos objetos selecionados para a instância do banco de dados de destino. Essa escolha será melhor se você quiser mover um banco de dados inteiro (incluindo objetos que não sejam tabelas) ou grandes quantidades de dados entre duas instâncias de bancos de dados SQL Server. Para obter uma descrição completa da sintaxe da linha de comando do bcp, consulte [Utilitário bcp](http://msdn.microsoft.com/en-us/library/ms162802%28v=sql.110%29.aspx) na documentação do Microsoft SQL Server.
O Assistente para gerar e publicar scripts do SQL Server está disponível como parte do Microsoft SQL Server Management Studio. Esse cliente SQL Server gráfico está incluído em todas as edições do Microsoft SQL Server, exceto a Express Edition. O SQL Server Management Studio está disponível apenas como um aplicativo baseado no Windows. O SQL Server Management Studio Express está disponível na Microsoft como [download gratuito](http://www.microsoft.com/en-us/search/Results.aspx?q=sql%20server%20management%20studio).
**Para usar o Assistente para gerar e publicar scripts e o utilitário bcp do SQL Server para exportar dados**
1. No SQL Server Management Studio, conecte-se à sua instância de banco de dados do RDS for SQL Server. Para obter detalhes sobre como fazer isso, consulte [Conectar-se à instância de banco de dados do Microsoft SQL Server](USER_ConnectToMicrosoftSQLServerInstance.md).
1. No **Object Explorer (Navegador de objetos)**, expanda o nó **Databases (Bancos de dados)** e selecione o banco de dados para o qual você deseja definir um script.
1. Siga as instruções do [Assistente para gerar e publicar scripts](http://msdn.microsoft.com/en-us/library/bb895179%28v=sql.110%29.aspx) na documentação do SQL Server para criar um arquivo de script.
1. No SQL Server Management Studio, conecte-se à sua instância de banco de dados SQL Server de destino.
1. Com a instância de banco de dados SQL Server de destino selecionada no **Object Explorer** (Navegador de objetos), escolha **Open** (Abrir) no menu **File** (Arquivo), escolha **File** (Arquivo) e abra o arquivo de script.
1. Se você tiver definido um script para o banco de dados inteiro, reveja a instrução CREATE DATABASE no script. Certifique-se de que o banco de dados esteja sendo criado no local e com os parâmetros desejados. Para obter mais informações, consulte [CREATE DATABASE](http://msdn.microsoft.com/en-us/library/ms176061%28v=sql.110%29.aspx) na documentação do SQL Server.
1. Se você estiver criando usuários de banco de dados no script, verifique se há logins no servidor na instância de banco de dados de destino para esses usuários. Caso contrário, crie logins para esses usuários. Os comandos com scripts para criar os usuários do banco de dados falharão de outra forma. Para obter mais informações, consulte [Criar um login](http://msdn.microsoft.com/en-us/library/aa337562%28v=sql.110%29.aspx) na documentação do SQL Server.
1. Escolha **\$1Execute** no menu do SQL Editor para executar o arquivo de script e criar os objetos do banco de dados. Quando o script terminar, verifique se todos os objetos de banco de dados existem conforme o esperado.
1. Use o utilitário bcp para exportar dados da instância de banco de dados do RDS for SQL Server em arquivos. Abra um prompt de comando e digite o seguinte comando.
```
bcp database_name.schema_name.table_name out data_file -n -S aws_rds_sql_endpoint -U username -P password
```
O código anterior inclui as seguintes opções:
+ *table\$1name* é o nome de uma das tabelas criadas no banco de dados de destino e agora deseja preencher com dados.
+ *data\$1file* é o caminho completo e o nome do arquivo de dados a ser criado.
+ `-n` especifica que a cópia em massa usa os tipos de dados nativos dos dados a serem copiados.
+ `-S` especifica a instância de banco de dados SQL Server da qual exportar.
+ `-U` especifica o nome de usuário a ser usado ao se conectar à instância de banco de dados do SQL Server.
+ `-P` especifica a senha para o usuário especificada por `-U`.
O seguinte mostra um exemplo de comando .
```
bcp world.dbo.city out C:\Users\JohnDoe\city.dat -n -S sql-jdoe.1234abcd.us-west-2.rds.amazonaws.com,1433 -U JohnDoe -P ClearTextPassword
```
Repita essa etapa até ter arquivos de dados para todas as tabelas que você deseja exportar.
1. Prepare sua instância de banco de dados de destino para importação em massa de dados, seguindo as instruções em [Diretrizes básicas para dados de importação em massa](http://msdn.microsoft.com/en-us/library/ms189989%28v=sql.110%29.aspx), na documentação do SQL Server.
1. Escolha um método de importação em massa a ser usado depois de considerar a performance e outras preocupações discutidas no tópico [Sobre operações de importação e exportação em massa](http://msdn.microsoft.com/en-us/library/ms187042%28v=sql.105%29.aspx), na documentação do SQL Server.
1. Faça uma importação em massa dos dados dos arquivos de dados criados usando o utilitário bcp. Para fazer isso, siga as instruções em [Importar e exportar dados em massa usando o bcp (SQL Server)](http://msdn.microsoft.com/en-us/library/aa337544%28v=sql.110%29.aspx) ou em [Usar BULK INSERT ou OPENROWSET(BULK...) para importar dados para o SQL Server](http://msdn.microsoft.com/en-us/library/ms175915%28v=sql.110%29.aspx), na documentação do SQL Server, dependendo do que você decidiu na etapa 11.
# Usar o utilitário BCP do Linux para importar e exportar dados
O utilitário BCP (Bulk Copy Program) oferece uma maneira eficiente de transferir grandes quantidades de dados entre a instância de banco de dados do RDS para SQL Server e os arquivos de dados. Você pode usar o BCP em ambientes Linux para realizar operações de dados em massa, o que o torna útil para migração de dados, processos de ETL e transferências regulares de dados.
O BCP permite a importação de dados de arquivos para tabelas do SQL Server e a exportação de dados de tabelas do SQL Server para arquivos. Isso é particularmente eficaz para transferir dados estruturados em vários formatos, inclusive arquivos de texto delimitados.
## Pré-requisitos
Antes de usar o BCP com uma instância de banco de dados do RDS para SQL Server usando o Linux, verifique se você tem o seguinte:
+ Um ambiente Linux com conectividade de rede à instância de banco de dados do RDS para SQL Server.
+ Ferramentas de linha de comandos do Microsoft SQL Server instaladas no sistema Linux, como:
+ sqlcmd: ferramenta de consulta de linha de comandos do SQL Server
+ bcp: utilitário Bulk Copy Program
+ Credenciais válidas para a instância de banco de dados do RDS para SQL Server.
+ Acesso à rede configurado por meio de grupos de segurança para permitir conexões na porta do SQL Server (normalmente 1433).
+ Permissões de banco de dados apropriadas para as operações que você deseja realizar.
## Instalar ferramentas de linha de comandos do SQL Server no Linux
Para usar o BCP no Linux, você precisa instalar as ferramentas de linha de comandos do Microsoft SQL Server. Para obter instruções detalhadas sobre instalação para sua distribuição Linux específica, consulte a seguinte documentação da Microsoft:
+ [Install sqlcmd and bcp the SQL Server command-line tools on Linux](https://docs.microsoft.com/en-us/sql/linux/sql-server-linux-setup-tools)
+ [bcp utility](https://docs.microsoft.com/en-us/sql/tools/bcp-utility): referência completa para o utilitário BCP
Após a instalação, confirme se as ferramentas estão disponíveis em seu PATH executando:
```
bcp -v
sqlcmd -?
```
## Exportar dados do RDS para SQL Server
Você pode usar o BCP para exportar dados da instância de banco de dados do RDS para SQL Server para arquivos no sistema Linux. Isso é útil para criar backups, analisar dados ou preparar dados para migração.
### Sintaxe básica de exportação
A sintaxe básica para exportar dados usando o BCP é:
```
bcp database.schema.table out output_file -S server_name -U username -P password [options]
```
Em que:
+ `database.schema.table`: o nome totalmente qualificado da tabela.
+ `output_file`: o caminho e o nome do arquivo de saída.
+ `server_name`: o endpoint do RDS para SQL Server.
+ `username`: o nome de usuário do banco de dados.
+ `password`: a senha do banco de dados.
### Exemplo de exportação
O seguinte exemplo exporta dados de uma tabela denominada `customers` no banco de dados `sales`:
```
bcp sales.dbo.customers out /home/user/customers.txt \
-S mydb.cluster-abc123.us-east-1.rds.amazonaws.com \
-U admin \
-P mypassword \
-c \
-t "|" \
-r "\n"
```
Esse comando:
+ Exporta dados da tabela `customers`.
+ Salva a saída de `/home/user/customers.txt`.
+ Usa o formato de caracteres (`-c`).
+ Usa pipe (\$1) como delimitador de campo (`-t "|"`).
+ Usa nova linha como delimitador de linha (`-r "\n"`).
## Importar dados para o RDS para SQL Server
Você pode usar o BCP para exportar dados de arquivos em seu sistema Linux para sua instância de banco de dados do RDS para SQL Server. Isso é útil para migração de dados, carregamento de dados de teste ou atualizações regulares de dados.
### Sintaxe básica de importação
A sintaxe básica para exportar dados usando o BCP é:
```
bcp database.schema.table in input_file -S server_name -U username -P password [options]
```
Em que:
+ `database.schema.table`: o nome totalmente qualificado da tabela de destino.
+ `input_file`: o caminho e o nome do arquivo de entrada.
+ `server_name`: o endpoint do RDS para SQL Server.
+ `username`: o nome de usuário do banco de dados.
+ `password`: a senha do banco de dados.
### Exemplo de importação
O seguinte exemplo importa dados de um arquivo para uma tabela denominada `customers`:
```
bcp sales.dbo.customers in /home/user/customers.txt \
-S mydb.cluster-abc123.us-east-1.rds.amazonaws.com \
-U admin \
-P mypassword \
-c \
-t "|" \
-r "\n" \
-b 1000
```
Esse comando:
+ Importa dados para a tabela `customers`.
+ Lê os dados do `/home/user/customers.txt`
+ Usa o formato de caracteres (`-c`).
+ Usa pipe (\$1) como delimitador de campo (`-t "|"`).
+ Usa nova linha como delimitador de linha (`-r "\n"`).
+ Processa dados em lotes de mil linhas (`-b 1000`).
## Opções comuns do BCP
O BCP oferece várias opções para controlar a formatação de dados e o comportamento de transferência. A seguinte tabela descreve as opções comumente usadas:
| Opção | Descrição |
| --- | --- |
| -c | Usa o tipo de dados de caracteres para todas as colunas. |
| -n | Usa tipos de dados de banco de dados nativos. |
| -t | Especifica o delimitador de campo (o padrão é tab). |
| -r | Especifica o delimitador de linha (o padrão é nova linha). |
| -b | Especifica o tamanho do lote para operações em massa. |
| -F | Especifica a primeira linha a ser exportada ou importada. |
| -L | Especifica a última linha a ser exportada ou importada. |
| -e | Especifica um arquivo de erro para capturar linhas rejeitadas. |
| -f | Especifica um arquivo de formato para formatação de dados. |
| -q | Usa identificadores entre aspas para nomes de objeto. |
## Práticas recomendadas e considerações
Ao usar o BCP com o RDS para SQL Server no Linux, considere as seguintes práticas recomendadas:
+ **Use o processamento em lote**: para grandes conjuntos de dados, use a opção `-b` para processar dados em lote. Isso melhora o desempenho e permite uma recuperação de erros mais apropriada.
+ **Lide com erros adequadamente**: use a opção `-e` para capturar informações de erros e linhas rejeitadas em um arquivo separado para análise.
+ **Escolha os formatos de dados apropriados**: use o formato de caracteres (`-c`) para compatibilidade entre plataformas ou o formato nativo (`-n`) para melhorar desempenho quando a origem e o destino forem o SQL Server.
+ **Proteja suas credenciais**: evite colocar senhas diretamente nas linhas de comandos. Considere a possibilidade de usar variáveis de ambiente ou arquivos de configuração com as permissões apropriadas.
+ **Teste com conjuntos de dados pequenos**: antes de processar grandes quantidades de dados, teste seus comandos do BCP com conjuntos de dados menores para verificar a formatação e a conectividade.
+ **Monitore a conectividade de rede**: garanta conexões de rede estáveis, especialmente para grandes transferências de dados. Considere a possibilidade de usar ferramentas como `screen` ou `tmux` para operações de longa duração.
+ **Valide a integridade dos dados**: após a transferência de dados, verifique as contagens de linhas e os dados de amostra para garantir que a operação foi concluída com êxito.
## Solução de problemas comuns do
A seguinte tabela descreve os problemas comuns que você pode encontrar ao usar o BCP no Linux e as respectivas soluções:
| Problema | Solução |
| --- | --- |
| Tempo limite de conexão ou erros de rede | Verifique seu endpoint do Amazon RDS, as configurações do grupo de segurança e a conectividade de rede. Confirme se a porta do SQL Server (normalmente 1433) pode ser acessada pelo seu sistema Linux. |
| Falhas de autenticação | Anote seu nome de usuário e senha. Verifique se o usuário do banco de dados tem as permissões apropriadas para as operações que você está executando. |
| Erros de formato de dados | Verifique seus delimitadores de campo e linha. Confirme se o formato dos dados corresponde ao que o BCP espera. Use arquivos de formato para estruturas de dados complexas. |
| Erros de permissão negada | Verifique se o usuário do banco de dados tem permissões INSERT para importações ou permissões SELECT para exportações nas tabelas de destino. |
| Problemas de tratamento de arquivos grandes | Use o processamento em lote com a opção -b. Considere a possibilidade de dividir arquivos grandes em partes menores para melhorar o desempenho e a recuperação de erros. |
| Problemas de codificação de caracteres | Garanta que seus arquivos de dados usem uma codificação de caracteres compatível. Use a opção -c para o formato de caracteres ou especifique as páginas de código apropriadas. |