`. RDS supporta percorsi assoluti e percorsi relativi. Per creare una sottocartella è necessario includerla nel percorso del file. |
| `@overwrite_file` | INT | 0 | Facoltativo | Sovrascrittura del file esistente: 0 = Non sovrascrivere 1 = Sovrascrivi |
È possibile scaricare file senza estensione e file con le seguenti estensioni: .bcp, .csv, .dat, .fmt, .info, .lst, .tbl, .txt e .xml.
**Nota**
I file con estensione .ispac sono supportati per il download quando SQL Server Integration Services è abilitato. Per ulteriori informazioni sull'abilitazione di SSIS, vedere [SQL Server Integration Services (SSIS)](Appendix.SQLServer.Options.SSIS.md).
I file con le seguenti estensioni di file sono supportati per il download quando SQL Server Analysis Services è abilitato: .abf, .asdatabase, .configsettings, .deploymentoptions, .deploymenttargets e .xmla. Per ulteriori informazioni sull'abilitazione di SSAS, vedere [SQL Server Analysis Services (SSAS)](Appendix.SQLServer.Options.SSAS.md).
L'esempio seguente mostra la stored procedure per scaricare i file da 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;
```
L'operazione `rds_download_from_s3` di esempio crea una cartella denominata `seed_data` in `D:\S3\`, se non esiste già. Quindi, viene scaricato il file di origine `bulk_data.csv` da S3 in un nuovo file denominato `data.csv` nell'istanza database. Se il file esisteva in precedenza, viene sovrascritto perché il parametro `@overwrite_file` è impostato su `1`.
## Aggiornamenti di file da un'istanza database SQL Server in un bucket Amazon S3
Per aggiornare i file da un'istanza database RDS for SQL Server in un bucket S3, usa la stored procedure Amazon RDS `msdb.dbo.rds_upload_to_s3` con i seguenti parametri.
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `@s3_arn_of_file` | NVARCHAR | – | Campo obbligatorio | L'ARN S3 del file da creare in S3, ad esempio: `arn:aws:s3:::amzn-s3-demo-bucket/mydata.csv` |
| `@rds_file_path` | NVARCHAR | – | Campo obbligatorio | Il percorso del file da caricare in S3. Sono supportati percorsi assoluti e relativi. |
| `@overwrite_file` | INT | – | Facoltativo | Sovrascrittura del file esistente: 0 = Non sovrascrivere 1 = Sovrascrivi |
L'esempio seguente carica il file denominato `data.csv` dal percorso specificato in `D:\S3\seed_data\` nel file `new_data.csv` del bucket S3 specificato dall'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 il file esisteva in precedenza in S3, viene sovrascritto perché il parametro @overwrite\$1file è impostato su `1`.
# Visualizzazione di file nell'istanza database RDS
Per elencare i file disponibili nell'istanza database, si utilizza sia una stored procedure che una funzione. Innanzitutto, esegui la seguente stored procedure per raccogliere i dettagli dai file in `D:\S3\`.
```
exec msdb.dbo.rds_gather_file_details;
```
La stored procedure restituisce l'ID dell'attività. Come altre attività, questa stored procedure viene eseguita in modo asincrono. Non appena lo stato dell'attività diventa `SUCCESS`, puoi usare l'ID attività nella funzione `rds_fn_list_file_details` per elencare i file e le directory esistenti in D:\$1S3\$1, come indicato di seguito.
```
SELECT * FROM msdb.dbo.rds_fn_list_file_details(TASK_ID);
```
La funzione `rds_fn_list_file_details` restituisce una tabella con le seguenti colonne:
| Parametro di output | Descrizione |
| --- | --- |
| filepath | Percorso assoluto del file (ad esempio, D:\$1S3\$1mydata.csv) |
| size\$1in\$1bytes | Dimensione del file (in byte) |
| last\$1modified\$1utc | Data e ora dell'ultima modifica in formato UTC |
| is\$1directory | Opzione che indica se l'elemento è una directory (true/false) |
# Eliminazione di file nell'istanza database RDS
Per eliminare i file disponibili nell'istanza DB, utilizza la stored procedure Amazon RDS `msdb.dbo.rds_delete_from_filesystem` con i seguenti parametri.
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `@rds_file_path` | NVARCHAR | – | Campo obbligatorio | Il percorso del file da eliminare. Sono supportati percorsi assoluti e relativi. |
| `@force_delete` | INT | 0 | Facoltativo | Per eliminare una directory, questo flag deve essere incluso e impostato su `1`. `1` = Elimina una directory Questo parametro viene ignorato se si elimina un file. |
Per eliminare una directory, `@rds_file_path` deve terminare con una barra (`\`) e `@force_delete` deve essere impostato su `1`.
L'esempio seguente elimina il file `D:\S3\delete_me.txt`.
```
exec msdb.dbo.rds_delete_from_filesystem
@rds_file_path='D:\S3\delete_me.txt';
```
L'esempio seguente elimina la directory `D:\S3\example_folder\`.
```
exec msdb.dbo.rds_delete_from_filesystem
@rds_file_path='D:\S3\example_folder\',
@force_delete=1;
```
# Monitoraggio dello stato di un'attività di trasferimento di file
Per tenere traccia dello stato dell'attività di integrazione di S3, chiama la funzione `rds_fn_task_status` che accetta due parametri. Il primo parametro deve essere sempre `NULL` perché non si applica all'integrazione di S3. Il secondo parametro accetta un ID attività.
Per visualizzare l'elenco di tutte le attività, imposta il primo parametro su `NULL` e il secondo parametro su `0`, come indicato nell'esempio seguente.
```
SELECT * FROM msdb.dbo.rds_fn_task_status(NULL,0);
```
Per ottenere un'attività specifica, imposta il primo parametro su `NULL` e il secondo parametro sull'ID attività, come indicato nell'esempio seguente.
```
SELECT * FROM msdb.dbo.rds_fn_task_status(NULL,42);
```
La funzione `rds_fn_task_status` restituisce le seguenti informazioni.
| Parametro di output | Descrizione |
| --- | --- |
| `task_id` | L'ID dell'attività. |
| `task_type` | Per l'integrazione di S3, le attività possono avere i seguenti tipi: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Appendix.SQLServer.Options.S3-integration.using.monitortasks.html) |
| `database_name` | Non applicabile alle attività di integrazione di S3. |
| `% complete` | L'avanzamento dell'attività espresso come percentuale. |
| `duration(mins)` | La quantità di tempo dedicato all'attività, in minuti. |
| `lifecycle` | Lo stato dell'attività. I possibili stati sono i seguenti: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Appendix.SQLServer.Options.S3-integration.using.monitortasks.html) |
| `task_info` | Ulteriori informazioni sull'attività. Se si verifica un errore durante l'elaborazione, questa colonna contiene informazioni sull'errore. |
| `last_updated` | La data e l'ora dell'ultimo aggiornamento dello stato dell'attività. |
| `created_at` | La data e l'ora di creazione dell'attività. |
| `S3_object_arn` | L'ARN dell'oggetto S3 scaricato o caricato. |
| `overwrite_S3_backup_file` | Non applicabile alle attività di integrazione di S3. |
| `KMS_master_key_arn` | Non applicabile alle attività di integrazione di S3. |
| `filepath` | Il percorso del file nell'istanza database RDS. |
| `overwrite_file` | Opzione che indica se un file esistente viene sovrascritto. |
| `task_metadata` | Non applicabile alle attività di integrazione di S3. |
# Annullamento di un'attività
Per annullare le attività di integrazione di S3, utilizzare la stored procedure `msdb.dbo.rds_cancel_task` con il parametro `task_id`. Le attività di eliminazione ed elenco in corso non possono essere annullate. L'esempio seguente mostra una richiesta per annullare un'attività.
```
exec msdb.dbo.rds_cancel_task @task_id = 1234;
```
Per ottenere una panoramica di tutte le attività e dei relativi ID attività, utilizza la funzione `rds_fn_task_status` come descritto in [Monitoraggio dello stato di un'attività di trasferimento di file](Appendix.SQLServer.Options.S3-integration.using.monitortasks.md).
## Limitazioni Multi-AZ per l'integrazione S3
Nelle istanze Multi-AZ, i file nella cartella `D:\S3` vengono eliminati nella replica di standby dopo un failover. Un failover può essere pianificato, ad esempio, durante le modifiche dell'istanza database, come la modifica della classe di istanza o l'aggiornamento della versione del motore. Oppure un failover può essere non pianificato, durante un'interruzione dell'istanza primaria.
**Nota**
Non è consigliabile utilizzare la cartella `D:\S3` per lo storage di file. La best practice consiste nel caricare i file creati in Amazon S3 per renderli durevoli e scaricare i file quando è necessario importare i dati.
Per determinare l'ora dell'ultimo failover, puoi utilizzare la stored procedure `msdb.dbo.rds_failover_time`. Per ulteriori informazioni, consulta [Individuazione dell’ora dell’ultimo failover per Amazon RDS per SQL Server](Appendix.SQLServer.CommonDBATasks.LastFailover.md).
**Example di nessun failover recente**
Questo esempio mostra l'output quando il log degli errori non contiene alcun failover recente. Nessun failover si è verificato dal 29-04-2020 alle 23:59:00.01.
Pertanto, tutti i file scaricati dopo tale ora che non sono stati eliminati utilizzando la stored procedure `rds_delete_from_filesystem` sono ancora accessibili sull'host corrente. Anche i file scaricati prima di tale ora potrebbero essere disponibili.
| errorlog\$1available\$1from | recent\$1failover\$1time |
| --- | --- |
| 2020-04-29 23:59:00.0100000 | null |
**Example di failover recente**
Questo esempio mostra l'output quando il log degli errori contiene un failover. Il failover più recente è stato il 05-05-2020 alle 18:57:51.89.
Tutti i file scaricati dopo quest'ora che non sono stati eliminati utilizzando la stored procedure `rds_delete_from_filesystem` sono ancora accessibili sull'host corrente.
| errorlog\$1available\$1from | recent\$1failover\$1time |
| --- | --- |
| 2020-04-29 23:59:00.0100000 | 2020-05-05 18:57:51.8900000 |
# Disabilitazione dell'integrazione di RDS for SQL Server con S3
Nella sezione seguente sono riportate le indicazioni per disabilitare l'integrazione di Amazon S3 con Amazon RDS for SQL Server. I file in `D:\S3\` non vengono eliminati quando si disabilita l'integrazione S3.
**Nota**
Per rimuovere un ruolo IAM da un'istanza database, lo stato dell'istanza database deve essere `available`.
## Console
**Per dissociare il ruolo IAM dall'istanza database**
1. Accedi alla Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Scegli il nome dell'istanza database RDS for SQL Server per visualizzarne i dettagli.
1. Nella sezione **Manage IAM roles (Gestisci ruoli IAM)** della scheda **Connectivity & security (Connettività e sicurezza)**, scegliere il ruolo IAM da rimuovere.
1. Scegliere **Delete (Elimina)**.
## AWS CLI
**Per rimuovere il ruolo IAM dall'istanza database RDS for SQL Server**
+ Il seguente comando di AWS CLI rimuove il ruolo IAM da un'istanza database RDS for SQL Server denominata `mydbinstance`.
**Example**
Per Linux, macOS o Unix:
```
aws rds remove-role-from-db-instance \
--db-instance-identifier mydbinstance \
--feature-name S3_INTEGRATION \
--role-arn your-role-arn
```
Per Windows:
```
aws rds remove-role-from-db-instance ^
--db-instance-identifier mydbinstance ^
--feature-name S3_INTEGRATION ^
--role-arn your-role-arn
```
Sostituire `your-role-arn` con l'ARN del ruolo IAM appropriato per l'opzione `--feature-name`.
# Utilizzo di Database Mail su Amazon RDS for SQL Server
Puoi utilizzare Database Mail per inviare messaggi di posta elettronica agli utenti da Amazon RDS dall'istanza database di SQL Server. I messaggi possono contenere file e risultati delle query. Database Mail include i seguenti componenti:
+ **Oggetti di configurazione e sicurezza** – Questi oggetti creano profili e account e sono memorizzati nel database `msdb`.
+ **Oggetti di messaggistica** – Questi oggetti includono la stored procedure [sp\$1send\$1dbmail](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-send-dbmail-transact-sql) utilizzata per inviare messaggi e strutture di dati che contengono informazioni sui messaggi. Sono memorizzati nel database `msdb`.
+ **Oggetti di registrazione e controllo** – Database Mail scrive le informazioni di registrazione nel database `msdb` e nel registro eventi applicazioni di Microsoft Windows.
+ **Eseguibile di Database Mail** – `DatabaseMail.exe` legge da una coda nel database `msdb` e invia messaggi di posta elettronica.
RDS supporta Database Mail per tutte le versioni di SQL Server nelle edizioni Web, Standard ed Enterprise.
## Limitazioni
Le seguenti limitazioni si applicano all'utilizzo di posta elettronica di database nell'istanza database di SQL Server:
+ Database Mail non è supportato per SQL Server Express Edition.
+ La modifica dei parametri di configurazione di Database Mail non è supportata. Per visualizzare i valori predefiniti, utilizza la stored procedure [sysmail\$1help\$1configure\$1sp](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-help-configure-sp-transact-sql) .
+ Gli allegati dei file non sono completamente supportati. Per ulteriori informazioni, consulta [Utilizzo di file allegati](#SQLServer.DBMail.Files).
+ La dimensione massima del file allegato è 1 MB.
+ Database Mail richiede una configurazione aggiuntiva su istanze database multi-AZ. Per ulteriori informazioni, consulta [Considerazioni per le implementazioni Multi-AZ](#SQLServer.DBMail.MAZ).
+ La configurazione di SQL Server Agent per l'invio di messaggi di posta elettronica agli operatori predefiniti non è supportata.
# Abilitazione di Database Mail
Per abilitare Database Mail per l'istanza database, completa la seguente procedura:
1. Crea un nuovo set di parametri.
1. Modificare il gruppo di parametri per impostare il parametro `database mail xps` su 1 o 2.
1. Associa il nuovo gruppo di parametri all'istanza database.
## Creazione del gruppo di parametri per Database Mail
Crea o modifica un gruppo di parametri per il parametro `database mail xps` corrispondente all'edizione di SQL Server e alla versione dell'istanza database.
**Nota**
Puoi anche modificare un gruppo di parametri esistente. Segui la procedura riportata in [Modifica del parametro che abilita Database Mail](#DBMail.ModifyParamGroup).
### Console
Nell'esempio seguente viene creato un gruppo di parametri per SQL Server Standard Edition 2016.
**Per creare il gruppo di parametri**
1. Accedi a Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nel pannello di navigazione, scegli **Parameter groups** (Gruppi di parametri).
1. Scegliere **Create parameter group (Crea gruppo di parametri)**.
1. Nel riquadro **Create parameter group (Crea gruppi di parametri)**, procedi nel modo seguente:
1. Per **Famiglia del gruppo di parametri**, scegliere **sqlserver-se-13.0**.
1. Per **Group name (Nome gruppo)**, immettere un identificatore per il gruppo di parametri, ad esempio **dbmail-sqlserver-se-13**.
1. Per **Description (Descrizione)**, immettere **Database Mail XPs**.
1. Scegliere **Create (Crea)**.
### CLI
Nell'esempio seguente viene creato un gruppo di parametri per SQL Server Standard Edition 2016.
**Per creare il gruppo di parametri**
+ Utilizzare uno dei seguenti comandi.
**Example**
Per Linux, macOS o 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"
```
Per 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"
```
## Modifica del parametro che abilita Database Mail
Modifica il parametro `database mail xps` nel gruppo di parametri che corrisponde all'edizione di SQL Server e alla versione dell'istanza database.
Per abilitare Database Mail, imposta il `database mail xps` parametro su 1.
### Console
Nell'esempio seguente il gruppo di parametri creato per SQL Server Standard Edition 2016 viene modificato.
**Per modificare il gruppo di parametri**
1. Accedi a Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nel riquadro di navigazione scegliere **Parameter groups (Gruppi di parametri)**.
1. Scegli il gruppo di parametri, ad esempio **dbmail-sqlserver-se-13**.
1. In **Parameters (Parametri)**, filtrare l'elenco dei parametri per **mail**.
1. Seleziona **database mail xps**.
1. Scegliere **Edit parameters (Modifica parametri)**.
1. Specificare (sì **1**.
1. Scegli **Save changes** (Salva modifiche).
### CLI
Nell'esempio seguente il gruppo di parametri creato per SQL Server Standard Edition 2016 viene modificato.
**Per modificare il gruppo di parametri**
+ Utilizzare uno dei seguenti comandi.
**Example**
Per Linux, macOS o Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name dbmail-sqlserver-se-13 \
--parameters "ParameterName='database mail xps',ParameterValue=1,ApplyMethod=immediate"
```
Per Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name dbmail-sqlserver-se-13 ^
--parameters "ParameterName='database mail xps',ParameterValue=1,ApplyMethod=immediate"
```
## Associazione del gruppo di parametri all'istanza database
È possibile utilizzare Console di gestione AWS o the AWS CLI per associare il gruppo di parametri Database Mail all'istanza DB.
### Console
Puoi associare il gruppo di parametri di Database Mail a un'istanza database nuova o esistente.
+ Per una nuova istanza database, associarli all'avvio dell'istanza. Per ulteriori informazioni, consulta [Creazione di un'istanza database Amazon RDS](USER_CreateDBInstance.md).
+ Per un'istanza database esistente, associarli modificando l'istanza. Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
### CLI
Puoi associare il gruppo di parametri di Database Mail a un'istanza database nuova o esistente.
**Per creare un'istanza database con il gruppo di parametri di Database Mail**
+ Specificare lo stesso tipo di motore di database e la versione principale utilizzati durante la creazione del gruppo di parametri.
**Example**
Per Linux, macOS o 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
```
Per 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
```
**Per modificare un'istanza database e associare il gruppo di parametri di Database Mail**
+ Utilizzare uno dei seguenti comandi.
**Example**
Per Linux, macOS o Unix:
```
aws rds modify-db-instance \
--db-instance-identifier mydbinstance \
--db-parameter-group-name dbmail-sqlserver-se-13 \
--apply-immediately
```
Per Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier mydbinstance ^
--db-parameter-group-name dbmail-sqlserver-se-13 ^
--apply-immediately
```
# Configurazione di Database Mail
Per configurare Database Mail, puoi completare le attività riportate di seguito.
1. Crea il profilo Database Mail.
1. Crea l'account Database Mail.
1. Aggiungi l'account Database Mail al profilo Database Mail.
1. Aggiungi utenti al profilo Database Mail.
**Nota**
Per configurare Database Mail, assicurati di disporre delle autorizzazioni `execute` per le stored procedure nel database `msdb`.
## Creazione del profilo Database Mail
Per creare il profilo Database Mail, utilizza la stored procedure [sysmail\$1add\$1profile\$1sp](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-profile-sp-transact-sql) . Nell’esempio seguente viene creato un profilo denominato `Notifications`.
**Per creare il profilo**
+ Utilizza la seguente istruzione 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
```
## Creazione dell'account Database Mail
Per creare l'account Database Mail, utilizza la stored procedure [sysmail\$1add\$1account\$1sp](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-account-sp-transact-sql) . Nell'esempio seguente viene creato un account denominato `SES` in un'istanza DB RDS per SQL Server in un VPC privato utilizzando Amazon Simple Email Service.
L'utilizzo di Amazon SES richiede i parametri seguenti:
+ `@email_address`: un'identità verificata da Amazon SES. Per ulteriori informazioni su , consulta [Verifica delle identità in Amazon SES](https://docs.aws.amazon.com/ses/latest/dg/verify-addresses-and-domains.html).
+ `@mailserver_name`: un endpoint SMTP Amazon SES. Per ulteriori informazioni, consulta [Connessione a un endpoint SMTP Amazon SES](https://docs.aws.amazon.com/ses/latest/dg/smtp-connect.html).
+ `@username`: un nome utente SMTP Amazon SES. Per ulteriori informazioni, consulta [Come ottenere le credenziali SMTP in Amazon SES](https://docs.aws.amazon.com/ses/latest/dg/smtp-credentials.html).
Non utilizzare un nome AWS Identity and Access Management utente.
+ `@password`: password SMTP Amazon SES. Per ulteriori informazioni, consulta [Come ottenere le credenziali SMTP in Amazon SES](https://docs.aws.amazon.com/ses/latest/dg/smtp-credentials.html).
**Per creare l'account**
+ Utilizza la seguente istruzione 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**
Specifica credenziali diverse dai prompt mostrati qui come best practice per la sicurezza.
## Aggiunta dell'account Database Mail al profilo Database Mail
Per aggiungere l'account Database Mail al profilo Database Mail, utilizza la stored procedure [sysmail\$1add\$1profileaccount\$1sp](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-profileaccount-sp-transact-sql) . Nell'esempio seguente viene aggiunto l'account `SES` al profilo `Notifications`.
**Per aggiungere l'account al profilo**
+ Utilizza la seguente istruzione SQL.
```
USE msdb
GO
EXECUTE msdb.dbo.sysmail_add_profileaccount_sp
@profile_name = 'Notifications',
@account_name = 'SES',
@sequence_number = 1;
GO
```
## Aggiunta di utenti al profilo Database Mail
Per concedere l'autorizzazione a un principal di database `msdb` per l'utilizzo di un profilo Database Mail, utilizza la stored procedure [sysmail\$1add\$1principalprofile\$1sp](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sysmail-add-principalprofile-sp-transact-sql) . Un *principal* è un'entità che può richiedere risorse di SQL Server. Il principal del database deve essere mappato a un utente di autenticazione di SQL Server, un utente di autenticazione di Windows o un gruppo di autenticazione di Windows.
Nell'esempio seguente viene concesso l'accesso pubblico al profilo `Notifications`.
**Per aggiungere un utente al profilo**
+ Utilizza la seguente istruzione SQL.
```
USE msdb
GO
EXECUTE msdb.dbo.sysmail_add_principalprofile_sp
@profile_name = 'Notifications',
@principal_name = 'public',
@is_default = 1;
GO
```
## Amazon RDS stored procedure e funzioni per Database Mail
Microsoft fornisce [Procedure archiviate](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/database-mail-stored-procedures-transact-sql) per l'utilizzo di Mail database, ad esempio la creazione, l'elenco, l'aggiornamento ed eliminazione di account e profili. Inoltre, RDS fornisce le stored procedure e le funzioni per Database Mail riportate nella tabella seguente.
| Stored procedure/Funzione | Descrizione |
| --- | --- |
| rds\$1fn\$1sysmail\$1allitems | Mostra i messaggi inviati, inclusi quelli inviati da altri utenti. |
| rds\$1fn\$1sysmail\$1event\$1log | Mostra gli eventi, inclusi quelli relativi ai messaggi inviati da altri utenti. |
| rds\$1fn\$1sysmail\$1mailattachments | Mostra gli allegati, inclusi quelli inviati da altri utenti. |
| rds\$1sysmail\$1control | Avvia e arresta la coda di posta elettronica (processo DatabaseMail.exe). |
| rds\$1sysmail\$1delete\$1mailitems\$1sp | Elimina i messaggi di posta elettronica inviati da tutti gli utenti dalle tabelle interne a Database Mail. |
# Invio di messaggi di posta elettronica tramite Database Mail
Per inviare messaggi di posta elettronica utilizzando Database Mail, puoi utilizzare la stored procedure [sp\$1send\$1dbmail](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-send-dbmail-transact-sql).
## Utilizzo
```
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]';
```
I parametri seguenti sono obbligatori:
+ `@profile_name` – Il nome del profilo Database Mail da cui inviare il messaggio.
+ `@recipients` – L’elenco delimitato da punto e virgola di indirizzi di posta elettronica a cui inviare il messaggio.
+ `@subject` – L'oggetto del messaggio.
+ `@body` – Il corpo del messaggio. Puoi inoltre utilizzare una variabile dichiarata come corpo.
I parametri seguenti sono facoltativi:
+ `@body_format` – Questo parametro viene utilizzato con una variabile dichiarata per inviare e-mail in formato HTML.
+ `@file_attachments` – L’elenco delimitato da punto e virgola degli allegati dei messaggi. I percorsi dei file devono essere percorsi assoluti.
+ `@query` – Una query SQL da eseguire. I risultati della query possono essere allegati come file o inclusi nel corpo del messaggio.
+ `@attach_query_result_as_file` – Indica se allegare il risultato della query come file. Imposta su 0 per no, 1 per sì. Il valore predefinito è 0.
## Esempi
Negli esempi seguenti viene illustrato come inviare messaggi di posta elettronica.
**Example di invio di un messaggio a un singolo destinatario**
```
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 di invio di un messaggio a più destinatari**
```
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 di invio di un risultato di una query SQL come file allegato**
```
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 di invio di un messaggio in 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 di invio di un messaggio utilizzando un trigger quando si verifica un evento specifico nel database**
```
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
```
# Visualizzazione di messaggi, log e allegati
È possibile utilizzare le stored procedure RDS per visualizzare messaggi, log di eventi e allegati.
**Per visualizzare tutti i messaggi di posta elettronica**
+ Digita la seguente query SQL:
```
SELECT * FROM msdb.dbo.rds_fn_sysmail_allitems(); --WHERE sent_status='sent' or 'failed' or 'unsent'
```
**Per visualizzare tutti i log di eventi di posta elettronica**
+ Digita la seguente query SQL:
```
SELECT * FROM msdb.dbo.rds_fn_sysmail_event_log();
```
**Per visualizzare tutti gli allegati di posta elettronica**
+ Digita la seguente query SQL:
```
SELECT * FROM msdb.dbo.rds_fn_sysmail_mailattachments();
```
# Eliminazione dei messaggi
Per eliminare i messaggi, puoi utilizzare la stored procedure `rds_sysmail_delete_mailitems_sp`.
**Nota**
RDS elimina automaticamente gli elementi della tabella di posta quando i dati della cronologia di DBMail raggiungono le dimensioni di 1 GB, con un periodo di conservazione di almeno 24 ore.
Se desideri conservare gli elementi di posta per un periodo più lungo, puoi archiviarli. Per maggiori informazioni, consulta [Creazione di un processo di SQL Server Agent per archiviare i messaggi di Database Mail e i log di eventi](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) nella documentazione di Microsoft.
**Per eliminare tutti i messaggi di posta elettronica**
+ Utilizza la seguente istruzione SQL.
```
DECLARE @GETDATE datetime
SET @GETDATE = GETDATE();
EXECUTE msdb.dbo.rds_sysmail_delete_mailitems_sp @sent_before = @GETDATE;
GO
```
**Per eliminare tutti i messaggi di posta elettronica con uno stato particolare**
+ Utilizza la seguente istruzione SQL per eliminare tutti i messaggi non riusciti.
```
DECLARE @GETDATE datetime
SET @GETDATE = GETDATE();
EXECUTE msdb.dbo.rds_sysmail_delete_mailitems_sp @sent_status = 'failed';
GO
```
# Avvio e arresto della coda di posta
Per avviare e arrestare la coda di posta del database utilizza le seguenti istruzioni:
**Topics**
+ [
## Avvio della coda di posta
](#SQLServer.DBMail.Start)
+ [
## Arresto della coda di posta
](#SQLServer.DBMail.Stop)
## Avvio della coda di posta
Per avviare il processo Database Mail, utilizza la stored procedure `rds_sysmail_control` .
**Nota**
L'abilitazione di Database Mail avvia automaticamente la coda di posta.
**Per avviare la coda di posta**
+ Utilizza la seguente istruzione SQL.
```
EXECUTE msdb.dbo.rds_sysmail_control start;
GO
```
## Arresto della coda di posta
Per arrestare il processo di Database Mail, utilizza la stored procedure `rds_sysmail_control`.
**Per arrestare la coda di posta**
+ Utilizza la seguente istruzione SQL.
```
EXECUTE msdb.dbo.rds_sysmail_control stop;
GO
```
## Utilizzo di file allegati
Le seguenti estensioni di file allegati non sono supportate nei messaggi di Database Mail provenienti da RDS su 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, .wsc, .wsf e .wsh.
Database Mail utilizza il contesto di protezione di Microsoft Windows dell'utente corrente per controllare l'accesso ai file. Gli utenti che accedono con l'autenticazione di SQL Server non possono allegare file utilizzando il parametro `@file_attachments` con la stored procedure `sp_send_dbmail`. Windows non consente a SQL Server di fornire le credenziali da un computer remoto a un altro computer remoto. Di conseguenza, Database Mail non può allegare file da una condivisione di rete quando il comando viene eseguito da un computer diverso dal computer che esegue SQL Server.
Tuttavia, per allegare i file puoi utilizzare i processi di SQL Server Agent. Per ulteriori informazioni su SQL Server Agent, consulta [Utilizzo di SQL Server Agent per Amazon RDS](Appendix.SQLServer.CommonDBATasks.Agent.md) e [SQL Server Agent](https://docs.microsoft.com/en-us/sql/ssms/agent/sql-server-agent) nella documentazione Microsoft.
## Considerazioni per le implementazioni Multi-AZ
Quando configuri Database Mail in un'istanza database Multi-AZ, la configurazione non viene propagata automaticamente al nodo secondario. Si consiglia di convertire l'istanza Multi-AZ in un'istanza Single-AZ, configurare Database Mail e quindi riconvertire l'istanza database in Multi-AZ. In questo modo, entrambi i nodi primario e secondario avranno la configurazione di Database Mail.
Se crei una replica di lettura dall'istanza Multi-AZ in cui è configurato Database Mail, la replica eredita la configurazione, ma senza la password sul server SMTP. Aggiorna l'account Database Mail con la password.
## Rimozione della restrizione SMTP (porta 25)
Per impostazione predefinita, AWS blocca il traffico in uscita su SMTP (porta 25) per le istanze database RDS per SQL Server. Questa impostazione consente di prevenire lo spam in base alle policy del proprietario dell’interfaccia di rete elastica. È possibile rimuovere la restrizione, se necessario. Per ulteriori informazioni, consulta [Come posso rimuovere la restrizione sulla porta 25 dalla mia istanza Amazon EC2 o dalla mia funzione Lambda?](https://repost.aws/knowledge-center/ec2-port-25-throttle)
# Supporto dell'archivio istanze per il database tempdb su Amazon RDS for SQL Server
Un *archivio istanze* fornisce uno storage temporaneo di livello per l’istanza database. Lo storage è collocato all'interno dei dischi fisicamente collegati al computer host. Questi dischi dispongono di storage di istanza NVMe (Non-Volatile Memory Express) basata su unità a stato solido (SSD). Questo storage è ottimizzato per bassa latenza, prestazioni I/O casuali molto elevate ed elevata velocità di lettura sequenziale.
Inserendo i file di dati `tempdb` e i file di log `tempdb` nell'archivio istanze, sarà possibile ottenere latenze di lettura e scrittura inferiori rispetto allo storage standard basato su Amazon EBS.
**Nota**
I file di database di SQL Server e i file di log del database non vengono inseriti nell'archivio istanze.
## Abilitazione dell'archivio istanze
Quando RDS esegue il provisioning di istanze database con una delle seguenti classi di istanza, il database `tempdb` viene automaticamente inserito nell'archivio istanze:
+ db.m5d
+ db.r5d
+ db.x2iedn
Per abilitare l'archivio istanze, effettua una delle seguenti operazioni:
+ Crea un'istanza database di SQL Server utilizzando uno di questi tipi di istanza. Per ulteriori informazioni, consulta [Creazione di un'istanza database Amazon RDS](USER_CreateDBInstance.md).
+ Modifica un'istanza database di SQL Server esistente per utilizzarne una. Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
L'archivio istanze è disponibile in tutte le regioni AWS in cui sono supportati uno o più di questi tipi di istanza. Per ulteriori informazioni sulle classi di istanza `db.m5d` e `db.r5d`, consulta [Classi di istanze DB ](Concepts.DBInstanceClass.md). Per ulteriori informazioni sulle classi di istanza supportate da Amazon RDS for SQL Server, consulta [Supporto classe istanza database per Microsoft SQL Server](SQLServer.Concepts.General.InstanceClasses.md).
## Considerazioni sulla posizione e sulle dimensioni dei file
Nelle istanze senza un archivio di istanze, RDS memorizza i file di dati e di log `tempdb` nella directory `D:\rdsdbdata\DATA`. Entrambi i file iniziano da 8 MB per impostazione predefinita.
Nelle istanze con un archivio istanze, RDS memorizza i file di dati e di log `tempdb` nella directory `T:\rdsdbdata\DATA`.
Quando `tempdb` ha un solo file di dati (`tempdb.mdf`) e un file di log (`templog.ldf`), `templog.ldf` inizia da 8 MB per impostazione predefinita e `tempdb.mdf` inizia all'80% o più della capacità di archiviazione dell'istanza. Il 20% della capacità di storage o 200 GB, a seconda di quale sia inferiore, viene mantenuto libero per iniziare. Più file di dati `tempdb` dividono uniformemente l'80% dello spazio su disco, mentre i file di log hanno sempre una dimensione iniziale di 8 MB.
Ad esempio, se si modifica la classe di istanza database da `db.m5.2xlarge` a `db.m5d.2xlarge`, la dimensione dei file di dati `tempdb` aumenta da 8 MB ciascuno a 234 GB in totale.
**Nota**
Oltre ai file di dati e di log di `tempdb` nell'archivio istanze (`T:\rdsdbdata\DATA`), puoi ancora creare file di dati e file di log `tempdb` nel volume di dati (`D:\rdsdbdata\DATA`). Questi file hanno sempre una dimensione iniziale di 8 MB.
## Considerazioni sul backup
Potrebbe essere necessario conservare i backup per lunghi periodi, con costi nel tempo. I blocchi di dati e log di `tempdb` possono cambiare molto spesso a seconda del carico di lavoro. Ciò può aumentare notevolmente la dimensione degli snapshot del database.
Quando si `tempdb` trova nell'archivio istanze, le istantanee non includono file temporanei. Ciò significa che le dimensioni degli snapshot sono più piccole e consumano meno l'allocazione di backup gratuita rispetto allo storage solo EBS.
## Errori di disco pieno
Se si utilizza tutto lo spazio disponibile nell'archivio istanze, è possibile che vengano visualizzati errori come i seguenti:
+ Il log delle transazioni per il database 'tempdb' è pieno a causa di 'ACTIVE\$1TRANSACTION '.
+ Impossibile allocare spazio per l'oggetto 'dbo.sort temporanea di archiviazione esecuzione: 140738941419520' nel database 'tempdb' perché il filegroup 'PRIMARY' è pieno. Crea spazio su disco eliminando i file non necessari, rilasciando oggetti nel gruppo di file, aggiungendo altri file al gruppo di file o impostando il parametro autogrowth per i file esistenti nel gruppo di file.
È possibile eseguire una o più delle seguenti operazioni quando l'archivio istanze è pieno:
+ Regola il carico di lavoro o il modo in cui utilizzi `tempdb`.
+ Scala fino all'utilizzo di una classe di istanza database con più storage NVMe.
+ Interrompi l'utilizzo dell'archivio istanze e utilizza una classe di istanza con solo storage EBS.
+ Utilizza una modalità mista aggiungendo dati secondari o file di log per `tempdb` sul volume EBS.
## Rimozione dell'archivio istanze
Per rimuovere l'archivio dell'istanza, modifica l'istanza database di SQL Server per utilizzare un tipo di istanza che non supporta l'archivio dell'istanza, ad esempio db.m5, db.r5 o db.x1e.
**Nota**
Quando rimuovi l'archivio istanze, i file temporanei vengono spostati nella directory `D:\rdsdbdata\DATA` e le dimensioni sono ridotte a 8 MB.
# Utilizzo di eventi estesi con Amazon RDS per Microsoft SQL Server
È possibile utilizzare eventi estesi in Microsoft SQL Server per acquisire informazioni di debug e risoluzione dei problemi per Amazon RDS for SQL Server. Gli eventi estesi sostituiscono SQL Trace e Server Profiler, che sono stati deprecati da Microsoft. Gli eventi estesi sono simili alle tracce del profiler, ma hanno un controllo più granulare sugli eventi tracciati. Gli eventi estesi sono supportati per SQL Server versioni 2016 e successive su Amazon RDS. Per ulteriori informazioni, consulta [Panoramica degli eventi estesi](https://docs.microsoft.com/en-us/sql/relational-databases/extended-events/extended-events) nella documentazione di Microsoft.
Gli eventi estesi vengono attivati automaticamente per gli utenti con privilegi utente master in Amazon RDS for SQL Server.
**Topics**
+ [
## Limitazioni e consigli
](#SQLServer.ExtendedEvents.Limits)
+ [
## Configurazione di eventi estesi su RDS per SQL Server
](#SQLServer.ExtendedEvents.Config)
+ [
## Considerazioni per le implementazioni Multi-AZ
](#SQLServer.ExtendedEvents.MAZ)
+ [
## Esecuzione di query sui file di eventi estesi
](#SQLServer.ExtendedEvents.Querying)
## Limitazioni e consigli
Quando si utilizzano eventi estesi su RDS per SQL Server, si applicano le seguenti limitazioni:
+ Gli eventi estesi sono supportati solo per le edizioni Enterprise e Standard.
+ Non è possibile modificare le sessioni degli eventi estesi predefinite.
+ Assicurati di impostare la modalità di partizione della memoria della sessione su `NONE`.
+ La modalità di conservazione degli eventi della sessione può essere `ALLOW_SINGLE_EVENT_LOSS` o `ALLOW_MULTIPLE_EVENT_LOSS`.
+ Le destinazioni di traccia eventi per Windows (ETW) non sono supportate.
+ Assicurati che le destinazioni dei file siano nella directory `D:\rdsdbdata\log`.
+ Per le destinazioni corrispondenti alle coppie, imposta la proprietà `respond_to_memory_pressure` su `1`.
+ La memoria di destinazione del buffer ring non può essere maggiore di 4 MB.
+ Le seguenti azioni non sono supportate:
+ `debug_break`
+ `create_dump_all_threads`
+ `create_dump_single_threads`
+ L'evento `rpc_completed` è supportato nelle seguenti versioni: 15.0.4083.2, 14.0.3370.1, 13.0.5865.1, 12.0.6433.1, 11.0.7507.2 e nelle versioni successive.
## Configurazione di eventi estesi su RDS per SQL Server
In RDS per SQL Server, è possibile configurare i valori di determinati parametri delle sessioni degli eventi estesi. Nella tabella seguente vengono descritti i parametri configurabili.
| Nome del parametro | Descrizione | Valore predefinito RDS | Valore minimo | Valore massimo |
| --- | --- | --- | --- | --- |
| xe\$1session\$1max\$1memory | Specifica la quantità massima di memoria da allocare alla sessione per il buffering degli eventi. Questo valore corrisponde all'impostazione max\$1memory della sessione evento. | 4 MB | 4 MB | 8 MB |
| xe\$1session\$1max\$1event\$1size | Specifica la dimensione massima di memoria consentita per eventi di grandi dimensioni. Questo valore corrisponde all'impostazione max\$1event\$1size della sessione evento. | 4 MB | 4 MB | 8 MB |
| xe\$1session\$1max\$1dispatch\$1latency | Specifica il tempo in cui gli eventi vengono memorizzati nel buffer prima di essere inviati alle destinazioni delle sessioni degli eventi estesi. Questo valore corrisponde all'impostazione max\$1dispatch\$1latency della sessione evento. | 30 secondi | 1 secondo | 30 secondi |
| xe\$1file\$1target\$1size | Specifica la dimensione massima della destinazione file. Questo valore corrisponde all'impostazione max\$1file\$1size della destinazione del file. | 100 MB | 10 MB | 1 GB |
| xe\$1file\$1retention | Specifica il tempo di conservazione (in giorni) per i file generati dalle destinazioni file delle sessioni eventi. | 7 giorni | 0 giorni | 7 giorni |
**Nota**
Impostando `xe_file_retention` su zero, i file .xel vengono rimossi automaticamente dopo il blocco di questi file viene rilasciato da SQL Server. Il blocco viene rilasciato ogni volta che un file con estensione .xel raggiunge il limite di dimensione impostato in `xe_file_target_size`.
È possibile utilizzare la stored procedure `rdsadmin.dbo.rds_show_configuration` per visualizzare i valori correnti di questi parametri. Ad esempio, utilizzare l'istruzione SQL seguente per visualizzare l'impostazione corrente di `xe_session_max_memory`.
```
exec rdsadmin.dbo.rds_show_configuration 'xe_session_max_memory'
```
È possibile utilizzare la stored procedure `rdsadmin.dbo.rds_set_configuration` per modificarle. Ad esempio, utilizzare l'istruzione SQL seguente per impostare `xe_session_max_memory` su 4 MB.
```
exec rdsadmin.dbo.rds_set_configuration 'xe_session_max_memory', 4
```
## Considerazioni per le implementazioni Multi-AZ
Quando si crea una sessione per un evento esteso in un'istanza DB primaria, la sessione non viene propagata alla replica in standby. È possibile eseguire il failover e creare la sessione dell’evento esteso nella nuova istanza DB primaria. In alternativa, è possibile rimuovere e aggiungere nuovamente la configurazione Multi-AZ per propagare la sessione di eventi estesi alla replica in attesa. RDS interrompe tutte le sessioni degli eventi estesi non predefinite sulla replica in standby, in modo che queste sessioni non utilizzino risorse in standby. Per questo motivo, dopo che una replica in standby diventa l'istanza DB primaria, assicurarsi di avviare manualmente le sessioni dell’evento esteso sul nuovo primario.
**Nota**
Questo approccio si applica sia ai gruppi di disponibilità Always On che al mirroring del database.
È inoltre possibile utilizzare un processo di SQL Server Agent per tenere traccia della replica in standby e avviare le sessioni se lo standby diventa primario. Ad esempio, utilizzare la seguente query nel passaggio del processo Agente SQL Server per riavviare le sessioni di eventi in un'istanza DB primaria.
```
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
```
Questa query riavvia le sessioni di evento `xe1` e `xe2` su un'istanza DB primaria se queste sessioni sono in uno stato interrotto. È inoltre possibile aggiungere una pianificazione con un intervallo conveniente a questa query.
## Esecuzione di query sui file di eventi estesi
È possibile utilizzare SQL Server Management Studio o la `sys.fn_xe_file_target_read_file` funzione per visualizzare i dati da eventi estesi che utilizzano destinazioni file. Per ulteriori informazioni su questa funzione, consulta [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) nella documentazione di Microsoft.
Le destinazioni dei file degli eventi estesi possono scrivere solo file nella directory `D:\rdsdbdata\log` su RDS for SQL Server.
Ad esempio, utilizzare la seguente query SQL per elencare il contenuto di tutti i file delle sessioni di eventi estesi i cui nomi iniziano con `xe`.
```
SELECT * FROM sys.fn_xe_file_target_read_file('d:\rdsdbdata\log\xe*', null,null,null);
```
# Accesso ai backup dei log delle transazioni con RDS per SQL Server
Con l'accesso ai backup dei log delle transazioni di RDS per SQL Server, puoi elencare i file di backup dei log delle transazioni per un database e copiarli in un bucket Amazon S3 di destinazione. Copiando i backup dei log delle transazioni in un bucket Amazon S3, puoi utilizzarli in combinazione con backup completi e differenziali del database per eseguire ripristini point-in-time del database. Utilizzi le stored procedure RDS per configurare l'accesso ai backup dei log delle transazioni, elencare i backup dei log delle transazioni disponibili e copiarli nel bucket Amazon S3.
L'accesso ai backup dei log delle transazioni offre le funzionalità e i vantaggi seguenti:
+ Elenca e visualizza i metadati dei backup dei log delle transazioni disponibili per un database su un'istanza database di RDS per SQL Server.
+ Copia i backup dei log delle transazioni disponibili da RDS per SQL Server in un bucket Amazon S3 di destinazione.
+ Esegui point-in-time ripristini dei database senza la necessità di ripristinare un'intera istanza DB. Per ulteriori informazioni sul ripristino point-in-time di un'istanza database, consulta [Ripristino di un’istanza database a un punto temporale specifico per Amazon RDS](USER_PIT.md).
## Disponibilità e supporto
L'accesso ai backup dei log delle transazioni è supportato in tutte le AWS regioni. L'accesso ai backup dei log delle transazioni è disponibile per tutte le edizioni e le versioni di Microsoft SQL Server supportate su Amazon RDS.
## Requisiti
I seguenti requisiti devono essere soddisfatti prima di consentire l'accesso ai backup dei log delle transazioni:
+ I backup automatici devono essere abilitati sull'istanza database e la conservazione del backup deve essere impostata su un valore di uno o più giorni. Per ulteriori informazioni sull'attivazione dei backup automatici e sulla configurazione di una policy di conservazione, consulta [Abilitazione dei backup automatici](USER_WorkingWithAutomatedBackups.Enabling.md).
+ Un bucket Amazon S3 deve trovarsi nello stesso account e nella stessa regione dell'istanza database di origine. Prima di abilitare l'accesso ai backup dei log delle transazioni, scegli un bucket Amazon S3 esistente o [crea un nuovo bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingaBucket.html) da utilizzare per i file di backup dei log delle transazioni.
+ Una policy di autorizzazione per i bucket Amazon S3 deve essere configurata come segue per consentire ad Amazon RDS di copiarvi i file di log delle transazioni:
1. Imposta la proprietà del proprietario dell'account dell'oggetto nel bucket su **Bucket Owner Preferred** (Proprietario preferito del bucket).
1. Aggiungi la policy seguente. Non ci sarà alcuna policy per impostazione predefinita, quindi utilizza le liste di controllo degli accessi (ACL) del bucket per modificare la policy del bucket e aggiungerla.
Nell'esempio che segue viene utilizzato un ARN per specificare la risorsa. Si consiglia di utilizzare le chiavi di contesto delle condizioni globali `SourceArn` e `SourceAccount` nelle relazioni di trust basate sulle risorse per limitare le autorizzazioni del servizio relative a una risorsa specifica. Per ulteriori informazioni su come lavorare con ARNs, consulta [Amazon resource names (ARNs)](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) e[Nomi della risorsa Amazon (ARN) in Amazon RDS](USER_Tagging.ARN.md).
**Example di policy di autorizzazione di Amazon S3 per l'accesso ai backup dei log delle transazioni**
------
#### [ 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}"
}
}
}
]
}
```
------
+ Un ruolo AWS Identity and Access Management (IAM) per accedere al bucket Amazon S3. Se disponi già di un ruolo IAM, puoi utilizzarlo. In alternativa, puoi scegliere che venga creato automaticamente un nuovo ruolo IAM quando aggiungi l'opzione `SQLSERVER_BACKUP_RESTORE` usando la Console di gestione AWS. In alternativa, è possibile crearne uno nuovo manualmente. Per ulteriori informazioni sulla creazione e la configurazione di un ruolo IAM con `SQLSERVER_BACKUP_RESTORE`, consulta [Creazione manuale di un ruolo IAM per backup e ripristino nativi](SQLServer.Procedural.Importing.Native.Enabling.md#SQLServer.Procedural.Importing.Native.Enabling.IAM).
+ L'opzione `SQLSERVER_BACKUP_RESTORE` deve essere aggiunta a un gruppo di opzioni nella tua istanza database. Per ulteriori informazioni sull'aggiunta dell'opzione `SQLSERVER_BACKUP_RESTORE`, consulta [Supporto per backup nativo e ripristino in SQL Server](Appendix.SQLServer.Options.BackupRestore.md).
**Nota**
Se l'istanza DB ha la crittografia dello storage abilitata, le azioni e la chiave AWS KMS (KMS) devono essere fornite nel ruolo IAM fornito nel gruppo di opzioni di backup e ripristino nativo.
Facoltativamente, se intendi utilizzare la stored procedure `rds_restore_log` per eseguire ripristini point-in-time del database, ti consigliamo di utilizzare lo stesso percorso Amazon S3 per il gruppo di opzioni di backup e ripristino nativo e l'accesso ai backup dei log delle transazioni. Questo metodo garantisce che, quando Amazon RDS assume il ruolo del gruppo di opzioni per eseguire le funzioni del log di ripristino, abbia accesso ai backup dei log delle transazioni dallo stesso percorso di Amazon S3.
+ Se l'istanza DB è crittografata, indipendentemente dal tipo di crittografia (chiave AWS gestita o chiave gestita dal cliente), è necessario fornire una chiave KMS gestita dal cliente nel ruolo IAM e nella `rds_tlog_backup_copy_to_S3` stored procedure.
## Limitazioni e consigli
L'accesso ai backup dei log delle transazioni include le seguenti limitazioni e raccomandazioni:
+ È possibile elencare e copiare fino agli ultimi sette giorni di backup dei log delle transazioni per qualsiasi istanza database la cui conservazione del backup è configurata tra uno e 35 giorni.
+ Il bucket Amazon S3 utilizzato per l'accesso ai backup dei log delle transazioni deve essere presente nello stesso account e nella stessa regione dell'istanza database di origine. La copia tra account e tra regioni non è supportata.
+ È possibile configurare un solo bucket Amazon S3 come destinazione in cui copiare i backup dei log delle transazioni. Puoi scegliere un nuovo bucket Amazon S3 di destinazione con la stored procedure `rds_tlog_copy_setup`. Per ulteriori informazioni sulla scelta di un nuovo bucket Amazon S3 di destinazione, consulta [Configurazione dell'accesso ai backup dei log delle transazioni](USER.SQLServer.AddlFeat.TransactionLogAccess.Enabling.md).
+ Non è possibile specificare la chiave KMS quando si utilizza la stored procedure `rds_tlog_backup_copy_to_S3` se l'istanza RDS non è abilitata per la crittografia dell'archiviazione.
+ La copia tra account non è supportata. Il ruolo IAM utilizzato per la copia consente l'accesso in scrittura ai bucket Amazon S3 solo all'interno dell'account proprietario dell'istanza database.
+ Solo due attività simultanee di qualsiasi tipo possono essere eseguite su un'istanza database RDS per SQL Server.
+ È possibile eseguire una sola operazione di copia alla volta per ogni singolo database. Se desideri copiare i backup dei log delle transazioni per più database sull'istanza database, utilizza un'attività di copia separata per ogni database.
+ Se copi un backup dei log delle transazioni già esistente con lo stesso nome nel bucket Amazon S3, il backup dei log delle transazioni esistente verrà sovrascritto.
+ È possibile eseguire solo le stored procedure che consentono l'accesso ai backup dei log delle transazioni sull'istanza database primaria. Non è possibile eseguire queste stored procedure su una replica di lettura di RDS per SQL Server o su un'istanza secondaria di un cluster database multi-AZ.
+ Se l'istanza database di RDS per SQL Server viene riavviata mentre la stored procedure `rds_tlog_backup_copy_to_S3` è in esecuzione, l'attività verrà riavviata automaticamente dall'inizio quando l'istanza database tornerà online. Qualsiasi backup dei log delle transazioni copiato nel bucket Amazon S3 mentre l'attività è in esecuzione prima del riavvio verrà sovrascritto.
+ I database di sistema Microsoft SQL Server e il database `RDSAdmin` non possono essere configurati per l'accesso ai backup dei log delle transazioni.
+ La copia su bucket con crittografia SSE-KMS non è supportata.
# Configurazione dell'accesso ai backup dei log delle transazioni
Per configurare l'accesso ai backup dei log delle transazioni, completa l'elenco dei requisiti nella sezione [Requisiti](USER.SQLServer.AddlFeat.TransactionLogAccess.md#USER.SQLServer.AddlFeat.TransactionLogAccess.Requirements), quindi esegui la stored procedure `rds_tlog_copy_setup`. La procedura consente l'accesso alla funzionalità di backup dei log delle transazioni a livello di istanza database. Non è necessario eseguirla per ogni singolo database nell'istanza database.
**Importante**
All'utente del database deve essere concesso il ruolo `db_owner` in SQL Server su ogni database per configurare e utilizzare la funzionalità di accesso ai backup dei log delle transazioni.
**Example di utilizzo:**
```
exec msdb.dbo.rds_tlog_copy_setup
@target_s3_arn='arn:aws:s3:::amzn-s3-demo-bucket/myfolder';
```
Il parametro seguente è obbligatorio:
+ `@target_s3_arn`: l'ARN del bucket Amazon S3 di destinazione in cui copiare i file di backup dei log delle transazioni.
**Example di impostazione di un bucket Amazon S3:**
```
exec msdb.dbo.rds_tlog_copy_setup @target_s3_arn='arn:aws:s3:::amzn-s3-demo-logging-bucket/mytestdb1';
```
Per convalidare la configurazione, chiama la stored procedure `rds_show_configuration`.
**Example di convalida della configurazione:**
```
exec rdsadmin.dbo.rds_show_configuration @name='target_s3_arn_for_tlog_copy';
```
Per modificare l'accesso ai backup dei log delle transazioni in modo che punti a un bucket Amazon S3 diverso, puoi visualizzare il valore corrente del bucket Amazon S3 ed eseguire nuovamente la store procedure `rds_tlog_copy_setup` utilizzando un nuovo valore per `@target_s3_arn`.
**Example di visualizzazione del bucket Amazon S3 esistente configurato per l'accesso ai backup dei log delle transazioni**
```
exec rdsadmin.dbo.rds_show_configuration @name='target_s3_arn_for_tlog_copy';
```
**Example di aggiornamento a un nuovo bucket Amazon S3 di destinazione**
```
exec msdb.dbo.rds_tlog_copy_setup @target_s3_arn='arn:aws:s3:::amzn-s3-demo-logging-bucket1/mynewfolder';
```
# Elenco dei backup dei log delle transazioni disponibili
Con RDS per SQL Server, i database configurati per utilizzare il modello di ripristino completo e la conservazione del backup dell'istanza database impostata su uno o più giorni, hanno automaticamente abilitati i backup dei log delle transazioni. Abilitando l'accesso ai backup dei log delle transazioni, potrai copiarli nel tuo bucket Amazon S3 per un massimo di sette giorni.
Dopo aver abilitato l'accesso ai backup dei log delle transazioni, puoi iniziare a utilizzarlo per elencare e copiare i file di backup dei log delle transazioni disponibili.
**Elenco dei backup dei log delle transazioni**
Per elencare tutti i backup dei log delle transazioni disponibili per un singolo database, chiama la funzione `rds_fn_list_tlog_backup_metadata`. È possibile utilizzare una clausola `ORDER BY` o `WHERE` quando si chiama la funzione.
**Example di elenco e filtro dei file di backup dei log delle transazioni disponibili**
```
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;
```
![\[Output da rds_fn_list_tlog_backup_metadata\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/sql_accesstransactionlogs_func.png)
La funzione `rds_fn_list_tlog_backup_metadata` restituisce il seguente output:
****
| Nome della colonna | Tipo di dati | Description |
| --- | --- | --- |
| `db_name` | sysname | Il nome del database fornito per elencare i backup dei log delle transazioni. |
| `db_id` | int | L'identificatore del database interno per il parametro di input `db_name`. |
| `family_guid` | uniqueidentifier | L'ID univoco del database originale al momento della creazione. Questo valore rimane invariato quando il database viene ripristinato, anche con un nome di database diverso. |
| `rds_backup_seq_id` | int | L'ID che RDS utilizza internamente per mantenere un numero di sequenza per ogni file di backup dei log delle transazioni. |
| `backup_file_epoch` | bigint | L'ora in cui è stato generato un file di backup delle transazioni. |
| `backup_file_time_utc` | datetime | Il valore UTC per il valore `backup_file_epoch`. |
| `starting_lsn` | numeric(25,0) | Il numero di sequenza di log del primo o dell'ultimo record di log di un file di backup dei log delle transazioni. |
| `ending_lsn` | numeric(25,0) | Il numero di sequenza di log dell'ultimo o del penultimo record di log di un file di backup dei log delle transazioni. |
| `is_log_chain_broken` | bit | Un valore booleano che indica se la catena di log è interrotta tra il file di backup dei log delle transazioni corrente e il file di backup dei log delle transazioni precedente. |
| `file_size_bytes` | bigint | Le dimensioni del set di backup delle transazioni in byte. |
| `Error` | varchar(4000) | Messaggio di errore se la funzione `rds_fn_list_tlog_backup_metadata` genera un'eccezione. NULL in assenza di eccezioni. |
# Copia dei backup dei log delle transazioni
Per copiare un set di backup dei log delle transazioni disponibili per un singolo database nel bucket Amazon S3, chiama la stored procedure `rds_tlog_backup_copy_to_S3`. La stored procedure `rds_tlog_backup_copy_to_S3` avvia una nuova attività per copiare i backup dei log delle transazioni.
**Nota**
La store procedure `rds_tlog_backup_copy_to_S3` memorizzata copia i backup dei log delle transazioni senza convalidarli con l'attributo `is_log_chain_broken`. Per questo motivo, è necessario confermare manualmente una catena di log ininterrotta prima di eseguire la stored procedure `rds_tlog_backup_copy_to_S3`. Per ulteriori informazioni, consulta [Convalida della catena di log di backup dei log delle transazioni](#USER.SQLServer.AddlFeat.TransactionLogAccess.Copying.LogChain).
**Example di utilizzo della stored procedure `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];
```
Sono disponibili i seguenti parametri di input:
****
| Parametro | Description |
| --- | --- |
| `@db_name` | Il nome del database per cui copiare i backup dei log delle transazioni |
| `@kms_key_arn` | Una chiave KMS gestita dal cliente. Se crittografi la tua istanza DB con una chiave KMS AWS gestita, devi creare una chiave gestita dal cliente. Se si crittografa l’istanza database con una chiave gestita dal cliente, è possibile utilizzare lo stesso ARN della chiave KMS. |
| `@backup_file_start_time` | Il timestamp UTC fornito dalla colonna `[backup_file_time_utc]` della funzione `rds_fn_list_tlog_backup_metadata`. |
| `@backup_file_end_time` | Il timestamp UTC fornito dalla colonna `[backup_file_time_utc]` della funzione `rds_fn_list_tlog_backup_metadata`. |
| `@starting_lsn` | Il numero di sequenza di log fornito dalla colonna `[starting_lsn]` della funzione `rds_fn_list_tlog_backup_metadata`. |
| `@ending_lsn` | Il numero di sequenza di log fornito dalla colonna `[ending_lsn]` della funzione `rds_fn_list_tlog_backup_metadata`. |
| `@rds_backup_starting_seq_id` | L'ID sequenza fornito dalla colonna `[rds_backup_seq_id]` della funzione `rds_fn_list_tlog_backup_metadata`. |
| `@rds_backup_ending_seq_id` | L'ID sequenza fornito dalla colonna `[rds_backup_seq_id]` della funzione `rds_fn_list_tlog_backup_metadata`. |
È possibile specificare un set di parametri relativi all'ora, al numero di sequenza di log o all'ID sequenza. È richiesto un solo set di parametri.
È inoltre possibile specificare un solo parametro in uno qualsiasi dei set. Ad esempio, fornendo un valore solo per il parametro `backup_file_end_time`, tutti i file di backup dei log delle transazioni disponibili prima di quel momento entro il limite di sette giorni verranno copiati nel bucket Amazon S3.
Di seguito sono riportate le combinazioni di parametri di input valide per la stored procedure `rds_tlog_backup_copy_to_S3`.
****
| Parametri forniti | Risultato previsto |
| --- | --- |
| 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 i backup dei log delle transazioni degli ultimi sette giorni ed esistenti nell'intervallo fornito compreso tra `backup_file_start_time` e `backup_file_end_time`. In questo esempio, la stored procedure copia i backup dei log delle transazioni generati tra "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 i backup dei log delle transazioni degli ultimi sette giorni e a partire dalla data specificata in `backup_file_start_time`. In questo esempio, la stored procedure copia i backup dei log delle transazioni dal "2022-08-23 00:00:00" fino al più recente backup dei log delle transazioni. |
| exec msdb.dbo.rds_tlog_backup_copy_to_S3
@db_name = 'testdb1',
@backup_file_end_time='2022-08-30 00:00:00';
| Copia i backup dei log delle transazioni dagli ultimi sette giorni fino alla data specificata in `backup_file_end_time`. In questo esempio, la stored procedure copia i backup dei log delle transazioni dal "2022-08-23 00:00:00" al "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 i backup dei log delle transazioni disponibili negli ultimi sette giorni e compresi nell'intervallo fornito compreso tra `starting_lsn` e `ending_lsn`. In questo esempio, la stored procedure copia i backup dei log delle transazioni degli ultimi sette giorni con un intervallo di numero di sequenza di log compreso tra 1490000000040007 e 1490000000050009. |
| exec msdb.dbo.rds_tlog_backup_copy_to_S3
@db_name='testdb1',
@starting_lsn =1490000000040007;
| Copia i backup dei log delle transazioni disponibili negli ultimi sette giorni, a partire dal numero specificato in `starting_lsn`. In questo esempio, la stored procedure copia i backup dei log delle transazioni dal numero di sequenza di log 1490000000040007 fino al più recente backup dei log delle transazioni. |
| exec msdb.dbo.rds_tlog_backup_copy_to_S3
@db_name='testdb1',
@ending_lsn =1490000000050009;
| Copia i backup dei log delle transazioni disponibili negli ultimi sette giorni fino al numero specificato in `ending_lsn`. In questo esempio, la stored procedure copia i backup dei log delle transazioni degli ultimi sette giorni fino al numero di sequenza di log 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 i backup dei log delle transazioni disponibili negli ultimi sette giorni ed esistenti nell'intervallo fornito compreso tra `rds_backup_starting_seq_id` e `rds_backup_ending_seq_id`. In questo esempio, la stored procedure copia i backup dei log delle transazioni a partire dagli ultimi sette giorni e compresi nell'intervallo di ID sequenza di backup RDS fornito, a partire da seq\$1id 2000 fino a seq\$1id 5000. |
| exec msdb.dbo.rds_tlog_backup_copy_to_S3
@db_name='testdb1',
@rds_backup_starting_seq_id= 2000;
| Copia i backup dei log delle transazioni disponibili negli ultimi sette giorni, a partire dal numero specificato in `rds_backup_starting_seq_id`. In questo esempio, la stored procedure copia i backup dei log delle transazioni a partire da seq\$1id 2000 fino al più recente backup dei log delle transazioni. |
| exec msdb.dbo.rds_tlog_backup_copy_to_S3
@db_name='testdb1',
@rds_backup_ending_seq_id= 5000;
| Copia i backup dei log delle transazioni disponibili negli ultimi sette giorni fino al numero specificato in `rds_backup_ending_seq_id`. In questo esempio, la stored procedure copia i backup dei log delle transazioni degli ultimi sette giorni fino a 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 un singolo backup dei log delle transazioni con l'elemento `rds_backup_starting_seq_id` specificato, se disponibile negli ultimi sette giorni. In questo esempio, la stored procedure copia un singolo backup dei log delle transazioni con seq\$1id 2000, se esistente negli ultimi sette giorni. |
## Convalida della catena di log di backup dei log delle transazioni
I database configurati per l'accesso ai backup dei log delle transazioni devono avere la conservazione automatica dei backup abilitata. La conservazione automatica dei backup imposta i database sull'istanza database in base al modello di ripristino `FULL`. Per supportare il ripristino point-in-time di un database, evita di modificare il modello di ripristino del database per impedire l'interruzione della catena di log. Si consiglia di mantenere il database impostato sul modello di ripristino `FULL`.
Per convalidare manualmente la catena di log prima di copiare i backup dei log delle transazioni, chiama la funzione `rds_fn_list_tlog_backup_metadata` ed esamina i valori nella colonna `is_log_chain_broken`. Il valore "1" indica che la catena di log è stata interrotta tra il backup dei log corrente e il backup dei log precedente.
L'esempio seguente mostra una catena di log interrotta nell'output della stored procedure `rds_fn_list_tlog_backup_metadata`.
![\[Output di rds_fn_list_tlog_backup_metadata che mostra una catena di log interrotta.\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/sql_accesstransactionlogs_logchain_error.png)
In una normale catena di log, il valore del numero di sequenza di log per first\$1lsn per un dato rds\$1sequence\$1id deve corrispondere al valore di last\$1lsn nell'elemento rds\$1sequence\$1id precedente. Nell'immagine, il valore rds\$1sequence\$1id 45 ha il valore first\$1lsn 90987, che non corrisponde al valore last\$1lsn 90985 che dell'elemento rds\$1sequence\$1id 44 precedente.
Per ulteriori informazioni sull'architettura dei log delle transazioni di SQL Server e sui numeri di sequenza di log, consulta [Architettura logica del log delle transazioni](https://learn.microsoft.com/en-us/sql/relational-databases/sql-server-transaction-log-architecture-and-management-guide?view=sql-server-ver15#Logical_Arch) nella documentazione di Microsoft SQL Server.
# Struttura di file e cartelle del bucket Amazon S3
I backup dei log delle transazioni hanno la struttura e la convenzione di denominazione standard seguenti in un bucket Amazon S3:
+ Viene creata una nuova cartella nel percorso `target_s3_arn` di ogni database con la struttura di denominazione `{db_id}.{family_guid}`.
+ All'interno della cartella, i backup dei log delle transazioni hanno la struttura di denominazione dei file `{db_id}.{family_guid}.{rds_backup_seq_id}.{backup_file_epoch}`.
+ È possibile visualizzare i dettagli di `family_guid,db_id,rds_backup_seq_id and backup_file_epoch` con la funzione `rds_fn_list_tlog_backup_metadata`.
L'esempio seguente mostra la struttura di cartelle e file di un set di backup dei log delle transazioni in un bucket Amazon S3.
![\[Struttura del bucket Amazon S3 con accesso ai log delle transazioni\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/sql_accesstransactionlogs_s3.png)
# Monitoraggio dello stato delle attività
Per monitorare lo stato delle attività di copia, chiama la stored procedure `rds_task_status`. Se non fornisci alcun parametro, la stored procedure restituisce lo stato di tutte le attività.
**Example di utilizzo:**
```
exec msdb.dbo.rds_task_status
@db_name='database_name',
@task_id=ID_number;
```
I parametri seguenti sono facoltativi:
+ `@db_name` – Il nome del database per il quale visualizzare lo stato dell'attività.
+ `@task_id` – L'ID dell'attività per la quale visualizzare lo stato.
**Example di elenco dello stato per un ID attività specifico:**
```
exec msdb.dbo.rds_task_status @task_id=5;
```
**Example di elenco dello stato per un database e un'attività specifici:**
```
exec msdb.dbo.rds_task_status@db_name='my_database',@task_id=5;
```
**Example di elenco di tutte le attività e relativi stati per un database specifico:**
```
exec msdb.dbo.rds_task_status @db_name='my_database';
```
**Example di elenco di tutte le attività e relativi stati per l'istanza database corrente:**
```
exec msdb.dbo.rds_task_status;
```
# Annullamento di un'attività
Per annullare un'attività in esecuzione, chiama la stored procedure `rds_cancel_task`.
**Example di utilizzo:**
```
exec msdb.dbo.rds_cancel_task @task_id=ID_number;
```
Il parametro seguente è obbligatorio:
+ `@task_id` – L'ID dell'attività da annullare. Puoi esaminare l'ID attività chiamando la stored procedure `rds_task_status`.
Per ulteriori informazioni sulla visualizzazione e sull'annullamento delle attività in esecuzione, consulta [Importazione ed esportazione di database SQL Server mediante backup e ripristino nativi](SQLServer.Procedural.Importing.md).
# Risoluzione dei problemi di accesso ai backup dei log delle transazioni
Di seguito sono elencati i problemi che si potrebbero riscontrare quando si utilizzano le stored procedure per accedere ai backup dei log delle transazioni.
****
| Stored procedure | Messaggio di errore | Problema | Suggerimenti sulla risoluzione dei problemi |
| --- | --- | --- | --- |
| rds\$1tlog\$1copy\$1setup | I backup sono disabilitati su questa istanza database. Abilita i backup dell'istanza database con un valore per la conservazione di almeno "1" e riprova. | I backup automatici non sono abilitati per l'istanza database. | La conservazione dei backup dell'istanza database deve essere abilitata con un valore di almeno un giorno. Per ulteriori informazioni sull'abilitazione dei backup automatici e sulla configurazione della conservazione dei backup, consulta [Periodo di conservazione dei backup](USER_WorkingWithAutomatedBackups.BackupRetention.md). |
| rds\$1tlog\$1copy\$1setup | Errore durante l'esecuzione della stored procedure rds\$1tlog\$1copy\$1setup. Riconnettiti all'endpoint RDS e riprova. | Si è verificato un errore interno. | Riconnettiti all'endpoint RDS ed esegui nuovamente la stored procedure `rds_tlog_copy_setup`. |
| rds\$1tlog\$1copy\$1setup | L'esecuzione della stored procedure rds\$1tlog\$1backup\$1copy\$1setup in una transazione non è supportata. Verifica che nella sessione non ci siano transazioni aperte e riprova. | La stored procedure è stata avviata in una transazione utilizzando `BEGIN` e `END`. | Evita di utilizzare `BEGIN` e `END` durante l'esecuzione della stored procedure `rds_tlog_copy_setup`. |
| rds\$1tlog\$1copy\$1setup | Il nome del bucket S3 per il parametro di input `@target_s3_arn` deve contenere almeno un carattere diverso da spazio. | È stato fornito un valore errato per il parametro di input `@target_s3_arn`. | Assicurati che il parametro di input `@target_s3_arn` specifichi l'ARN completo del bucket Amazon S3. |
| rds\$1tlog\$1copy\$1setup | L'opzione `SQLSERVER_BACKUP_RESTORE` non è abilitata o è in fase di abilitazione. Abilita l'opzione o riprova più tardi. | L'opzione `SQLSERVER_BACKUP_RESTORE` non è abilitata sull'istanza database o è stata abilitata ma è in attesa dell'attivazione interna. | Attiva l'opzione `SQLSERVER_BACKUP_RESTORE` come specificato nella sezione Requisiti. Attendi qualche minuto ed esegui nuovamente la stored procedure `rds_tlog_copy_setup`. |
| rds\$1tlog\$1copy\$1setup | L'ARN S3 di destinazione per il parametro di input `@target_s3_arn` non può essere vuoto o nullo. | È stato fornito un valore `NULL` per il parametro di input `@target_s3_arn` oppure il valore non è stato fornito. | Assicurati che il parametro di input `@target_s3_arn` specifichi l'ARN completo del bucket Amazon S3. |
| rds\$1tlog\$1copy\$1setup | L'ARN S3 di destinazione per il parametro di input `@target_s3_arn` deve iniziare con arn:aws. | Il parametro di input `@target_s3_arn` è stato fornito senza `arn:aws` all'inizio. | Assicurati che il parametro di input `@target_s3_arn` specifichi l'ARN completo del bucket Amazon S3. |
| rds\$1tlog\$1copy\$1setup | L'ARN S3 di destinazione è già impostato sul valore fornito. | La stored procedure `rds_tlog_copy_setup` veniva precedentemente eseguita ed era configurata con un bucket ARN Amazon S3. | Per modificare il valore del bucket Amazon S3 per l'accesso ai backup dei log delle transazioni, fornisci un valore diverso per `target S3 ARN`. |
| rds\$1tlog\$1copy\$1setup | Impossibile generare credenziali per abilitare l'accesso ai backup dei log delle transazioni. Conferma l'ARN del percorso S3 fornito con `rds_tlog_copy_setup` e riprova. | Si è verificato un errore non specificato durante la generazione delle credenziali per consentire l'accesso ai backup dei log delle transazioni. | Esamina la configurazione dell'impostazione e riprova. |
| rds\$1tlog\$1copy\$1setup | Non è possibile eseguire la stored procedure rds\$1tlog\$1copy\$1setup se sono presenti attività in sospeso. Attendi il completamento delle attività in sospeso e riprova. | È possibile eseguire solo due attività alla volta. Sono presenti attività in attesa del completamento. | Visualizza le attività in sospeso e attendi che vengano completate. Per ulteriori informazioni sul monitoraggio dello stato delle attività, consulta [Monitoraggio dello stato delle attività](USER.SQLServer.AddlFeat.TransactionLogAccess.TrackTaskStatus.md). |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | È già stata eseguita un'operazione di copia del file di backup T-log per il database: %s con ID attività: %d, riprova più tardi. | È possibile eseguire una sola operazione di copia alla volta per un determinato database. È presente un'operazione di copia in attesa del completamento. | Visualizza le attività in sospeso e attendi che vengano completate. Per ulteriori informazioni sul monitoraggio dello stato delle attività, consulta [Monitoraggio dello stato delle attività](USER.SQLServer.AddlFeat.TransactionLogAccess.TrackTaskStatus.md). |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | È necessario fornire almeno uno di questi tre set di parametri. 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) | Nessuno dei tre set di parametri è stato fornito oppure in un set di parametri fornito manca un parametro obbligatorio. | È possibile specificare i parametri relativi all'ora, al numero di sequenza di log o all'ID sequenza. È richiesto uno di questi tre set di parametri. Per ulteriori informazioni sui parametri obbligatori, consulta [Copia dei backup dei log delle transazioni](USER.SQLServer.AddlFeat.TransactionLogAccess.Copying.md). |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | I backup sono disabilitati sull'istanza. Abilita i backup e riprova tra qualche minuto. | I backup automatici non sono abilitati per l'istanza database. | Per ulteriori informazioni sull'abilitazione dei backup automatici e sulla configurazione della conservazione dei backup, consulta [Periodo di conservazione dei backup](USER_WorkingWithAutomatedBackups.BackupRetention.md). |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Impossibile trovare il database specificato %s. | Il valore fornito per il parametro di input `@db_name` non corrisponde al nome di un database nell'istanza database. | Usa un nome di database corretto. Per elencare tutti i database per nome, esegui `SELECT * from sys.databases` |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Impossibile eseguire la stored procedure rds\$1tlog\$1backup\$1copy\$1to\$1S3 per i database di sistema SQL Server o il database rdsadmin. | Il valore fornito per il parametro di input `@db_name` corrisponde al nome di un database di sistema SQL Server o al database RDSAdmin. | I seguenti database non possono essere utilizzati per accedere ai backup dei log delle transazioni: `master, model, msdb, tempdb, RDSAdmin.` |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Il nome di database per il parametro di input @db\$1name non può essere vuoto o nullo. | Il valore fornito per il parametro di input `@db_name` era vuoto o `NULL`. | Usa un nome di database corretto. Per elencare tutti i database per nome, esegui `SELECT * from sys.databases` |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Il periodo di conservazione dei backup dell'istanza database deve essere impostato almeno su 1 per eseguire la stored procedure rds\$1tlog\$1backup\$1copy\$1setup. | I backup automatici non sono abilitati per l'istanza database. | Per ulteriori informazioni sull'abilitazione dei backup automatici e sulla configurazione della conservazione dei backup, consulta [Periodo di conservazione dei backup](USER_WorkingWithAutomatedBackups.BackupRetention.md). |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Errore durante l'esecuzione della stored procedure rds\$1tlog\$1backup\$1copy\$1to\$1S3. Riconnettiti all'endpoint RDS e riprova. | Si è verificato un errore interno. | Riconnettiti all'endpoint RDS ed esegui nuovamente la stored procedure `rds_tlog_backup_copy_to_S3`. |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | È possibile fornire uno solo di questi tre set di parametri. 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) | Sono stati forniti diversi set di parametri. | È possibile specificare i parametri relativi all'ora, al numero di sequenza di log o all'ID sequenza. È richiesto uno di questi tre set di parametri. Per ulteriori informazioni sui parametri obbligatori, consulta [Copia dei backup dei log delle transazioni](USER.SQLServer.AddlFeat.TransactionLogAccess.Copying.md). |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | L'esecuzione della stored procedure rds\$1tlog\$1backup\$1copy\$1to\$1S3 in una transazione non è supportata. Verifica che nella sessione non ci siano transazioni aperte e riprova. | La stored procedure è stata avviata in una transazione utilizzando `BEGIN` e `END`. | Evita di utilizzare `BEGIN` e `END` durante l'esecuzione della stored procedure `rds_tlog_backup_copy_to_S3`. |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | I parametri forniti non rientrano nel periodo di conservazione dei log di backup delle transazioni. Per visualizzare l'elenco dei file di backup dei log delle transazioni disponibili, esegui la funzione rds\$1fn\$1list\$1tlog\$1backup\$1metadata. | Non sono disponibili i backup dei log delle transazioni per i parametri di input forniti che rientrano nella finestra di conservazione delle copie. | Riprova con un set di parametri valido. Per ulteriori informazioni sui parametri obbligatori, consulta [Copia dei backup dei log delle transazioni](USER.SQLServer.AddlFeat.TransactionLogAccess.Copying.md). |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Si è verificato un errore di autorizzazione durante l'elaborazione della richiesta. Assicurati che il bucket si trovi nello stesso account e nella stessa regione dell'istanza database e conferma le autorizzazioni della policy del bucket S3 rispetto al modello della documentazione pubblica. | È stato rilevato un problema relativo al bucket S3 fornito o alle autorizzazioni di policy. | Verifica che la configurazione per l'accesso ai backup dei log delle transazioni sia corretta. Per ulteriori informazioni sui requisiti di configurazione per il bucket S3, consulta [Requisiti](USER.SQLServer.AddlFeat.TransactionLogAccess.md#USER.SQLServer.AddlFeat.TransactionLogAccess.Requirements). |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | L'esecuzione della stored procedure `rds_tlog_backup_copy_to_S3` su un'istanza di replica di lettura RDS non è consentita. | La stored procedure è stata avviata su un'istanza di replica di lettura RDS. | Connettiti all'istanza database primaria RDS per eseguire la stored procedure `rds_tlog_backup_copy_to_S3`. |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Il numero di sequenza di log per il parametro di input `@starting_lsn` deve essere inferiore a `@ending_lsn`. | Il valore fornito per il parametro di input `@starting_lsn` era maggiore del valore fornito per il parametro di input `@ending_lsn`. | Assicurati che il valore fornito per il parametro di input `@starting_lsn` sia inferiore al valore fornito per il parametro di input `@ending_lsn`. |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | La stored procedure `rds_tlog_backup_copy_to_S3` può essere eseguita solo dai membri con il ruolo `db_owner` nel database di origine. | Il ruolo `db_owner` non è stato concesso all'account che tenta di eseguire la stored procedure `rds_tlog_backup_copy_to_S3` sul provider `db_name`. | Assicurati che l'account che esegue la stored procedure sia autorizzato con il ruolo `db_owner` per il `db_name` specificato. |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | L'ID sequenza per il parametro di input `@rds_backup_starting_seq_id` deve essere minore o uguale a `@rds_backup_ending_seq_id`. | Il valore fornito per il parametro di input `@rds_backup_starting_seq_id` era maggiore del valore fornito per il parametro di input `@rds_backup_ending_seq_id`. | Assicurati che il valore fornito per il parametro di input `@rds_backup_starting_seq_id` sia inferiore al valore fornito per il parametro di input `@rds_backup_ending_seq_id`. |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | L'opzione SQLSERVER\$1BACKUP\$1RESTORE non è abilitata o è in fase di abilitazione. Abilita l'opzione o riprova più tardi. | L'opzione `SQLSERVER_BACKUP_RESTORE` non è abilitata sull'istanza database o è stata abilitata ma è in attesa dell'attivazione interna. | Attiva l'opzione `SQLSERVER_BACKUP_RESTORE` come specificato nella sezione Requisiti. Attendi qualche minuto ed esegui nuovamente la stored procedure `rds_tlog_backup_copy_to_S3`. |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | L'ora di inizio del parametro di input `@backup_file_start_time` deve essere inferiore a `@backup_file_end_time`. | Il valore fornito per il parametro di input `@backup_file_start_time` era maggiore del valore fornito per il parametro di input `@backup_file_end_time`. | Assicurati che il valore fornito per il parametro di input `@backup_file_start_time` sia inferiore al valore fornito per il parametro di input `@backup_file_end_time`. |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Impossibile elaborare la richiesta a causa della mancanza di accesso. Controlla le impostazioni e le autorizzazioni per la funzionalità. | Potrebbe esserci un problema con le autorizzazioni del bucket Amazon S3 oppure il bucket Amazon S3 fornito si trova in un altro account o un'altra regione. | Assicurati che le autorizzazioni della policy dei bucket di Amazon S3 siano autorizzate a consentire l'accesso RDS. Assicurati che il bucket Amazon S3 si trovi nello stesso account e nella stessa regione dell'istanza database. |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | Non è possibile fornire l'ARN di una chiave KMS come parametro di input alla stored procedure per le istanze che non sono crittografate nell'archiviazione. | Quando la crittografia dell'archiviazione non è abilitata sull'istanza database, il parametro di input `@kms_key_arn` non deve essere fornito. | Non fornire un parametro di input per `@kms_key_arn`. |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | È necessario fornire l'ARN di una chiave KMS come parametro di input per la stored procedure delle istanze crittografate nell'archiviazione. | Quando la crittografia dell'archiviazione è abilitata sull'istanza database, è necessario fornire il parametro di input `@kms_key_arn`. | Fornisci un parametro di input per `@kms_key_arn` con un valore che corrisponda all'ARN del bucket Amazon S3 da utilizzare per i backup dei log delle transazioni. |
| rds\$1tlog\$1backup\$1copy\$1to\$1S3 | È necessario eseguire la stored procedure `rds_tlog_copy_setup` e impostare `@target_s3_arn`, prima di eseguire la stored procedure `rds_tlog_backup_copy_to_S3`. | La procedura di impostazione dell'accesso ai backup dei log delle transazioni non è stata completata prima di tentare di eseguire la stored procedure `rds_tlog_backup_copy_to_S3`. | Esegui la stored procedure `rds_tlog_copy_setup` prima di eseguire la stored procedure `rds_tlog_backup_copy_to_S3`. Per ulteriori informazioni sull'esecuzione della procedura di impostazione per l'accesso ai backup dei log delle transazioni, consulta [Configurazione dell'accesso ai backup dei log delle transazioni](USER.SQLServer.AddlFeat.TransactionLogAccess.Enabling.md). |