`. O RDS oferece suporte a caminhos absolutos e relativos. Se você deseja criar uma subpasta, inclua-a no caminho do arquivo. |
| `@overwrite_file` | INT | 0 | Optional | Substitua o arquivo existente: 0 = não substituir 1 = substituir |
É possível baixar arquivos sem uma extensão de arquivo e arquivos com as seguintes extensões: .bcp, .csv, .dat, .fmt, .info, .lst, .tbl, .txt e .xml.
**nota**
Arquivos com a extensão .ispac são têm suporte para download quando o SQL Server Integration Services está habilitado. Para obter mais informações sobre como habilitar o SSIS, consulte [SQL Server Integration Services](Appendix.SQLServer.Options.SSIS.md).
Arquivos com as seguintes extensões têm suporte para download quando o SQL Server Analysis Services está habilitado: .abf, .asdatabase, .configsettings, .deploymentoptions, .deploymenttargets e .xmla. Para obter mais informações sobre como habilitar o SSAS, consulte [SQL Server Analysis Services](Appendix.SQLServer.Options.SSAS.md).
O exemplo a seguir mostra o procedimento armazenado para baixar arquivos do S3.
```
exec msdb.dbo.rds_download_from_s3
@s3_arn_of_file='arn:aws:s3:::amzn-s3-demo-bucket/bulk_data.csv',
@rds_file_path='D:\S3\seed_data\data.csv',
@overwrite_file=1;
```
A operação de exemplo `rds_download_from_s3` cria uma pasta chamada `seed_data` em `D:\S3\`, se a pasta não existir ainda. Depois disso, o exemplo baixa o arquivo de origem `bulk_data.csv` do S3 para um novo arquivo chamado `data.csv` na instância de banco de dados. Se o arquivo existia anteriormente, ele será substituído porque o parâmetro `@overwrite_file` está definido como `1`.
## Fazer upload de arquivos de uma instância de banco de dados SQL Server para um bucket do Amazon S3
Para fazer upload de arquivos de uma instância de banco de dados do RDS for SQL Server para um bucket do S3, use o procedimento armazenado do Amazon RDS `msdb.dbo.rds_upload_to_s3` com os parâmetros a seguir.
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `@s3_arn_of_file` | NVARCHAR | – | Obrigatório | O ARN do S3 do arquivo a ser criado no S3, por exemplo: `arn:aws:s3:::amzn-s3-demo-bucket/mydata.csv` |
| `@rds_file_path` | NVARCHAR | – | Obrigatório | O caminho de arquivo do arquivo para fazer upload no S3. Caminhos relativos e absolutos têm suporte. |
| `@overwrite_file` | INT | – | Optional | Substitua o arquivo existente: 0 = não substituir 1 = substituir |
O exemplo a seguir faz upload do arquivo chamado `data.csv` do local especificado em `D:\S3\seed_data\` para um arquivo `new_data.csv` no bucket do S3 especificado pelo ARN.
```
exec msdb.dbo.rds_upload_to_s3
@rds_file_path='D:\S3\seed_data\data.csv',
@s3_arn_of_file='arn:aws:s3:::amzn-s3-demo-bucket/new_data.csv',
@overwrite_file=1;
```
Se o arquivo existia antes no S3, ele será substituído porque o parâmetro @overwrite\$1file está definido como `1`.
# Listar arquivos na instância de banco de dados do RDS
Para listar os arquivos disponíveis na instância de banco de dados, use a função e o procedimento armazenado. Primeiro, execute o seguinte procedimento armazenado para coletar detalhes de arquivo dos arquivos em `D:\S3\`.
```
exec msdb.dbo.rds_gather_file_details;
```
O procedimento armazenado retorna o ID da tarefa. Assim como outras tarefas, esse procedimento armazenado é executado de forma assíncrona. Assim que o status da tarefa for `SUCCESS`, é possível usar o ID da tarefa na função `rds_fn_list_file_details` para listar os diretórios e arquivos existentes em D:\$1S3\$1, conforme mostrado a seguir.
```
SELECT * FROM msdb.dbo.rds_fn_list_file_details(TASK_ID);
```
A função `rds_fn_list_file_details` exibe uma tabela com as colunas a seguir.
| Parâmetro de saída | Descrição |
| --- | --- |
| filepath | Caminho absoluto do arquivo (por exemplo, D:\$1S3\$1mydata.csv) |
| size\$1in\$1bytes | Tamanho do arquivo (em bytes) |
| last\$1modified\$1utc | A data e a hora da última modificação em formato UTC |
| is\$1directory | Opção que indica se o item é um diretório (true/false) |
# Excluir arquivos na instância de banco de dados do RDS
Para excluir os arquivos disponíveis na instância de banco de dados, use o procedimento armazenado do Amazon RDS `msdb.dbo.rds_delete_from_filesystem` com os seguintes parâmetros.
| Nome do parâmetro | Tipo de dados | Padrão | Obrigatório | Descrição |
| --- | --- | --- | --- | --- |
| `@rds_file_path` | NVARCHAR | – | Obrigatório | O caminho de arquivo do arquivo a ser excluído. Caminhos relativos e absolutos têm suporte. |
| `@force_delete` | INT | 0 | Optional | Para excluir um diretório, este sinalizador deve ser incluído e definido como `1`. `1` = excluir um diretório Este parâmetro será ignorado se você estiver excluindo um arquivo. |
Para excluir um diretório, o `@rds_file_path` deve terminar com uma barra invertida (`\`), e `@force_delete` deve ser definido como `1`.
O exemplo a seguir exclui o arquivo `D:\S3\delete_me.txt`.
```
exec msdb.dbo.rds_delete_from_filesystem
@rds_file_path='D:\S3\delete_me.txt';
```
O exemplo a seguir exclui o diretório `D:\S3\example_folder\`.
```
exec msdb.dbo.rds_delete_from_filesystem
@rds_file_path='D:\S3\example_folder\',
@force_delete=1;
```
# Monitorar o status de uma tarefa de transferência de arquivo
Para rastrear o status da tarefa de integração do S3, chame a função `rds_fn_task_status`. Ela leva dois parâmetros. O primeiro parâmetro sempre deve ser `NULL` porque não se aplica à integração do S3. O segundo parâmetro aceita um ID de tarefa.
Para ver uma lista de todas as tarefas, defina o primeiro parâmetro como `NULL` e o segundo parâmetro como `0`, conforme mostrado no seguinte exemplo.
```
SELECT * FROM msdb.dbo.rds_fn_task_status(NULL,0);
```
Para obter uma tarefa específica, defina o primeiro parâmetro como `NULL` e o segundo parâmetro como o ID da tarefa, conforme mostrado no exemplo a seguir.
```
SELECT * FROM msdb.dbo.rds_fn_task_status(NULL,42);
```
A função `rds_fn_task_status` retorna as informações a seguir.
| Parâmetro de saída | Descrição |
| --- | --- |
| `task_id` | O ID da tarefa. |
| `task_type` | Para a integração do S3, as tarefas podem ter os seguintes tipos de tarefa: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/Appendix.SQLServer.Options.S3-integration.using.monitortasks.html) |
| `database_name` | Não aplicável a tarefas de integração do S3. |
| `% complete` | O progresso da tarefa em 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/Appendix.SQLServer.Options.S3-integration.using.monitortasks.html) |
| `task_info` | Informações adicionais sobre a tarefa. Se um erro ocorrer durante o processamento, essa coluna conterá informações sobre o erro. |
| `last_updated` | A data e hora em que o status da tarefa foi atualizado pela última vez. |
| `created_at` | A data e hora em que a tarefa foi criada. |
| `S3_object_arn` | O ARN do objeto do S3 baixado ou carregado. |
| `overwrite_S3_backup_file` | Não aplicável a tarefas de integração do S3. |
| `KMS_master_key_arn` | Não aplicável a tarefas de integração do S3. |
| `filepath` | O caminho de arquivo na instância de banco de dados do RDS |
| `overwrite_file` | Uma opção que indica se um arquivo existente foi substituído. |
| `task_metadata` | Não aplicável a tarefas de integração do S3. |
# Cancelar uma tarefa
Para cancelar tarefas de integração do S3, use o procedimento armazenado `msdb.dbo.rds_cancel_task` com o parâmetro `task_id`. Tarefas de listagem e exclusão que estão em progresso não podem ser canceladas. O exemplo a seguir mostra uma solicitação para cancelar uma tarefa.
```
exec msdb.dbo.rds_cancel_task @task_id = 1234;
```
Para obter uma visão geral de todas as tarefas e seus IDs de tarefa, use a função `rds_fn_task_status` conforme descrito em [Monitorar o status de uma tarefa de transferência de arquivo](Appendix.SQLServer.Options.S3-integration.using.monitortasks.md).
## Limitações Multi-AZ para a integração do S3
Em instâncias Multi-AZ, os arquivos na pasta `D:\S3` são excluídos na réplica em espera após um failover. Um failover pode ser planejado, por exemplo, durante modificações de instâncias de banco de dados, como alterar a classe de instância ou atualizar a versão do mecanismo. Ou um failover pode ser não planejado, durante uma interrupção do principal.
**nota**
Não recomendamos usar a pasta `D:\S3` para armazenamento de arquivos. A prática recomendada é carregar arquivos criados no Amazon S3 para torná-los duráveis e baixar arquivos quando precisar importar dados.
Para determinar o último tempo de failover, é possível usar o procedimento `msdb.dbo.rds_failover_time` armazenado. Para obter mais informações, consulte [Determinar o horário do último failover do Amazon RDS para SQL Server](Appendix.SQLServer.CommonDBATasks.LastFailover.md).
**Example de nenhum failover recente**
Este exemplo mostra a saída quando não há nenhum failover recente nos logs de erros. Nenhum failover aconteceu desde 29-04-2020 23:59:00.01.
Portanto, todos os arquivos baixados após esse horário que não foram excluídos usando o procedimento `rds_delete_from_filesystem` armazenado ainda estão acessíveis no host atual. Arquivos baixados antes desse horário também podem estar disponíveis.
| errorlog\$1available\$1from | recent\$1failover\$1time |
| --- | --- |
| 29-04-2020 23:59:00.0100000 | nulo |
**Example de failover recente**
Este exemplo mostra a saída quando há um failover nos logs de erros. O failover mais recente foi em 05-05-2020 18:57:51.89.
Todos os arquivos baixados após esse horário que não foram excluídos usando o procedimento `rds_delete_from_filesystem` armazenado ainda estão acessíveis no host atual.
| errorlog\$1available\$1from | recent\$1failover\$1time |
| --- | --- |
| 29-04-2020 23:59:00.0100000 | 05-05-2020 18:57:51.8900000 |
# Desabilitação da integração do RDS for SQL Server com o S3
A seguir, é possível saber como desabilitar a integração do Amazon S3 com o Amazon RDS for SQL Server. Os arquivos em `D:\S3\` não são excluídos ao desabilitar a integração do S3.
**nota**
Para remover uma função do IAM de uma instância de banco de dados, o status da instância de banco de dados deve ser `available`.
## Console
**Como desassociar uma função do IAM da instância de banco de dados**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon RDS em [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Escolha o nome da instância de banco de dados do RDS for SQL Server para exibir seus detalhes.
1. Na guia **Connectivity & security (Conectividade e segurança)**, na seção **Manage IAM roles (Gerenciar funções do IAM)**, escolha a função do IAM a ser removida.
1. Escolha **Excluir**.
## AWS CLI
**Para remover a função do IAM da instância de banco de dados do RDS for SQL Server**
+ O seguinte comando da AWS CLI remove a função do IAM de uma instância de banco de dados do RDS for SQL Server chamada `mydbinstance`.
**Example**
Para Linux, macOS ou Unix:
```
aws rds remove-role-from-db-instance \
--db-instance-identifier mydbinstance \
--feature-name S3_INTEGRATION \
--role-arn your-role-arn
```
Para Windows:
```
aws rds remove-role-from-db-instance ^
--db-instance-identifier mydbinstance ^
--feature-name S3_INTEGRATION ^
--role-arn your-role-arn
```
Substitua `your-role-arn` pelo ARN adequado da função do IAM para a opção `--feature-name`.
# Usar o Database Mail no Amazon RDS for SQL Server
Você pode usar o Database Mail para enviar mensagens de e-mail aos usuários a partir da instância de banco de dados do Amazon RDS no SQL Server. As mensagens podem conter arquivos e resultados de consultas. O Database Mail inclui os seguintes componentes:
+ Objetos de**configuração e segurança** – esses objetos criam perfis e contas e são armazenados no banco de dados `msdb`.
+ **Objetos de mensagens ** – esses objetos incluem o procedimento armazenado [sp\$1send\$1dbmail](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-send-dbmail-transact-sql) usado para enviar mensagens e estruturas de dados que contêm informações sobre mensagens. Eles estão armazenados no banco de dados `msdb`.
+ **Objetos de registro e auditoria** – o Database Mail grava informações de registro no banco de dados `msdb` e no log de eventos de aplicações do Microsoft Windows.
+ **Executável do Database Mail** – `DatabaseMail.exe` lê a partir de uma fila no banco de dados `msdb` e envia mensagens de e-mail.
O RDS oferece suporte ao Database Mail para todas as versões do SQL Server nas edições Web, Standard e Enterprise.
## Limitações
As seguintes limitações se aplicam ao uso do Database Mail em sua instância de banco de dados SQL Server:
+ O Database Mail não é compatível com o SQL Server Express Edition.
+ A modificação dos parâmetros de configuração do Database Mail não é aceita. Para ver os valores predefinidos (padrão), use o procedimento armazenado [sysmail\$1help\$1configure\$1sp](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-help-configure-sp-transact-sql) .
+ Os anexos de arquivo não são totalmente compatíveis. Para ter mais informações, consulte [Trabalhar com anexos de arquivos](#SQLServer.DBMail.Files).
+ O tamanho máximo do anexo do arquivo é de 1 MB.
+ O Database Mail requer configuração adicional em instâncias de banco de dados Multi-AZ. Para ter mais informações, consulte [Considerações para implantações Multi-AZ](#SQLServer.DBMail.MAZ).
+ Não há suporte para configurar o SQL Server Agent para enviar mensagens de email para operadores predefinidos.
# Habilitar Database Mail
Use o seguinte processo para habilitar o Database Mail para a instância de banco de dados:
1. Crie um novo parameter group.
1. Modifique o grupo de parâmetros para definir o parâmetro `database mail xps` como 1.
1. Associe o grupo de parâmetros à instância de banco de dados.
## Criar o grupo de parâmetros para o Database Mail
Crie um grupo de parâmetros para o parâmetro `database mail xps` que corresponde à edição e à versão do SQL Server da instância de banco de dados.
**nota**
Você também pode modificar um grupo de parâmetros existente. Siga o procedimento em [Modificar o parâmetro que habilita o Database Mail](#DBMail.ModifyParamGroup).
### Console
O exemplo a seguir cria um grupo de parâmetros para o SQL Server Standard Edition 2016.
**Como criar o grupo de parâmetros**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon RDS em [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. No painel de navegação, escolha **Parameter groups** (Grupos de parâmetros).
1. Escolha **Create parameter group (Criar parameter group)**.
1. No painel**Create parameter group (Criar parameter group)**, faça o seguinte:
1. Em **Família de grupos de parâmetros**, escolha **sqlserver-se-13.0**.
1. Em **Nome do grupo**, insira um identificador para o grupo de parâmetros, como **dbmail-sqlserver-se-13**.
1. Em **Descrição**, insira **Database Mail XPs**.
1. Escolha **Criar**.
### CLI
O exemplo a seguir cria um grupo de parâmetros para o SQL Server Standard Edition 2016.
**Como criar o grupo de parâmetros**
+ Use um dos seguintes comandos.
**Example**
Para Linux, macOS ou Unix:
```
aws rds create-db-parameter-group \
--db-parameter-group-name dbmail-sqlserver-se-13 \
--db-parameter-group-family "sqlserver-se-13.0" \
--description "Database Mail XPs"
```
Para Windows:
```
aws rds create-db-parameter-group ^
--db-parameter-group-name dbmail-sqlserver-se-13 ^
--db-parameter-group-family "sqlserver-se-13.0" ^
--description "Database Mail XPs"
```
## Modificar o parâmetro que habilita o Database Mail
Modifique o parâmetro `database mail xps` no grupo de parâmetros que corresponde à edição e à versão do SQL Server da instância de banco de dados.
Para habilitar o Database Mail, defina o parâmetro `database mail xps` como 1.
### Console
O exemplo a seguir modifica o grupo de parâmetros que você criou para o SQL Server Standard Edition 2016.
**Como modificar o grupo de parâmetros**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon RDS em [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. No painel de navegação, selecione **Parameter groups**.
1. Escolha o grupo de parâmetros, como **debmail-sqlserver-se-13**.
1. Em **Parâmetros**, filtre a lista de parâmetros para **mail**.
1. Escolha **xps de email de banco**de dados.
1. Escolha **Edit parameters**.
1. Digite **1**.
1. Selecione **Save changes**.
### CLI
O exemplo a seguir modifica o grupo de parâmetros que você criou para o SQL Server Standard Edition 2016.
**Como modificar o grupo de parâmetros**
+ Use um dos seguintes comandos.
**Example**
Para Linux, macOS ou Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name dbmail-sqlserver-se-13 \
--parameters "ParameterName='database mail xps',ParameterValue=1,ApplyMethod=immediate"
```
Para Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name dbmail-sqlserver-se-13 ^
--parameters "ParameterName='database mail xps',ParameterValue=1,ApplyMethod=immediate"
```
## Associar o grupo de parâmetros à instância de banco de dados
É possível usar o Console de gerenciamento da AWS ou a AWS CLI para associar o grupo de parâmetros do Database Mail à instância de banco de dados.
### Console
É possível associar o grupo de parâmetros do Database Mail a uma instância de banco de dados nova ou existente.
+ Para uma nova instância de banco de dados, associe-o ao executar a instância. Para ter mais informações, consulte [Criar uma instância de banco de dados do Amazon RDS](USER_CreateDBInstance.md).
+ Para uma instância de banco de dados existente, associe-o modificando a instância. Para ter mais informações, consulte [Modificar uma instância de banco de dados do Amazon RDS](Overview.DBInstance.Modifying.md).
### CLI
É possível associar o grupo de parâmetros do Database Mail a uma instância de banco de dados nova ou existente.
**Para criar uma instância de banco de dados com o grupo de parâmetros do Database Mail**
+ Especifique o mesmo tipo de mecanismo de banco de dados e a versão principal que você usou ao criar o grupo de parâmetros.
**Example**
Para Linux, macOS ou Unix:
```
aws rds create-db-instance \
--db-instance-identifier mydbinstance \
--db-instance-class db.m5.2xlarge \
--engine sqlserver-se \
--engine-version 13.00.5426.0.v1 \
--allocated-storage 100 \
--manage-master-user-password \
--master-username admin \
--storage-type gp2 \
--license-model li
--db-parameter-group-name dbmail-sqlserver-se-13
```
Para Windows:
```
aws rds create-db-instance ^
--db-instance-identifier mydbinstance ^
--db-instance-class db.m5.2xlarge ^
--engine sqlserver-se ^
--engine-version 13.00.5426.0.v1 ^
--allocated-storage 100 ^
--manage-master-user-password ^
--master-username admin ^
--storage-type gp2 ^
--license-model li ^
--db-parameter-group-name dbmail-sqlserver-se-13
```
**Para modificar uma instância de banco de dados e associar o grupo de parâmetros do Database Mail**
+ Use um dos seguintes comandos.
**Example**
Para Linux, macOS ou Unix:
```
aws rds modify-db-instance \
--db-instance-identifier mydbinstance \
--db-parameter-group-name dbmail-sqlserver-se-13 \
--apply-immediately
```
Para Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier mydbinstance ^
--db-parameter-group-name dbmail-sqlserver-se-13 ^
--apply-immediately
```
# Configurando o Correio do Banco
Execute as seguintes tarefas para configurar o Database Mail:
1. Crie o perfil do Database Mail.
1. Crie a conta Database Mail.
1. Adicione a conta de Correio do Banco de Dados ao perfil de Correio do Banco de Dados.
1. Adicione usuários ao perfil Database Mail.
**nota**
Para configurar o Database Mail, certifique-se de que você tem `execute` permissão nos procedimentos armazenados no `msdb` banco de dados.
## Criando o perfil de Correio de Banco de
Para criar o perfil Database Mail, use o procedimento armazenado [sysmail\$1add\$1profile\$1sp](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-profile-sp-transact-sql) . O exemplo a seguir cria um perfil chamado `Notifications`.
**Para criar o perfil**
+ Use a seguinte instrução SQL.
```
USE msdb
GO
EXECUTE msdb.dbo.sysmail_add_profile_sp
@profile_name = 'Notifications',
@description = 'Profile used for sending outgoing notifications using Amazon SES.';
GO
```
## Criando a conta Database Mail
Para criar a conta Database Mail, use o procedimento armazenado [sysmail\$1add\$1account\$1sp](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-account-sp-transact-sql) . O exemplo a seguir cria uma conta chamada `SES` em uma instância de banco de dados do RDS para SQL Server em uma VPC privada, usando o Amazon Simple Email Service.
O uso do Amazon SES requer os seguintes parâmetros:
+ `@email_address`: uma identidade verificada do Amazon SES. Para ter mais informações, consulte [Identidades verificadas no Amazon SES](https://docs.aws.amazon.com/ses/latest/dg/verify-addresses-and-domains.html).
+ `@mailserver_name`: um endpoint SMTP do Amazon SES. Para ter mais informações, consulte [Conexão a um endpoint SMTP do Amazon SES](https://docs.aws.amazon.com/ses/latest/dg/smtp-connect.html).
+ `@username`: um nome de usuário SMTP do Amazon SES. Para ter mais informações, consulte [Obtenção de credenciais SMTP do Amazon SES](https://docs.aws.amazon.com/ses/latest/dg/smtp-credentials.html).
Não use um nome de usuário do AWS Identity and Access Management.
+ `@password`: uma senha SMTP do Amazon SES. Para ter mais informações, consulte [Obtenção de credenciais SMTP do Amazon SES](https://docs.aws.amazon.com/ses/latest/dg/smtp-credentials.html).
**Para criar a conta**
+ Use a seguinte instrução SQL.
```
USE msdb
GO
EXECUTE msdb.dbo.sysmail_add_account_sp
@account_name = 'SES',
@description = 'Mail account for sending outgoing notifications.',
@email_address = 'nobody@example.com',
@display_name = 'Automated Mailer',
@mailserver_name = 'vpce-0a1b2c3d4e5f-01234567.email-smtp.us-west-2.vpce.amazonaws.com',
@port = 587,
@enable_ssl = 1,
@username = 'Smtp_Username',
@password = 'Smtp_Password';
GO
```
**nota**
Especifique credenciais diferentes dos prompts mostrados aqui como prática recomendada de segurança.
## Adicionar a conta do Database Mail ao perfil do Database Mail
Para adicionar a conta Database Mail ao perfil Database Mail, use o procedimento armazenado [sysmail\$1add\$1profileaccount\$1sp](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-profileaccount-sp-transact-sql). O exemplo a seguir adiciona a conta do `SES` ao perfil `Notifications`.
**Para adicionar a conta ao perfil**
+ Use a seguinte instrução SQL.
```
USE msdb
GO
EXECUTE msdb.dbo.sysmail_add_profileaccount_sp
@profile_name = 'Notifications',
@account_name = 'SES',
@sequence_number = 1;
GO
```
## Adicionar usuários ao perfil Database Mail
Para conceder permissão para que um principal do banco de dados `msdb` use um perfil do Database Mail, use o procedimento armazenado [sysmail\$1add\$1principalprofile\$1sp](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-principalprofile-sp-transact-sql). Um *principal* é uma entidade que pode solicitar recursos do SQL Server. O principal do banco de dados deve mapear para um usuário de autenticação do SQL Server, um usuário de Autenticação do Windows ou um grupo de autenticação do Windows.
O exemplo a seguir concede acesso público ao perfil `Notifications`.
**Para adicionar um usuário ao perfil**
+ Use a seguinte instrução SQL.
```
USE msdb
GO
EXECUTE msdb.dbo.sysmail_add_principalprofile_sp
@profile_name = 'Notifications',
@principal_name = 'public',
@is_default = 1;
GO
```
## Procedimentos armazenados e funções do Amazon RDS para o Database Mail
A Microsoft fornece [procedimentos armazenados](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/database-mail-stored-procedures-transact-sql) para usar o Database Mail, como criar, listar, atualizar e excluir contas e perfis. Além disso, o RDS fornece os procedimentos e funções armazenados para o Database Mail mostrados na tabela a seguir.
| Procedimento/Função | Descrição |
| --- | --- |
| rds\$1fn\$1sysmail\$1allitems | Mostra as mensagens enviadas, incluindo as enviadas por outros usuários. |
| rds\$1fn\$1sysmail\$1event\$1log | Mostra eventos, incluindo aqueles para mensagens enviadas por outros usuários. |
| rds\$1fn\$1sysmail\$1mailattachments | Mostra anexos, incluindo aqueles para mensagens enviadas por outros usuários. |
| rds\$1sysmail\$1control | Inicia e interrompe a fila de correio (processo DatabaseMail.exe). |
| rds\$1sysmail\$1delete\$1mailitems\$1sp | Exclui mensagens de e-mail enviadas por todos os usuários das tabelas internas do Database Mail. |
# Enviando mensagens de e-mail usando o Database
Use o procedimento armazenado [sp\$1send\$1dbmail](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-send-dbmail-transact-sql) para enviar mensagens de email usando o Database Mail.
## Usage
```
EXEC msdb.dbo.sp_send_dbmail
@profile_name = 'profile_name',
@recipients = 'recipient1@example.com[; recipient2; ... recipientn]',
@subject = 'subject',
@body = 'message_body',
[@body_format = 'HTML'],
[@file_attachments = 'file_path1; file_path2; ... file_pathn'],
[@query = 'SQL_query'],
[@attach_query_result_as_file = 0|1]';
```
Os seguintes parâmetros são obrigatórios:
+ `@profile_name` – o nome do perfil Database Mail a partir do qual enviar a mensagem.
+ `@recipients` – a lista delimitada por ponto e vírgula de endereços de e-mail para os quais enviar a mensagem.
+ `@subject` – o assunto da mensagem.
+ `@body` – o corpo da mensagem. Você também pode usar uma variável declarada como o corpo.
Os seguintes parâmetros são opcionais:
+ `@body_format` – esse parâmetro é usado com uma variável declarada para enviar e-mail em formato HTML.
+ `@file_attachments` – a lista delimitada por ponto e vírgula de anexos de mensagens. Os caminhos de arquivo devem ser caminhos absolutos.
+ `@query` – uma consulta SQL a ser executada. Os resultados da consulta podem ser anexados como um arquivo ou incluídos no corpo da mensagem.
+ `@attach_query_result_as_file` – Se deve anexar o resultado da consulta como um arquivo. Defina como 0 para não, 1 para sim. O padrão é 0.
## Exemplos
Os exemplos a seguir demonstram como enviar mensagens de e-mail.
**Example de enviar uma mensagem para um único destinatário**
```
USE msdb
GO
EXEC msdb.dbo.sp_send_dbmail
@profile_name = 'Notifications',
@recipients = 'nobody@example.com',
@subject = 'Automated DBMail message - 1',
@body = 'Database Mail configuration was successful.';
GO
```
**Example de enviar uma mensagem para vários destinatários**
```
USE msdb
GO
EXEC msdb.dbo.sp_send_dbmail
@profile_name = 'Notifications',
@recipients = 'recipient1@example.com;recipient2@example.com',
@subject = 'Automated DBMail message - 2',
@body = 'This is a message.';
GO
```
**Example de enviar um resultado de consulta SQL como um anexo de arquivo**
```
USE msdb
GO
EXEC msdb.dbo.sp_send_dbmail
@profile_name = 'Notifications',
@recipients = 'nobody@example.com',
@subject = 'Test SQL query',
@body = 'This is a SQL query test.',
@query = 'SELECT * FROM abc.dbo.test',
@attach_query_result_as_file = 1;
GO
```
**Example de enviar uma mensagem em formato HTML**
```
USE msdb
GO
DECLARE @HTML_Body as NVARCHAR(500) = 'Hi, Heading
See the report. Regards ';
EXEC msdb.dbo.sp_send_dbmail
@profile_name = 'Notifications',
@recipients = 'nobody@example.com',
@subject = 'Test HTML message',
@body = @HTML_Body,
@body_format = 'HTML';
GO
```
**Example de enviar uma mensagem usando um gatilho quando ocorre um evento específico no banco de dados**
```
USE AdventureWorks2017
GO
IF OBJECT_ID ('Production.iProductNotification', 'TR') IS NOT NULL
DROP TRIGGER Purchasing.iProductNotification
GO
CREATE TRIGGER iProductNotification ON Production.Product
FOR INSERT
AS
DECLARE @ProductInformation nvarchar(255);
SELECT
@ProductInformation = 'A new product, ' + Name + ', is now available for $' + CAST(StandardCost AS nvarchar(20)) + '!'
FROM INSERTED i;
EXEC msdb.dbo.sp_send_dbmail
@profile_name = 'Notifications',
@recipients = 'nobody@example.com',
@subject = 'New product information',
@body = @ProductInformation;
GO
```
# Visualizar mensagens, logs e anexos
Você usa procedimentos armazenados do RDS para visualizar mensagens, logs de eventos e anexos.
**Para visualizar todas as mensagens de e-mail**
+ Use a seguinte consulta SQL:
```
SELECT * FROM msdb.dbo.rds_fn_sysmail_allitems(); --WHERE sent_status='sent' or 'failed' or 'unsent'
```
**Para visualizar todos os logs de eventos de e-mail**
+ Use a seguinte consulta SQL:
```
SELECT * FROM msdb.dbo.rds_fn_sysmail_event_log();
```
**Para visualizar todos os anexos de e-mail**
+ Use a seguinte consulta SQL:
```
SELECT * FROM msdb.dbo.rds_fn_sysmail_mailattachments();
```
# Excluir mensagens
Use o procedimento armazenado `rds_sysmail_delete_mailitems_sp` para excluir mensagens.
**nota**
O RDS exclui automaticamente os itens da tabela de e-mail quando os dados do histórico do DBMail atingem 1 GB de tamanho, com um período de retenção de pelo menos 24 horas.
Se você quiser manter itens de e-mail por um período mais longo, poderá arquivá-los. Para ter mais informações, consulte [Create a SQL Server Agent Job to Archive Database Mail Messages and Event Logs](https://docs.microsoft.com/en-us/sql/relational-databases/database-mail/create-a-sql-server-agent-job-to-archive-database-mail-messages-and-event-logs) na documentação da Microsoft.
**Para excluir todas as mensagens de e-mail**
+ Use a seguinte instrução SQL.
```
DECLARE @GETDATE datetime
SET @GETDATE = GETDATE();
EXECUTE msdb.dbo.rds_sysmail_delete_mailitems_sp @sent_before = @GETDATE;
GO
```
**Para excluir todas as mensagens de e-mail com um status específico**
+ Use a seguinte instrução SQL para excluir todas as mensagens com falha.
```
DECLARE @GETDATE datetime
SET @GETDATE = GETDATE();
EXECUTE msdb.dbo.rds_sysmail_delete_mailitems_sp @sent_status = 'failed';
GO
```
# Iniciar e interromper a fila de e-mails
Use as seguintes instruções para iniciar e interromper a fila de e-mails de banco de dados:
**Topics**
+ [Iniciar a fila de e-mails](#SQLServer.DBMail.Start)
+ [Parar a fila de e-mails](#SQLServer.DBMail.Stop)
## Iniciar a fila de e-mails
Use o procedimento armazenado `rds_sysmail_control` para iniciar o processo Database Mail.
**nota**
A habilitação do Database Mail inicia automaticamente a fila de e-mails
**Para iniciar a fila de correio**
+ Use a seguinte instrução SQL.
```
EXECUTE msdb.dbo.rds_sysmail_control start;
GO
```
## Parar a fila de e-mails
Use o procedimento armazenado `rds_sysmail_control` para interromper o processo Database Mail.
**Para interromper a fila de e-mails**
+ Use a seguinte instrução SQL.
```
EXECUTE msdb.dbo.rds_sysmail_control stop;
GO
```
## Trabalhar com anexos de arquivos
As seguintes extensões de anexo de arquivo não são compatíveis com as mensagens do Database Mail do RDS no SQL Server: .ade, .adp, .apk, .appx, .appxbundle, .bat, .bak, .cab, .chm, .cmd, .com, .cpl, .dll, .dmg, .exe, .hta, .inf1, .ins, .isp, .iso, .jar, .job, .js, .jse, .ldf, .lib, .lnk, .mde, .mdf, .msc, .msi, .msix, .msixbundle, .msp, .mst, .nsh, .pif, .ps, .ps1, .psc1, .reg, .rgs, .scr, .sct, .shb, .shs, .svg, .sys, .u3p, .vb, .vbe, .vbs, .vbscript, .vxd, .ws,. sc, .wsf e .wsh.
O Database Mail usa o contexto de segurança do Microsoft Windows do usuário atual para controlar o acesso aos arquivos. Os usuários que fazem login com o SQL Server Authentication não podem anexar arquivos usando o parâmetro `@file_attachments` com o procedimento armazenado `sp_send_dbmail`. O Windows não permite que o SQL Server forneça credenciais de um computador remoto para outro computador remoto. Portanto, o Database Mail não pode anexar arquivos de um compartilhamento de rede quando o comando é executado a partir de um computador diferente do computador que esteja executando o SQL Server.
No entanto, você pode usar tarefas do SQL Server Agent para anexar arquivos. Para ter mais informações sobre o SQL Server Agent, consulte [Usar o agente do SQL Server para o Amazon RDS](Appendix.SQLServer.CommonDBATasks.Agent.md) e [SQL Server Agent](https://docs.microsoft.com/en-us/sql/ssms/agent/sql-server-agent) na documentação da Microsoft.
## Considerações para implantações Multi-AZ
Quando você configura o Database Mail em uma instância de banco de dados Multi-AZ, a configuração não é propagada automaticamente para o secundário. Recomendamos converter a instância Multi-AZ em uma instância Single-AZ, configurar o Database Mail e, em seguida, converter a instância de banco de dados de volta para Multi-AZ. Em seguida, os nós primário e secundário têm a configuração do Database Mail.
Se você criar uma réplica de leitura a partir da instância Multi-AZ que tenha o Database Mail configurado, a réplica herdará a configuração, mas sem a senha para o servidor SMTP. Atualize a conta Database Mail com a senha.
## Remover a restrição de SMTP (porta 25)
Por padrão, a AWS bloqueia o tráfego de saída no SMTP (porta 25) para instâncias de banco de dados do RDS para SQL Server. Isso é feito para evitar spam com base nas políticas do proprietário da interface de rede elástica. É possível remover essa restrição, se necessário. Consulte mais informações em [Como removo a restrição à porta 25 de uma instância do Amazon EC2 ou de uma função do Lambda?](https://repost.aws/knowledge-center/ec2-port-25-throttle)
# Suporte ao armazenamento de instâncias para o banco de dados tempdb no Amazon RDS for SQL Server
Um *armazenamento de instâncias* fornece armazenamento temporário em nível de bloco para a instância de banco de dados. Esse armazenamento está localizado em discos que estão anexados fisicamente ao computador host. Esses discos têm armazenamento de instância de memória expressa não volátil (NVMe) baseado em unidades de estado sólido (SSDs). Esse armazenamento é otimizado para baixa latência, performance de E/S aleatória muito alto e alta taxa de transferência de leitura sequencial.
Ao colocar arquivos de dados `tempdb` e arquivos de log `tempdb` no armazenamento de instâncias, você pode obter latências de leitura e gravação mais baixas em comparação com o armazenamento padrão com base no Amazon EBS.
**nota**
Os arquivos de banco de dados do SQL Server e de log do banco de dados não são colocados no armazenamento de instâncias.
## Habilitar o armazenamento de instâncias
Quando o RDS provisiona instâncias de banco de dados com um dos seguintes tipos de instância, o banco de dados `tempdb` é automaticamente colocado no armazenamento de instâncias:
+ db.m5d
+ db.r5d
+ db.x2iedn
Para habilitar o armazenamento de instâncias, siga um destes procedimentos:
+ Crie uma instância de banco de dados do SQL Server usando um desses tipos de instância. Para obter mais informações, consulte [Criar uma instância de banco de dados do Amazon RDS](USER_CreateDBInstance.md).
+ Modifique uma instância de banco de dados SQL Server existente para usar uma delas. Para obter mais informações, consulte [Modificar uma instância de banco de dados do Amazon RDS](Overview.DBInstance.Modifying.md).
O armazenamento de instâncias está disponível em todas as regiões da AWS onde um ou mais desses tipos de instância são compatíveis. Para obter mais informações sobre as classes de instância `db.m5d` e `db.r5d`, consulte [Classes de instâncias de banco de dados do ](Concepts.DBInstanceClass.md). Para obter mais informações sobre as classes de instância compatíveis pelo Amazon RDS for SQL Server, consulte [Suporte a classes de instâncias de banco de dados para o Microsoft SQL Server](SQLServer.Concepts.General.InstanceClasses.md).
## Considerações de localização e tamanho do arquivo
Em instâncias sem armazenamento de instâncias, o RDS armazena os arquivos de dados e de logs `tempdb` no diretório `D:\rdsdbdata\DATA`. Ambos os arquivos começam em 8 MB por padrão.
Em instâncias com um armazenamento de instâncias, o RDS armazena os arquivos de dados e de logs `tempdb` no diretório `T:\rdsdbdata\DATA`.
Quando `tempdb` tem apenas um arquivo de dados (`tempdb.mdf`) e um arquivo de log (`templog.ldf`), `templog.ldf` inicia em 8 MB por padrão e `tempdb.mdf` inicia em 80% ou mais da capacidade de armazenamento da instância. Vinte por cento da capacidade de armazenamento ou 200 GB, o que for menor, é mantido livre para começar. Múltiplos arquivos de dados `tempdb` dividem os 80% do espaço em disco uniformemente, enquanto os arquivos de log sempre têm um tamanho inicial de 8 MB.
Por exemplo, se você modificar sua classe de instância de banco de dados de `db.m5.2xlarge` para `db.m5d.2xlarge`, o tamanho dos arquivos de dados `tempdb` aumenta de 8 MB cada para 234 GB no total.
**nota**
Além dos arquivos de dados e de log `tempdb` no armazenamento de instâncias (`T:\rdsdbdata\DATA`), você ainda pode criar arquivos de dados e de log `tempdb` extras no volume de dados (`D:\rdsdbdata\DATA`). Esses arquivos sempre têm um tamanho inicial de 8 MB.
## Considerações sobre backup
Talvez seja necessário reter backups por longos períodos, incorrendo em custos ao longo do tempo. Os blocos de `tempdb` dados e log podem mudar muitas vezes dependendo da carga de trabalho. Isso pode aumentar consideravelmente o tamanho do snapshot de banco de dados.
Quando `tempdb` está no armazenamento de instâncias, os snapshots não incluem arquivos temporários. Isso significa que os tamanhos de snapshots são menores e consomem menos a alocação de backup gratuita em comparação com o armazenamento de somente EBS.
## Erros completos de disco
Se você usar todo o espaço disponível no armazenamento de instâncias, poderá receber erros como os seguintes:
+ O log de transações do banco de dados 'tempdb' está cheio devido a 'ACTIVE\$1TRANSACTION'.
+ Não foi possível alocar espaço para o objeto dbo.SORT temporary run storage: 140738941419520' no banco de dados 'tempdb' porque o grupo de arquivos 'PRIMÁRIO' está cheio. Crie espaço em disco excluindo arquivos desnecessários, soltando objetos no grupo de arquivos, adicionando arquivos adicionais ao grupo de arquivos ou definindo o crescimento automático para arquivos existentes no grupo de arquivos.
Você pode executar um ou mais dos procedimentos a seguir quando o armazenamento de instâncias estiver cheio:
+ Ajuste sua carga de trabalho ou a maneira como você usa `tempdb`.
+ Aumente a escala para usar uma classe de instância de banco de dados com mais armazenamento NVMe.
+ Pare de usar o armazenamento de instâncias e use uma classe de instância com apenas armazenamento do EBS.
+ Use um modo misto adicionando dados secundários ou arquivos de log para `tempdb` no volume do EBS.
## Remover o armazenamento de instâncias
Para remover o armazenamento de instâncias, modifique a instância de banco de dados do SQL Server para usar um tipo de instância que não comporte o armazenamento de instâncias como db.m5, db.r5 ou db.x1e.
**nota**
Quando você remove o armazenamento de instâncias, os arquivos temporários são movidos para o diretório `D:\rdsdbdata\DATA` e reduzidos em tamanho para 8 MB.
# Usar eventos estendidos com Amazon RDS for Microsoft SQL Server
Você pode usar eventos estendidos no Microsoft SQL Server para capturar informações de depuração e solucionar problemas do Amazon RDS for SQL Server. Os eventos estendidos substituem o SQL Trace e o Server Profiler, que foram defasados pela Microsoft. Os eventos estendidos são semelhantes aos traços do Profiler, mas com controle mais granular nos eventos que estão sendo monitorados. Os eventos estendidos são compatíveis com as versões 2016 do SQL Server e posteriores do Amazon RDS. Para obter mais informações, consulte [Visão geral de eventos estendidos](https://docs.microsoft.com/en-us/sql/relational-databases/extended-events/extended-events) na documentação da Microsoft.
Os eventos estendidos são ativados automaticamente para usuários com privilégios de usuário primário no Amazon RDS for SQL Server.
**Topics**
+ [Limitações e recomendações](#SQLServer.ExtendedEvents.Limits)
+ [Configuração de eventos estendidos no RDS for SQL Server](#SQLServer.ExtendedEvents.Config)
+ [Considerações para implantações Multi-AZ](#SQLServer.ExtendedEvents.MAZ)
+ [Consultando arquivos de eventos estendidos](#SQLServer.ExtendedEvents.Querying)
## Limitações e recomendações
Ao usar eventos estendidos do RDS for SQL Server, as seguintes limitações se aplicam:
+ Os eventos estendidos são compatíveis apenas com as Edições Enterprise e Standard.
+ Você não pode alterar as sessões de eventos estendidos padrão.
+ Defina o modo de partição de memória de sessão como `NONE`.
+ O modo de retenção de eventos de sessão pode ser `ALLOW_SINGLE_EVENT_LOSS` ou `ALLOW_MULTIPLE_EVENT_LOSS`.
+ Os destinos de monitoramento de eventos para Windows (ETW) não são compatíveis.
+ Verifique se os destinos dos arquivo estão no diretório `D:\rdsdbdata\log`.
+ Para alvos de correspondência de pares, defina a propriedade `respond_to_memory_pressure` como `1`.
+ A memória de destino do buffer de anel não pode ser maior que 4 MB.
+ As seguintes ações não são aceitas:
+ `debug_break`
+ `create_dump_all_threads`
+ `create_dump_single_threads`
+ O evento `rpc_completed` é compatível com as seguintes versões e posteriores: 15.0.4083.2, 14.0.3370.1, 13.0.5865.1, 12.0.6433.1, 11.0.7507.2
## Configuração de eventos estendidos no RDS for SQL Server
No RDS for SQL Server, você pode configurar os valores de determinados parâmetros de sessões de eventos estendidos. A tabela a seguir descreve os parâmetros configuráveis.
| Nome do parâmetro | Descrição | Valor padrão do RDS | Valor mínimo | Valor máximo |
| --- | --- | --- | --- | --- |
| xe\$1session\$1max\$1memory | Especifica a quantidade máxima de memória a ser alocada à sessão para buffer de eventos. Esse valor corresponde à configuração max\$1memory da sessão do evento. | 4 MB | 4 MB | 8 MB |
| xe\$1session\$1max\$1event\$1size | Especifica o tamanho máximo de memória permitido para eventos grandes. Esse valor corresponde à configuração max\$1event\$1size da sessão do evento. | 4 MB | 4 MB | 8 MB |
| xe\$1session\$1max\$1dispatch\$1latency | Especifica a quantidade de tempo em que os eventos são armazenados em buffer na memória antes de serem despachados para destinos de sessão de eventos estendidos. Esse valor corresponde à configuração max\$1dispatch\$1latency da sessão do evento. | 30 segundos | 1 segundo | 30 segundos |
| xe\$1file\$1target\$1size | Especifica o tamanho máximo do destino do arquivo. Esse valor corresponde à configuração max\$1file\$1size do destino do arquivo. | 100 MB | 10 MB | 1 GB |
| xe\$1file\$1retention | Especifica o tempo de retenção em dias para arquivos gerados pelos destinos de arquivo das sessões de evento. | 7 dias | 0 dias | 7 dias |
**nota**
Definir `xe_file_retention` como zero remove os arquivos.xel automaticamente depois que o bloqueio nesses arquivos é liberado pelo SQL Server. O bloqueio é liberado sempre que um arquivo.xel atinge o limite de tamanho definido em `xe_file_target_size`.
Você pode usar o procedimento `rdsadmin.dbo.rds_show_configuration` armazenado para mostrar os valores atuais desses parâmetros. Por exemplo, use a instrução SQL a seguir para visualizar a configuração atual do `xe_session_max_memory`.
```
exec rdsadmin.dbo.rds_show_configuration 'xe_session_max_memory'
```
Você pode usar o procedimento `rdsadmin.dbo.rds_set_configuration` armazenado para modificá-los. Por exemplo, use a instrução SQL `xe_session_max_memory` a seguir para definir como 4 MB.
```
exec rdsadmin.dbo.rds_set_configuration 'xe_session_max_memory', 4
```
## Considerações para implantações Multi-AZ
Quando você cria uma sessão de evento estendida em uma instância de banco de dados principal, ela não se propaga para a réplica em espera. Você pode fazer failover e criar a sessão de evento estendida na nova instância de banco de dados principal. Ou você pode remover e ler a configuração Multi-AZ para propagar a sessão de evento estendida para a réplica em espera. O RDS interrompe todas as sessões de evento estendidas não padrão na réplica em espera, de modo que essas sessões não consumam recursos no modo de espera. Por isso, depois que uma réplica em espera se tornar a instância de banco de dados principal, inicie manualmente as sessões de eventos estendidas no novo primário.
**nota**
Essa abordagem se aplica a grupos de disponibilidade sempre ativos e ao espelhamento do banco de dados.
Você também pode usar um trabalho do SQL Server Agent para monitorar a réplica em espera e iniciar as sessões se a espera se tornar a primária. Por exemplo, use a consulta a seguir na etapa de trabalho do SQL Server Agent para reiniciar sessões de evento em uma instância de banco de dados principal.
```
BEGIN
IF (DATABASEPROPERTYEX('rdsadmin','Updateability')='READ_WRITE'
AND DATABASEPROPERTYEX('rdsadmin','status')='ONLINE'
AND (DATABASEPROPERTYEX('rdsadmin','Collation') IS NOT NULL OR DATABASEPROPERTYEX('rdsadmin','IsAutoClose')=1)
)
BEGIN
IF NOT EXISTS (SELECT 1 FROM sys.dm_xe_sessions WHERE name='xe1')
ALTER EVENT SESSION xe1 ON SERVER STATE=START
IF NOT EXISTS (SELECT 1 FROM sys.dm_xe_sessions WHERE name='xe2')
ALTER EVENT SESSION xe2 ON SERVER STATE=START
END
END
```
Essa consulta reinicia as sessões de evento `xe1` e `xe2` em uma instância de banco de dados principal se essas sessões estiverem em um estado interrompido. Você também pode adicionar uma programação com um intervalo conveniente a essa consulta.
## Consultando arquivos de eventos estendidos
Você pode usar o SQL Server Management Studio ou a função `sys.fn_xe_file_target_read_file` para visualizar dados de eventos estendidos que usam destinos de arquivo. Para obter mais informações sobre essa função, consulte [sys.fn\$1xe\$1file\$1target\$1read\$1file (Transact-SQL)](https://docs.microsoft.com/en-us/sql/relational-databases/system-functions/sys-fn-xe-file-target-read-file-transact-sql) na documentação da Microsoft.
Destinos de arquivos de eventos estendidos só podem gravar arquivos no diretório `D:\rdsdbdata\log` no RDS para SQL Server.
Como exemplo, use a consulta SQL a seguir para listar o conteúdo de todos os arquivos de sessões de eventos estendidos cujos nomes começam com `xe`.
```
SELECT * FROM sys.fn_xe_file_target_read_file('d:\rdsdbdata\log\xe*', null,null,null);
```
# Acesso aos backups de logs de transações com o RDS para SQL Server
Com acesso aos backup de logs de transações do RDS para SQL Server, é possível listar os arquivos de log de transações de um banco de dados e copiá-los em um bucket de destino do Amazon S3. Ao copiar backups de logs de transações em um bucket do Amazon S3, você pode usá-los em combinação com backups de banco de dados completos e diferenciais para realizar restaurações do banco de dados a um ponto anterior no tempo. Use procedimentos armazenados no RDS para configurar o acesso aos backups de logs de transações, listar os backups de logs de transações disponíveis e copiá-los em seu bucket do Amazon S3.
O acesso aos backups de logs de transações fornece os seguintes recursos e benefícios:
+ Listar e visualizar os metadados dos backups de logs de transações disponíveis de um banco de dados em uma instância de banco de dados do RDS para SQL Server.
+ Copiar os backups de logs de transações disponíveis do RDS para SQL Server em um bucket de destino do Amazon S3.
+ Executar restaurações a um ponto anterior no tempo de bancos de dados sem a necessidade de restaurar uma instância de banco de dados inteira. Para obter informações sobre como restaurar uma instância de banco de dados, consulte [Restaurar uma instância de banco de dados para um momento especificado no Amazon RDS](USER_PIT.md).
## Disponibilidade e suporte
O acesso aos backups de logs de transações é compatível em todas as regiões.da AWS. O acesso a backups de logs de transações está disponível para todas as edições e versões do Microsoft SQL Server compatíveis com o Amazon RDS.
## Requisitos
Os requisitos a seguir devem ser atendidos antes de ativar o acesso aos backups de logs de transações:
+ Os backups automatizados devem ser ativados na instância de banco de dados e a retenção do backup deve ser definida como um valor de um ou mais dias. Para ter mais informações sobre como ativar backups automatizados e configurar uma política de retenção, consulte [Ativar backups automáticos](USER_WorkingWithAutomatedBackups.Enabling.md).
+ Um bucket do Amazon S3 deve existir na mesma conta e região da instância de banco de dados de origem. Antes de ativar o acesso aos backups de logs de transações, selecione um bucket existente do Amazon S3 ou [crie um bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingaBucket.html) para usar em seus arquivos de backup de logs de transações.
+ Uma política de permissões de bucket do Amazon S3 deve ser configurada da seguinte forma para que o Amazon RDS copie arquivos de log de transações nela:
1. Defina a propriedade da conta do objeto no bucket como **Bucket Owner Preferred** (Propriedade do bucket preferencial).
1. Adicione a política a seguir. Não haverá nenhuma política por padrão, então use as listas de controle de acesso (ACL) do bucket para editar a política do bucket e adicioná-la.
O exemplo a seguir usa um ARN para especificar um recurso. Recomendamos usar as chaves de contexto de condição global `SourceArn` e `SourceAccount` em relacionamentos de confiança baseados em recursos a fim de limitar as permissões do serviço a um recurso específico. Para ter mais informações sobre como trabalhar com ARNs, consulte [Amazon resource names (ARNs)](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) (Nomes de recursos da Amazon (ARNs)) e [Nomes de recurso da Amazon (ARNs) no Amazon RDS](USER_Tagging.ARN.md).
**Example de uma política de permissões do Amazon S3 para acesso a backups de logs de transações**
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "Only allow writes to my bucket with bucket owner full control",
"Effect": "Allow",
"Principal": {
"Service": "backups.rds.amazonaws.com"
},
"Action": "s3:PutObject",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/{customer_path}/*",
"Condition": {
"StringEquals": {
"s3:x-amz-acl": "bucket-owner-full-control",
"aws:sourceAccount": "{customer_account}",
"aws:sourceArn": "{db_instance_arn}"
}
}
}
]
}
```
------
+ Um AWS Identity and Access Management (perfil do IAM) para acessar o bucket do Amazon S3. 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. Para ter mais informações sobre como criar e configurar um perfil do IAM com `SQLSERVER_BACKUP_RESTORE`, consulte [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).
+ A opção `SQLSERVER_BACKUP_RESTORE` deve ser adicionada a um grupo de opções em sua instância de banco de dados. Para ter mais informações sobre a adição da opção `SQLSERVER_BACKUP_RESTORE`, consulte [Suporte para backup e restauração nativos no SQL Server](Appendix.SQLServer.Options.BackupRestore.md).
**nota**
Se sua instância de banco de dados tiver a criptografia de armazenamento habilitada, será necessário fornecer as ações e a chave do AWS KMS (KMS) no perfil do IAM indicado no grupo nativo de opções de backup e restauração.
Opcionalmente, se você pretende usar o procedimento armazenado `rds_restore_log` para realizar restaurações do banco de dados a um ponto anterior no tempo, recomendamos usar o mesmo caminho do Amazon S3 para o grupo nativo de opções de backup e restauração e acesso aos backups de logs de transações. Esse método garante que, quando o Amazon RDS assume a função do grupo de opções para realizar as funções de log de restauração, ele tenha acesso para recuperar backups de logs de transações do mesmo caminho do Amazon S3.
+ Se a instância de banco de dados for criptografada, independentemente do tipo de criptografia (chave gerenciada pela AWS ou chave gerenciada pelo cliente), você deverá fornecer uma chave do KMS gerenciada pelo cliente no perfil do IAM e no procedimento armazenado `rds_tlog_backup_copy_to_S3`.
## Limitações e recomendações
O acesso aos backups de logs de transações tem as seguintes limitações e recomendações:
+ Você pode listar e copiar até os últimos sete dias de backups de logs de transações para qualquer instância de banco de dados que tenha a retenção de backup configurada entre um a 35 dias.
+ Um bucket do Amazon S3 utilizado para acessar backups de logs de transações deve existir na mesma conta e região da instância de banco de dados de origem. Não há suporte à cópia entre contas e regiões.
+ Somente um bucket do Amazon S3 pode ser configurado como destino para copiar backups de logs de transações. Você pode selecionar um novo bucket de destino do Amazon S3 com o procedimento armazenado `rds_tlog_copy_setup`. Para ter mais informações sobre como selecionar um novo bucket de destino do Amazon S3, consulte [Configurar o acesso aos backups de logs de transações](USER.SQLServer.AddlFeat.TransactionLogAccess.Enabling.md).
+ Você não poderá especificar a chave do KMS ao usar o procedimento armazenado `rds_tlog_backup_copy_to_S3` se sua instância do RDS não estiver ativada para criptografia de armazenamento.
+ A cópia de várias contas não é compatível. O perfil do IAM utilizado para cópia só permitirá o acesso de gravação aos buckets do Amazon S3 na conta do proprietário da instância de banco de dados.
+ Somente duas tarefas simultâneas de qualquer tipo podem ser executadas em uma instância de banco de dados do RDS para SQL Server.
+ Somente uma tarefa de cópia pode ser executada em um único banco de dados em um determinado momento. Se você quiser copiar backups de logs de transações para vários bancos de dados na instância de banco de dados, utilize uma tarefa de cópia separada para cada banco de dados.
+ Se você copiar um backup de logs de transações que já existe com o mesmo nome no bucket do Amazon S3, o backup de logs de transações existente será substituído.
+ Você só pode executar os procedimentos armazenados que são fornecidos com acesso aos backups de logs de transações na instância de banco de dados primária. Não é possível executar esses procedimentos armazenados em uma réplica de leitura do RDS para SQL Server nem em uma instância secundária de um cluster de banco de dados multi-AZ.
+ Se a instância de banco de dados do RDS para SQL Server for reinicializada enquanto o procedimento armazenado `rds_tlog_backup_copy_to_S3` estiver em execução, a tarefa será reiniciada automaticamente desde o início, quando a instância de banco de dados estiver on-line novamente. Todos os backups de logs de transações que tenha sido copiado no bucket do Amazon S3 enquanto a tarefa estiver em execução antes da reinicialização serão substituídos.
+ Os bancos de dados do sistema Microsoft SQL Server e o banco de dados `RDSAdmin` não podem ser configurados para acesso aos backups de logs de transações.
+ A cópia em buckets criptografados pela SSE-KMS não é compatível.
# Configurar o acesso aos backups de logs de transações
Para configurar o acesso aos backups de logs de transações, complete a lista de requisitos na seção [Requisitos](USER.SQLServer.AddlFeat.TransactionLogAccess.md#USER.SQLServer.AddlFeat.TransactionLogAccess.Requirements) e, depois, execute o procedimento armazenado `rds_tlog_copy_setup`. O procedimento permitirá o acesso ao recurso de backups de logs de transações em nível de instância de banco de dados. Você não precisa executá-lo para cada banco de dados individual na instância de banco de dados.
**Importante**
O usuário do banco de dados deve receber a função `db_owner` no SQL Server em cada banco de dados para configurar e usar o recurso de acesso aos backups de logs de transações.
**Example uso:**
```
exec msdb.dbo.rds_tlog_copy_setup
@target_s3_arn='arn:aws:s3:::amzn-s3-demo-bucket/myfolder';
```
O seguinte parâmetro é obrigatório:
+ `@target_s3_arn`: o ARN do bucket de destino do Amazon S3 no qual copiar arquivos de backup de logs de transações.
**Example de definir um bucket de destino do Amazon S3:**
```
exec msdb.dbo.rds_tlog_copy_setup @target_s3_arn='arn:aws:s3:::amzn-s3-demo-logging-bucket/mytestdb1';
```
Para validar a configuração, chame o procedimento armazenado `rds_show_configuration`.
**Example de validar a configuração:**
```
exec rdsadmin.dbo.rds_show_configuration @name='target_s3_arn_for_tlog_copy';
```
Para modificar o acesso aos backups de logs de transações para apontar para um bucket diferente do Amazon S3, você pode visualizar o valor atual do bucket do Amazon S3 e executar novamente o procedimento armazenado `rds_tlog_copy_setup` utilizando um novo valor para o `@target_s3_arn`.
**Example de visualizar o bucket existente do Amazon S3 configurado para acesso aos backups de logs de transações**
```
exec rdsadmin.dbo.rds_show_configuration @name='target_s3_arn_for_tlog_copy';
```
**Example de atualização para um novo bucket de destino do Amazon S3**
```
exec msdb.dbo.rds_tlog_copy_setup @target_s3_arn='arn:aws:s3:::amzn-s3-demo-logging-bucket1/mynewfolder';
```
# Listar os backups de logs de transações disponíveis
Com o RDS para SQL Server, os bancos de dados configurados para usar o modelo de recuperação completo e uma retenção de backup de instância de banco de dados definida para um ou mais dias têm os backups de logs de transações ativados automaticamente. Ao permitir o acesso aos backups de logs de transações, eles ficam disponíveis por até sete dias para você copiar em seu bucket do Amazon S3.
Depois de ativar o acesso aos backups de logs de transações, você pode começar a usá-lo para listar e copiar os arquivos de backup de logs de transações disponíveis.
**Listar backups de logs de transações**
Para listar todos os backups de logs de transações disponíveis para um banco de dados individual, chame a função `rds_fn_list_tlog_backup_metadata`. Você pode utilizar uma cláusula `ORDER BY` ou `WHERE` ao chamar a função.
**Example de listar e filtrar os arquivos de backup de logs de transações disponíveis**
```
SELECT * from msdb.dbo.rds_fn_list_tlog_backup_metadata('mydatabasename');
SELECT * from msdb.dbo.rds_fn_list_tlog_backup_metadata('mydatabasename') WHERE rds_backup_seq_id = 3507;
SELECT * from msdb.dbo.rds_fn_list_tlog_backup_metadata('mydatabasename') WHERE backup_file_time_utc > '2022-09-15 20:44:01' ORDER BY backup_file_time_utc DESC;
```
![\[Saída de rds_fn_list_tlog_backup_metadata\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/sql_accesstransactionlogs_func.png)
A função `rds_fn_list_tlog_backup_metadata` retorna o seguinte resultado:
****
| Nome da coluna | Tipo de dados | Descrição |
| --- | --- | --- |
| `db_name` | sysname | O nome do banco de dados fornecido para listar os backups de logs de transações. |
| `db_id` | int | O identificador interno do banco de dados para o parâmetro de entrada `db_name`. |
| `family_guid` | uniqueidentifier | O ID exclusivo do banco de dados original na criação. Esse valor permanece o mesmo quando o banco de dados é restaurado, mesmo com um nome de banco de dados diferente. |
| `rds_backup_seq_id` | int | O ID que o RDS utiliza internamente para manter um número de sequência de cada arquivo de backup de logs de transações. |
| `backup_file_epoch` | bigint | A época em que um arquivo de backup de transações foi gerado. |
| `backup_file_time_utc` | datetime | O valor UTC convertido em tempo para o valor `backup_file_epoch`. |
| `starting_lsn` | numérico (25,0) | O número de sequência de logs do primeiro registro de log ou do mais antigo de um arquivo de backup de logs de transações. |
| `ending_lsn` | numérico (25,0) | O número de sequência de logs do último ou do próximo registro de log de um arquivo de backup de logs de transações. |
| `is_log_chain_broken` | bit | Um valor booliano que indica se a cadeia de logs está rompida entre o arquivo de backup de logs de transações atual e o anterior. |
| `file_size_bytes` | bigint | O tamanho do conjunto de backup transacional em bytes. |
| `Error` | varchar(4000) | Mensagem de erro se a função `rds_fn_list_tlog_backup_metadata` gerar uma exceção. NULL se não houver exceções. |
# Copiar backups de logs de transações
Para copiar um conjunto de backups de logs de transações disponíveis para um banco de dados individual em seu bucket do Amazon S3, chame o procedimento armazenado `rds_tlog_backup_copy_to_S3`. O procedimento armazenado `rds_tlog_backup_copy_to_S3` iniciará uma nova tarefa para copiar os backups de logs de transações.
**nota**
O procedimento armazenado `rds_tlog_backup_copy_to_S3` copiará os backups de logs de transações sem validação em relação ao atributo `is_log_chain_broken`. Por esse motivo, você deve confirmar manualmente uma cadeia de logs ininterrupta antes de executar o procedimento armazenado `rds_tlog_backup_copy_to_S3`. Para obter mais explicações, consulte [Validar a cadeia de logs de backup de logs de transações](#USER.SQLServer.AddlFeat.TransactionLogAccess.Copying.LogChain).
**Example uso do procedimento armazenado `rds_tlog_backup_copy_to_S3`**
```
exec msdb.dbo.rds_tlog_backup_copy_to_S3
@db_name='mydatabasename',
[@kms_key_arn='arn:aws:kms:region:account-id:key/key-id'],
[@backup_file_start_time='2022-09-01 01:00:15'],
[@backup_file_end_time='2022-09-01 21:30:45'],
[@starting_lsn=149000000112100001],
[@ending_lsn=149000000120400001],
[@rds_backup_starting_seq_id=5],
[@rds_backup_ending_seq_id=10];
```
Os seguintes parâmetros de entrada estão disponíveis:
****
| Parameter | Descrição |
| --- | --- |
| `@db_name` | O nome do banco de dados do qual copiar backups de logs de transações |
| `@kms_key_arn` | Uma chave do KMS gerenciada pelo cliente. Se você criptografar a instância de banco de dados com uma chave do KMS gerenciada pela AWS, será necessário criar uma chave gerenciada pelo cliente. Se criptografar a instância de banco de dados com uma chave gerenciada pelo cliente, você poderá usar o mesmo ARN da chave do KMS. |
| `@backup_file_start_time` | O carimbo de data e hora UTC conforme fornecido na coluna `[backup_file_time_utc]` da função `rds_fn_list_tlog_backup_metadata`. |
| `@backup_file_end_time` | O carimbo de data e hora UTC conforme fornecido na coluna `[backup_file_time_utc]` da função `rds_fn_list_tlog_backup_metadata`. |
| `@starting_lsn` | O número de sequência de logs (LSN) conforme fornecido na coluna `[starting_lsn]` da função `rds_fn_list_tlog_backup_metadata` |
| `@ending_lsn` | O número de sequência de logs (LSN) conforme fornecido na coluna `[ending_lsn]` da função `rds_fn_list_tlog_backup_metadata`. |
| `@rds_backup_starting_seq_id` | O ID de sequência conforme fornecido na coluna `[rds_backup_seq_id]` da função `rds_fn_list_tlog_backup_metadata`. |
| `@rds_backup_ending_seq_id` | O ID de sequência conforme fornecido na coluna `[rds_backup_seq_id]` da função `rds_fn_list_tlog_backup_metadata`. |
Você pode especificar um conjunto de parâmetros de hora, LSN ou ID de sequência. Somente um conjunto de parâmetros é necessário.
Você também pode especificar apenas um único parâmetro em qualquer um dos conjuntos. Por exemplo, ao fornecer um valor somente para o parâmetro `backup_file_end_time`, todos os arquivos de backup de logs de transações disponíveis antes desse período dentro do limite de sete dias serão copiados em seu bucket do Amazon S3.
Veja a seguir as combinações válidas de parâmetros de entrada para o procedimento armazenado `rds_tlog_backup_copy_to_S3`.
****
| Parâmetros fornecidos | Resultado esperado |
| --- | --- |
| exec msdb.dbo.rds_tlog_backup_copy_to_S3
@db_name = 'testdb1',
@backup_file_start_time='2022-08-23 00:00:00',
@backup_file_end_time='2022-08-30 00:00:00';
| Copia os backups de logs de transações dos últimos sete dias e existentes entre o intervalo fornecido de`backup_file_start_time` e `backup_file_end_time`. Neste exemplo, o procedimento armazenado copiará os backups de logs de transações que foram gerados entre “2022-08-23 00:00:00” e “2022-08-30 00:00:00”. |
| exec msdb.dbo.rds_tlog_backup_copy_to_S3
@db_name = 'testdb1',
@backup_file_start_time='2022-08-23 00:00:00';
| Copia os backups de logs de transações dos últimos sete dias e a partir do `backup_file_start_time` fornecido. Neste exemplo, o procedimento armazenado copiará os backups de logs de transações de “2022-08-23 00:00:00” até o último backup de logs de transações. |
| exec msdb.dbo.rds_tlog_backup_copy_to_S3
@db_name = 'testdb1',
@backup_file_end_time='2022-08-30 00:00:00';
| Copia os backups de logs de transações dos últimos sete dias até o `backup_file_end_time` fornecido. Neste exemplo, o procedimento armazenado copiará os backups de logs de transações que foram gerados de “2022-08-23 00:00:00” até “2022-08-30 00:00:00”. |
| exec msdb.dbo.rds_tlog_backup_copy_to_S3
@db_name='testdb1',
@starting_lsn =1490000000040007,
@ending_lsn = 1490000000050009;
| Copia os backups de logs de transações disponíveis dos últimos sete dias e entre o intervalo fornecido do `starting_lsn` e `ending_lsn`. Neste exemplo, o procedimento armazenado copiará backups de logs de transações dos últimos sete dias com um intervalo de LSN entre 1490000000040007 e 1490000000050009. |
| exec msdb.dbo.rds_tlog_backup_copy_to_S3
@db_name='testdb1',
@starting_lsn =1490000000040007;
| Copia os backups de logs de transações disponíveis dos últimos sete dias, a partir do `starting_lsn` fornecido. Neste exemplo, o procedimento armazenado copiará os backups de logs de transações do LSN 1490000000040007 até o último backup de logs de transações. |
| exec msdb.dbo.rds_tlog_backup_copy_to_S3
@db_name='testdb1',
@ending_lsn =1490000000050009;
| Copia os backups de logs de transações disponíveis dos últimos sete dias, até o `ending_lsn` fornecido. Neste exemplo, o procedimento armazenado copiará backups de logs de transações a partir dos últimos sete dias até o lsn 1490000000050009. |
| exec msdb.dbo.rds_tlog_backup_copy_to_S3
@db_name='testdb1',
@rds_backup_starting_seq_id= 2000,
@rds_backup_ending_seq_id= 5000;
| Copia os backups de logs de transações disponíveis dos últimos sete dias e existentes entre o intervalo fornecido de `rds_backup_starting_seq_id` e `rds_backup_ending_seq_id`. Neste exemplo, o procedimento armazenado copiará os backups de logs de transações dos últimos sete dias e dentro do intervalo de ID da sequência de backup do rds fornecido, começando de seq\$1id 2000 até seq\$1id 5000. |
| exec msdb.dbo.rds_tlog_backup_copy_to_S3
@db_name='testdb1',
@rds_backup_starting_seq_id= 2000;
| Copia os backups de logs de transações disponíveis dos últimos sete dias, a partir do `rds_backup_starting_seq_id` fornecido. Neste exemplo, o procedimento armazenado copiará os backups de logs de transações de seq\$1id 2000 até o último backup de logs de transações. |
| exec msdb.dbo.rds_tlog_backup_copy_to_S3
@db_name='testdb1',
@rds_backup_ending_seq_id= 5000;
| Copia os backups de logs de transações disponíveis dos últimos sete dias, até o `rds_backup_ending_seq_id` fornecido. Neste exemplo, o procedimento armazenado copiará backups de logs de transações a partir dos últimos sete dias, até seq\$1id 5000. |
| exec msdb.dbo.rds_tlog_backup_copy_to_S3
@db_name='testdb1',
@rds_backup_starting_seq_id= 2000;
@rds_backup_ending_seq_id= 2000;
| Copia um único backup de logs de transações com o `rds_backup_starting_seq_id` fornecido, se disponível nos últimos sete dias. Neste exemplo, o procedimento armazenado copiará um único backup de logs de transações que tenha um seq\$1id de 2000, se houver nos últimos sete dias. |
## Validar a cadeia de logs de backup de logs de transações
Os bancos de dados configurados para acesso aos backups de logs de transações devem ter a retenção automatizada de backup ativada. A retenção automatizada de backup define os bancos de dados na instância de banco de dados de acordo com o modelo de recuperação `FULL`. Para ser compatível com a restauração a um ponto anterior no tempo de um banco de dados, evite alterar o modelo de recuperação do banco de dados, o que pode ocasionar uma cadeia de registros interrompida. Recomendamos manter o banco de dados definido como o modelo de recuperação `FULL`.
Para validar manualmente a cadeia de logs antes de copiar os backups de logs de transações, chame a função `rds_fn_list_tlog_backup_metadata` e revise os valores na coluna `is_log_chain_broken`. Um valor de “1" indica que a cadeia de logs foi interrompida entre o backup de logs atual e o backup de logs anterior.
O exemplo a seguir mostra uma cadeia de logs interrompida na saída do procedimento armazenado `rds_fn_list_tlog_backup_metadata`.
![\[Saída de rds_fn_list_tlog_backup_metadata mostrando uma cadeia de logs interrompida.\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/sql_accesstransactionlogs_logchain_error.png)
Em uma cadeia de logs normal, o valor do número de sequência de log (LSN) para first\$1lsn para determinado rds\$1sequence\$1id deve corresponder ao valor de last\$1lsn no rds\$1sequence\$1id anterior. Na imagem, o rds\$1sequence\$1id de 45 tem um valor first\$1lsn 90987, que não corresponde ao valor last\$1lsn de 90985 do rds\$1sequence\$1id 44 anterior.
Para ter mais informações sobre a arquitetura de logs de transações e os números de sequência de log do SQL Server, consulte [Transaction Log Logical Architecture](https://learn.microsoft.com/en-us/sql/relational-databases/sql-server-transaction-log-architecture-and-management-guide?view=sql-server-ver15#Logical_Arch) (Arquitetura lógica do log de transações) na documentação do Microsoft SQL Server.
# Estrutura de arquivos e pastas do bucket do Amazon S3
Os backups de logs de transações têm a seguinte estrutura padrão e convenção de nomenclatura em um bucket do Amazon S3:
+ Uma nova pasta é criada no caminho `target_s3_arn` de cada banco de dados com a estrutura de nomenclatura `{db_id}.{family_guid}`.
+ Dentro da pasta, os backups de logs de transações têm uma estrutura de nome de arquivo `{db_id}.{family_guid}.{rds_backup_seq_id}.{backup_file_epoch}`.
+ Você pode ver os detalhes de `family_guid,db_id,rds_backup_seq_id and backup_file_epoch` da função `rds_fn_list_tlog_backup_metadata`.
O exemplo a seguir mostra a estrutura de pastas e arquivos de um conjunto de backups de logs de transações em um bucket do Amazon S3.
![\[Estrutura de buckets do Amazon S3 com acesso aos logs de transações\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/sql_accesstransactionlogs_s3.png)
# Acompanhar o status de tarefas
Para acompanhar o status de suas tarefas de cópia, 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.
**Example uso:**
```
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.
**Example de listagem do status de um ID de tarefa específico:**
```
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 de 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 de banco de dados atual**
```
exec msdb.dbo.rds_task_status;
```
# Cancelar uma tarefa
Para cancelar uma tarefa em execução, chame o procedimento armazenado `rds_cancel_task`.
**Example uso:**
```
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 visualizar o ID da tarefa chamando o procedimento armazenado `rds_task_status`.
Para ter mais informações sobre como visualizar e cancelar tarefas em execução, consulte [Importar e exportar bancos de dados do SQL Server usando backup e restauração nativos](SQLServer.Procedural.Importing.md).
# Solução de problemas de acesso aos backups de logs de transações
Os problemas a seguir podem ocorrer ao usar os procedimentos armazenados para acesso aos backups de logs de transações.
****
| Procedimento armazenado | Mensagem de erro | Problema | Sugestões de solução de problemas |
| --- | --- | --- | --- |
| rds\$1tlog\$1copy\$1setup | Os backups estão desativados nessa instância de banco de dados. Ative backups de instâncias de banco de dados com uma retenção de pelo menos “1" e tente novamente. | Backups automatizados não estão ativados para a instância de banco de dados. | A retenção de backup da instância de banco de dados deve ser ativada com uma retenção de pelo menos um dia. Para ter mais informações sobre como ativar backups automatizados e configurar a retenção de backups, consulte [Período de retenção de backup](USER_WorkingWithAutomatedBackups.BackupRetention.md). |
| rds\$1tlog\$1copy\$1setup | Erro ao executar o procedimento armazenado rds\$1tlog\$1copy\$1setup. Reconecte-se ao endpoint do RDS e tente novamente. | Ocorreu um erro interno. | Reconecte-se ao endpoint do RDS e execute o procedimento armazenado `rds_tlog_copy_setup` novamente. |
| rds\$1tlog\$1copy\$1setup | A execução do procedimento armazenado rds\$1tlog\$1backup\$1copy\$1setup em uma transação não é compatível. Verifique se a sessão não tem transações abertas e tente novamente. | Houve uma tentativa de realizar o procedimento armazenado em uma transação com o uso de `BEGIN` e `END`. | Evite utilizar `BEGIN` e `END` ao executar o procedimento armazenado `rds_tlog_copy_setup`. |
| rds\$1tlog\$1copy\$1setup | O nome do bucket do S3 para o parâmetro de entrada`@target_s3_arn` deve conter pelo menos um caractere diferente de um espaço. | Um valor incorreto foi fornecido para o parâmetro de entrada `@target_s3_arn`. | O parâmetro de entrada `@target_s3_arn` deve especificar o ARN completo do bucket do Amazon S3. |
| rds\$1tlog\$1copy\$1setup | A opção `SQLSERVER_BACKUP_RESTORE` não está ativada ou está em processo de ativação. Ative a opção ou tente novamente mais tarde. | A opção `SQLSERVER_BACKUP_RESTORE` não está ativada na instância de banco de dados ou estava apenas ativada e com a ativação interna pendente. | Ative a opção `SQLSERVER_BACKUP_RESTORE` conforme especificado na seção Requirements (Requisitos). Aguarde alguns minutos e execute o procedimento armazenado `rds_tlog_copy_setup` novamente. |
| rds\$1tlog\$1copy\$1setup | O arn de destino do S3 para o parâmetro de entrada `@target_s3_arn` não pode estar em branco nem ser nulo. | Um valor `NULL` foi fornecido para o parâmetro de entrada `@target_s3_arn` ou o valor não foi fornecido. | O parâmetro de entrada `@target_s3_arn` deve especificar o ARN completo do bucket do Amazon S3. |
| rds\$1tlog\$1copy\$1setup | O arn de destino do S3 para o parâmetro de entrada `@target_s3_arn` deve começar com arn:aws. | O parâmetro de entrada `@target_s3_arn` foi fornecido sem `arn:aws` na frente. | O parâmetro de entrada `@target_s3_arn` deve especificar o ARN completo do bucket do Amazon S3. |
| rds\$1tlog\$1copy\$1setup | O ARN de destino do S3 já está definido com o valor fornecido. | O procedimento armazenado `rds_tlog_copy_setup` foi executado anteriormente e configurado com um ARN do bucket do Amazon S3. | Para modificar o valor do bucket do Amazon S3 para acesso aos backups de logs de transações, forneça um `target S3 ARN` diferente. |
| rds\$1tlog\$1copy\$1setup | Não é possível gerar credenciais para ativar o acesso aos backups de logs de transações. Confirme o ARN do caminho do S3 fornecido com `rds_tlog_copy_setup` e tente novamente mais tarde. | Houve um erro não especificado ao gerar credenciais para permitir o acesso aos backups de logs de transações. | Revise a configuração e tente novamente. |
| rds\$1tlog\$1copy\$1setup | Você não pode executar o procedimento armazenado rds\$1tlog\$1copy\$1setup enquanto houver tarefas pendentes. Aguarde até que as tarefas pendentes sejam concluídas e tente novamente. | Somente duas tarefas podem ser executadas por vez. Há tarefas pendentes aguardando conclusão. | Visualize as tarefas pendentes e aguarde a conclusão delas. Para ter mais informações sobre monitoramento do status da tarefa, consulte [Acompanhar o status de tarefas](USER.SQLServer.AddlFeat.TransactionLogAccess.TrackTaskStatus.md). |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Uma tarefa de cópia de arquivos de backup T-log já foi emitida para o banco de dados: %s com ID da tarefa: %d, tente novamente mais tarde. | Somente uma tarefa de cópia pode ser executada em um único banco de dados em um determinado momento. Há uma tarefa de cópia pendente aguardando conclusão. | Visualize as tarefas pendentes e aguarde a conclusão delas. Para ter mais informações sobre monitoramento do status da tarefa, consulte [Acompanhar o status de tarefas](USER.SQLServer.AddlFeat.TransactionLogAccess.TrackTaskStatus.md). |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Pelo menos um destes três conjuntos de parâmetros deve ser fornecido. SET-1:(@backup\$1file\$1start\$1time, @backup\$1file\$1end\$1time) \$1 SET-2:(@starting\$1lsn, @ending\$1lsn) \$1 SET-3:(@rds\$1backup\$1starting\$1seq\$1id, @rds\$1backup\$1ending\$1seq\$1id) | Nenhum dos três conjuntos de parâmetros foi fornecido, ou um conjunto de parâmetros fornecido não tem um parâmetro obrigatório. | Você pode especificar parâmetros de hora, lsn ou ID de sequência. É necessário um destes três conjuntos de parâmetros. Para ter mais informações sobre os parâmetros obrigatórios, consulte [Copiar backups de logs de transações](USER.SQLServer.AddlFeat.TransactionLogAccess.Copying.md). |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Os backups estão desativados em sua instância. Ative os backups e tente novamente em algum momento. | Backups automatizados não estão ativados para a instância de banco de dados. | Para ter mais informações sobre como ativar backups automatizados e configurar a retenção de backups, consulte [Período de retenção de backup](USER_WorkingWithAutomatedBackups.BackupRetention.md). |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Não é possível encontrar o banco de dados %s fornecido. | O valor fornecido para o parâmetro de entrada `@db_name` não corresponde ao nome do banco de dados na instância de banco de dados. | Utilize o nome de banco de dados correto. Para listar todos os bancos de dados por nome, execute `SELECT * from sys.databases` |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Não é possível executar o procedimento armazenado rds\$1tlog\$1backup\$1copy\$1to\$1S3 para bancos de dados do sistema do SQL Server nem para o banco de dados rdsadmin. | O valor fornecido para o parâmetro de entrada `@db_name` corresponde ao nome do banco de dados do sistema do SQL Server ou ao banco de dados RDSAdmin. | Os seguintes bancos de dados não podem ser usados com acesso aos backups de logs de transações: `master, model, msdb, tempdb, RDSAdmin.` |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | O nome do banco de dados do parâmetro de entrada @db\$1name não pode estar em branco nem ser nulo. | Um valor fornecido para o parâmetro de entrada `@db_name` estava em branco ou `NULL`. | Utilize o nome de banco de dados correto. Para listar todos os bancos de dados por nome, execute `SELECT * from sys.databases` |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | O período de retenção do backup da instância de banco de dados deve ser definido como pelo menos 1 para executar o procedimento armazenado rds\$1tlog\$1backup\$1copy\$1setup. | Backups automatizados não estão ativados para a instância de banco de dados. | Para ter mais informações sobre como ativar backups automatizados e configurar a retenção de backups, consulte [Período de retenção de backup](USER_WorkingWithAutomatedBackups.BackupRetention.md). |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Erro ao executar o procedimento armazenado rds\$1tlog\$1backup\$1copy\$1to\$1S3. Reconecte-se ao endpoint do RDS e tente novamente. | Ocorreu um erro interno. | Reconecte-se ao endpoint do RDS e execute o procedimento armazenado `rds_tlog_backup_copy_to_S3` novamente. |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Somente um destes três conjuntos de parâmetros deve ser fornecido. SET-1:(@backup\$1file\$1start\$1time, @backup\$1file\$1end\$1time) \$1 SET-2:(@starting\$1lsn, @ending\$1lsn) \$1 SET-3:(@rds\$1backup\$1starting\$1seq\$1id, @rds\$1backup\$1ending\$1seq\$1id) | Vários conjuntos de parâmetros foram fornecidos. | Você pode especificar parâmetros de hora, lsn ou ID de sequência. É necessário um destes três conjuntos de parâmetros. Para ter mais informações sobre os parâmetros obrigatórios, consulte [Copiar backups de logs de transações](USER.SQLServer.AddlFeat.TransactionLogAccess.Copying.md). |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | A execução do procedimento armazenado rds\$1tlog\$1backup\$1copy\$1to\$1S3 em uma transação não é compatível. Verifique se a sessão não tem transações abertas e tente novamente. | Houve uma tentativa de realizar o procedimento armazenado em uma transação com o uso de `BEGIN` e `END`. | Evite utilizar `BEGIN` e `END` ao executar o procedimento armazenado `rds_tlog_backup_copy_to_S3`. |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Os parâmetros fornecidos estão fora do período de retenção de logs de backup de transações. Para listar os arquivos de backup de logs de transações disponíveis, execute a função rds\$1fn\$1list\$1tlog\$1backup\$1metadata. | Não há backups de logs transacionais disponíveis para os parâmetros de entrada fornecidos que se encaixem na janela de retenção de cópias. | Tente novamente com um conjunto válido de parâmetros. Para ter mais informações sobre os parâmetros obrigatórios, consulte [Copiar backups de logs de transações](USER.SQLServer.AddlFeat.TransactionLogAccess.Copying.md). |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Houve um erro de permissão no processamento da solicitação. O bucket deve estar na mesma conta e região da instância de banco de dados e confirme as permissões da política de bucket do S3 em relação ao modelo na documentação pública. | Foi detectado um problema com o bucket do S3 fornecido ou com suas permissões de política. | Confirme se sua configuração de acesso aos backups de logs de transações está correta. Para ter mais informações sobre os requisitos de configuração para seu bucket do S3, consulte [Requisitos](USER.SQLServer.AddlFeat.TransactionLogAccess.md#USER.SQLServer.AddlFeat.TransactionLogAccess.Requirements). |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Não é permitido executar o procedimento armazenado `rds_tlog_backup_copy_to_S3` em uma instância de réplica de leitura do RDS. | Houve uma tentativa de realizar o procedimento armazenado em uma instância de réplica de leitura do RDS. | Conecte-se à instância de banco de dados primária do RDS para executar o procedimento armazenado `rds_tlog_backup_copy_to_S3`. |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | O LSN para o parâmetro de entrada `@starting_lsn` deve ser menor que `@ending_lsn`. | O valor fornecido para o parâmetro de entrada `@starting_lsn` foi maior do que o valor fornecido para o parâmetro de entrada `@ending_lsn`. | O valor fornecido para o parâmetro de entrada `@starting_lsn` foi menor do que o valor fornecido para o parâmetro de entrada `@ending_lsn`. |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | O procedimento armazenado `rds_tlog_backup_copy_to_S3` só pode ser executado pelos membros da função `db_owner` no banco de dados de origem. | A função `db_owner` não foi concedida para a conta que está tentando executar o procedimento armazenado `rds_tlog_backup_copy_to_S3` no `db_name` fornecido. | A conta que executa o procedimento armazenado deve ter permissão com a função `db_owner` para o `db_name` fornecido. |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | O ID de sequência do parâmetro de entrada `@rds_backup_starting_seq_id` deve ser menor ou igual a `@rds_backup_ending_seq_id`. | O valor fornecido para o parâmetro de entrada `@rds_backup_starting_seq_id` foi maior do que o valor fornecido para o parâmetro de entrada `@rds_backup_ending_seq_id`. | O valor fornecido para o parâmetro de entrada `@rds_backup_starting_seq_id` foi menor do que o valor fornecido para o parâmetro de entrada `@rds_backup_ending_seq_id`. |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | A opção SQLSERVER\$1BACKUP\$1RESTORE não está ativada ou está em processo de ativação. Ative a opção ou tente novamente mais tarde. | A opção `SQLSERVER_BACKUP_RESTORE` não está ativada na instância de banco de dados ou estava apenas ativada e com a ativação interna pendente. | Ative a opção `SQLSERVER_BACKUP_RESTORE` conforme especificado na seção Requirements (Requisitos). Aguarde alguns minutos e execute o procedimento armazenado `rds_tlog_backup_copy_to_S3` novamente. |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | A hora de início do parâmetro de entrada `@backup_file_start_time` deve ser menor do que `@backup_file_end_time`. | O valor fornecido para o parâmetro de entrada `@backup_file_start_time` foi maior do que o valor fornecido para o parâmetro de entrada `@backup_file_end_time`. | O valor fornecido para o parâmetro de entrada `@backup_file_start_time` foi menor do que o valor fornecido para o parâmetro de entrada `@backup_file_end_time`. |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Não conseguimos processar a solicitação devido à falta de acesso. Confira sua configuração e permissões para o recurso. | Pode haver um problema com as permissões do bucket do Amazon S3, ou o bucket do Amazon S3 fornecido está em outra conta ou região. | As permissões da política de bucket do Amazon S3 devem ter permissão para permitir o acesso ao RDS. Um bucket do Amazon S3 deve existir na mesma conta e região da instância de banco de dados. |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Você não pode fornecer um ARN de chave do KMS como parâmetro de entrada para o procedimento armazenado para instâncias que não são criptografadas para armazenamento. | Quando a criptografia de armazenamento não está ativada na instância de banco de dados, o parâmetro de entrada `@kms_key_arn` não deve ser fornecido. | Não forneça um parâmetro de entrada para `@kms_key_arn`. |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Você deve fornecer um ARN de chave do KMS como parâmetro de entrada para o procedimento armazenado para instâncias criptografadas para armazenamento. | Quando a criptografia de armazenamento está ativada na instância de banco de dados, o parâmetro de entrada `@kms_key_arn` deve ser fornecido. | Forneça um parâmetro de entrada para `@kms_key_arn` com um valor que corresponda ao ARN do bucket do Amazon S3 a ser usado para backups de logs de transações. |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Você deve executar o procedimento armazenado `rds_tlog_copy_setup` e definir o `@target_s3_arn` antes de executar o procedimento armazenado `rds_tlog_backup_copy_to_S3`. | O procedimento de configuração do acesso aos backups de logs de transações não foi concluído antes da tentativa de executar o procedimento armazenado `rds_tlog_backup_copy_to_S3`. | Execute o procedimento armazenado `rds_tlog_copy_setup` antes de executar o procedimento armazenado `rds_tlog_backup_copy_to_S3`. Para ter mais informações sobre como executar o procedimento de configuração para acesso aos backups de logs de transações, consulte [Configurar o acesso aos backups de logs de transações](USER.SQLServer.AddlFeat.TransactionLogAccess.Enabling.md). |