Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Attività DBA frequenti per Amazon RDS per Microsoft SQL Server
In questa sezione vengono descritte le implementazioni, specifiche per Amazon RDS, di alcune attività DBA frequenti per le istanze database che eseguono il motore di database Microsoft SQL Server. Per fornire un'esperienza di servizio gestito, Amazon RDS non fornisce accesso shell alle istanze database e limita l'accesso a certe procedure e tabelle di sistema che richiedono privilegi avanzati.
**Nota**
Quando utilizzi un'istanza database SQL Server, puoi eseguire script per modificare un database appena creato, ma non puoi modificare il database [model], ossia quello che serve da modello per nuovi database.
**Topics**
+ [Accesso al database tempdb sulle istanze database Microsoft SQL Server su Amazon RDS](SQLServer.TempDB.md)
+ [Analisi del carico di lavoro del database su un'istanza database Amazon RDS for SQL Server con Tuning Advisor motore di database](Appendix.SQLServer.CommonDBATasks.Workload.md)
+ [Modifica di `db_owner` nell’account `rdsa` per il database Amazon RDS per SQL Server](Appendix.SQLServer.CommonDBATasks.ChangeDBowner.md)
+ [Gestione di regole di confronto e set di caratteri per Amazon RDS per Microsoft SQL Server](Appendix.SQLServer.CommonDBATasks.Collation.md)
+ [Creazione di un utente del database per Amazon RDS per SQL Server](Appendix.SQLServer.CommonDBATasks.CreateUser.md)
+ [Individuazione di un modello di ripristino per il database Amazon RDS per SQL Server](Appendix.SQLServer.CommonDBATasks.DatabaseRecovery.md)
+ [Individuazione dell’ora dell’ultimo failover per Amazon RDS per SQL Server](Appendix.SQLServer.CommonDBATasks.LastFailover.md)
+ [Risoluzione dei problemi di recupero point-in-time dovuti a un divario dei numeri nella sequenza di log](Appendix.SQLServer.CommonDBATasks.PITR-LSN-Gaps.md)
+ [Negare o consentire la visualizzazione dei nomi dei database per Amazon RDS per SQL Server](Appendix.SQLServer.CommonDBATasks.ManageView.md)
+ [Disattivazione degli inserti rapidi durante il caricamento in blocco per Amazon RDS per SQL Server](Appendix.SQLServer.CommonDBATasks.DisableFastInserts.md)
+ [Eliminazione di un database in un’istanza database Amazon RDS per Microsoft SQL Server](Appendix.SQLServer.CommonDBATasks.DropMirrorDB.md)
+ [Ridenominazione di un database Amazon RDS per Microsoft SQL Server in un’implementazione Multi-AZ](Appendix.SQLServer.CommonDBATasks.RenamingDB.md)
+ [Reimpostazione dell’appartenenza al ruolo db\$1owner per l’utente master per Amazon RDS per SQL Server](Appendix.SQLServer.CommonDBATasks.ResetPassword.md)
+ [Ripristino di istanze database terminate in base alla licenza per Amazon RDS per SQL Server](Appendix.SQLServer.CommonDBATasks.RestoreLTI.md)
+ [Transizione di un database Amazon RDS per SQL Server da OFFLINE a ONLINE](Appendix.SQLServer.CommonDBATasks.TransitionOnline.md)
+ [Utilizzo di Change Data Capture per Amazon RDS per SQL Server](Appendix.SQLServer.CommonDBATasks.CDC.md)
+ [Utilizzo di SQL Server Agent per Amazon RDS](Appendix.SQLServer.CommonDBATasks.Agent.md)
+ [Utilizzo dei log di Amazon RDS per Microsoft SQL Server](Appendix.SQLServer.CommonDBATasks.Logs.md)
+ [Utilizzo di file di traccia e file dump per Amazon RDS per SQL Server](Appendix.SQLServer.CommonDBATasks.TraceFiles.md)
# Accesso al database tempdb sulle istanze database Microsoft SQL Server su Amazon RDS
Puoi accedere al database `tempdb` sulle tue istanze database Microsoft SQL Server su Amazon RDS. Puoi eseguire il codice su `tempdb` servendoti di Transact-SQL tramite Microsoft SQL Server Management Studio (SSMS) o qualsiasi altra applicazione client SQL standard. Per ulteriori informazioni sulla connessione alla tua istanza database, consulta [Connessione all’istanza database Microsoft SQL Server](USER_ConnectToMicrosoftSQLServerInstance.md).
L'utente master per la tua istanza database riceve l'accesso `CONTROL` a `tempdb` affinché possa modificare le opzioni del database `tempdb`. L'utente master non è il proprietario del database `tempdb`. Se necessario, l'utente master può concedere l'accesso `CONTROL` ad altri utenti affinché anch'essi possano modificare le opzioni del database `tempdb`.
**Nota**
Non puoi eseguire i comandi Database Console Commands (DBCC) nel database `tempdb`.
# Modifica delle opzioni del database tempdb
Puoi modificare le opzioni di database nel database `tempdb` sulle tue istanze database Amazon RDS. Per ulteriori informazioni sulle opzioni che puoi modificare, consulta [Database tempdb](https://msdn.microsoft.com/en-us/library/ms190768%28v=sql.120%29.aspx) nella documentazione di Microsoft.
Opzioni di database come, ad esempio, le opzioni per le dimensioni massime dei file, permangono dopo il riavvio dell'istanza database. Puoi modificare le opzioni di database per ottimizzare le prestazioni durante l'importazione dei dati e per evitare di esaurire lo spazio di storage.
## Ottimizzazione delle prestazioni durante l'importazione dei dati
Per ottimizzare le prestazioni durante l'importazione di grandi quantità di dati nella tua istanza database, imposta le proprietà `SIZE` e `FILEGROWTH` del database tempdb su un numero grande. Per ulteriori informazioni su come ottimizzare `tempdb`, consulta [Ottimizzazione delle prestazioni di tempdb](https://technet.microsoft.com/en-us/library/ms175527%28v=sql.120%29.aspx) nella documentazione di Microsoft.
L'esempio seguente mostra come impostare la dimensione su 100 GB e la crescita file su 10 percento.
```
1. alter database[tempdb] modify file (NAME = N'templog', SIZE=100GB, FILEGROWTH = 10%)
```
## Come evitare problemi di storage
Per evitare che il database `tempdb` utilizzi tutto lo spazio su disco disponibile, imposta la proprietà `MAXSIZE`. L'esempio seguente mostra come impostare la proprietà su 2048 MB.
```
1. alter database [tempdb] modify file (NAME = N'templog', MAXSIZE = 2048MB)
```
# Riduzione del database tempdb
Puoi scegliere tra due modi per ridurre il database `tempdb` sulla tua istanza database Amazon RDS. Puoi utilizzare la procedura `rds_shrink_tempdbfile` oppure impostare la proprietà `SIZE`.
## Utilizzo della procedura rds\$1shrink\$1tempdbfile
La procedura `msdb.dbo.rds_shrink_tempdbfile` Amazon RDS permette di ridurre il database `tempdb`. Puoi chiamare `rds_shrink_tempdbfile` soltanto se disponi dell'accesso `CONTROL` a `tempdb`. Quando chiami `rds_shrink_tempdbfile` non si verifica alcun tempo di inattività per la tua istanza database.
La procedura `rds_shrink_tempdbfile` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `@temp_filename` | SYSNAME | — | obbligatorio | Il nome logico del file da ridurre. |
| `@target_size` | int | nullo | facoltativo | La nuova dimensione del file in megabyte. |
Nell'esempio seguente vengono ottenuti i nomi dei file per il database `tempdb`.
```
1. use tempdb;
2. GO
3.
4. select name, * from sys.sysfiles;
5. GO
```
Nell'esempio seguente le dimensioni del file del database `tempdb` denominato `test_file` vengono ridotte e viene richiesta una nuova dimensione di `10` MB:
```
1. exec msdb.dbo.rds_shrink_tempdbfile @temp_filename = N'test_file', @target_size = 10;
```
## Impostazione della proprietà SIZE
Puoi anche ridurre il database `tempdb` impostando la proprietà `SIZE` e riavviando l'istanza database. Per ulteriori informazioni sul riavvio dell'istanza database, consulta [Riavvio di un'istanza DB DB](USER_RebootInstance.md).
L'esempio seguente mostra come impostare la proprietà `SIZE` su 1024 MB.
```
1. alter database [tempdb] modify file (NAME = N'templog', SIZE = 1024MB)
```
# Configurazione di TempDB per le implementazioni Multi-AZ
Se la tua istanza database RDS per SQL Server si trova in un’implementazione Multi-AZ con mirroring del database (DBM) o gruppi di disponibilità Always On (AG), è opportuno prendere in considerazione alcuni fattori relativi all’utilizzo del database `tempdb`.
Non è possibile replicare i dati di `tempdb` dall’istanza database primaria a quella secondaria. Quando esegui il failover in un’istanza database secondaria, il database `tempdb` sull’istanza secondaria sarà vuoto.
È possibile sincronizzare la configurazione delle opzioni del database `tempdb`, comprese le impostazioni relative alla crescita automatica e al dimensionamento dei file, dall’istanza database primaria a quella secondaria. La sincronizzazione della configurazione di `tempDB` è supportata in tutte le versioni di RDS per SQL Server. È possibile attivare la sincronizzazione automatica della configurazione di `tempdb` utilizzando la seguente stored procedure:
```
EXECUTE msdb.dbo.rds_set_system_database_sync_objects @object_types = 'TempDbFile';
```
**Importante**
Prima di utilizzare la stored procedure `rds_set_system_database_sync_objects`, assicurati di aver impostato la configurazione di `tempdb` preferita sull’istanza database primaria, anziché su quella secondaria. Se hai modificato la configurazione sull’istanza database secondaria, la tua configurazione di `tempdb` preferita potrebbe essere eliminata quando attivi la sincronizzazione automatica.
Per verificare se la sincronizzazione automatica della configurazione di `tempdb` è attivata, è possibile utilizzare la seguente funzione:
```
SELECT * from msdb.dbo.rds_fn_get_system_database_sync_objects();
```
Quando la sincronizzazione automatica della configurazione di `tempdb` è attivata, viene restituito un valore per il campo `object_class`. Quando è disattivata, non viene restituito alcun valore.
Per trovare l’ultima volta che gli oggetti sono stati sincronizzati in base al fuso orario UTC, è possibile utilizzare la seguente funzione:
```
SELECT * from msdb.dbo.rds_fn_server_object_last_sync_time();
```
Ad esempio, se hai modificato la configurazione di `tempdb` alle ore 01:00 e successivamente esegui la funzione `rds_fn_server_object_last_sync_time`, il valore restituito per `last_sync_time` dovrebbe essere successivo alle ore 01:00, a indicare che è avvenuta una sincronizzazione automatica.
Se utilizzi anche la funzionalità di replica dei processi di SQL Server Agent, puoi abilitare la replica sia per i processi di SQL Agent sia per la configurazione di `tempdb` specificandoli nel parametro `@object_type`:
```
EXECUTE msdb.dbo.rds_set_system_database_sync_objects @object_types = 'SQLAgentJob,TempDbFile';
```
Per ulteriori informazioni sulla replica dei processi di SQL Server Agent, consulta [Attivazione della replica di processo SQL Server Agent](Appendix.SQLServer.CommonDBATasks.Agent.md#SQLServerAgent.Replicate).
In alternativa all’utilizzo della stored procedure `rds_set_system_database_sync_objects`, per assicurarti che le modifiche alla configurazione di `tempdb` vengano sincronizzate automaticamente, puoi utilizzare uno dei seguenti metodi manuali:
**Nota**
È consigliabile attivare la sincronizzazione automatica della configurazione di `tempdb` utilizzando la stored procedure `rds_set_system_database_sync_objects`: L’utilizzo della sincronizzazione automatica evita la necessità di eseguire queste attività manuali ogni volta che modifichi la configurazione di `tempdb`.
+ Modifica innanzitutto la tua istanza database e disattiva Multi-AZ, quindi modifica tempdb e infine riattiva Multi-AZ. Questo sistema non causa alcun tempo di inattività.
Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
+ Modifica dapprima `tempdb` nell'istanza primaria originale, quindi effettua il failover manualmente e infine modifica `tempdb` nella nuova istanza primaria. Questo sistema causa un tempo di inattività.
Per ulteriori informazioni, consulta [Riavvio di un'istanza DB DB](USER_RebootInstance.md).
# Analisi del carico di lavoro del database su un'istanza database Amazon RDS for SQL Server con Tuning Advisor motore di database
Database Engine Tuning Advisor è un'applicazione client fornita da Microsoft che analizza il carico di lavoro dei database e suggerisce un insieme ottimale di indici per i database Microsoft SQL Server in base al tipo di query eseguite. Come SQL Server Management Studio, Tuning Advisor viene eseguito da un computer client che si connette all'istanza database Amazon RDS che esegue SQL Server. Il computer client può essere un computer eseguito in locale nella tua rete o può essere un'istanza Amazon EC2 Windows in esecuzione nella stessa regione dell'istanza database Amazon RDS.
Questa sezione mostra come acquisire un carico di lavoro affinché Tuning Advisor lo analizzi. Questa è la procedura consigliata per acquisire un carico di lavoro perché Amazon RDS limita l'accesso host all'istanza SQL Server. Per ulteriori informazioni, consulta [Database Engine Tuning Advisor](https://docs.microsoft.com/en-us/sql/relational-databases/performance/database-engine-tuning-advisor) nella documentazione Microsoft.
Per utilizzare Tuning Advisor, occorre fornire ad Advisor ciò che chiamiamo "carico di lavoro". Un carico di lavoro è un insieme di istruzioni Transact-SQL che vengono eseguite su uno o più database che desideri ottimizzare. Durante l'ottimizzazione dei database, Database Engine Tuning Advisor si serve di file e tabelle di traccia, script Transact-SQL o file XML come input del carico di lavoro. Quando usi Amazon RDS, un carico di lavoro può essere un file in un computer client o una tabella di database in un database Amazon RDS for SQL Server accessibile al computer client. Il file o la tabella devono contenere query sul database che desideri ottimizzare in un formato riproducibile.
Per ottenere la massima efficacia di Tuning Advisor, i carichi di lavoro dovrebbero essere il più possibile realistici. Puoi generare un file o una tabella del carico di lavoro creando una traccia dell'istanza database. Quando una traccia è in esecuzione, puoi simulare un carico sull'istanza database oppure eseguire le applicazioni con carico normale.
Esistono due tipi di tracce: lato client e lato server. Le tracce lato client sono più facili da configurare e puoi osservare in tempo reale gli eventi di traccia che vengono acquisiti in SQL Server Profiler. Una traccia lato server è più complicata da configurare e richiede una certa quantità di scripting Transact-SQL. Inoltre, la traccia occupa spazio di storage perché viene trascritta in un file sull'istanza database in Amazon RDS. È importante monitorare quanto spazio di storage viene utilizzato da una traccia in esecuzione lato server perché l'istanza database potrebbe acquisire lo stato di storage completo e non sarebbe più disponibile se lo spazio di storage venisse esaurito.
Per le tracce lato client, dopo che una quantità sufficiente di dati di traccia è stata acquisita in SQL Server Profiler, puoi generare il file del carico di lavoro salvando la traccia in un file sul computer locale o in una tabella di database su un'istanza database accessibile dal computer client. Il principale svantaggio dell'utilizzo di una traccia lato client consiste nel fatto che la traccia potrebbe non essere in grado di acquisire tutte le query in condizioni di carico intenso. Ciò potrebbe rendere meno efficace l'analisi eseguita da Database Engine Tuning Advisor. Se devi eseguire una traccia con carichi intensi e desideri fare in modo che tale traccia acquisisca ogni query di una sessione di traccia, è preferibile utilizzare una traccia lato server.
Per le tracce lato server, devi memorizzare i file di traccia sull'istanza database in un file del carico di lavoro idoneo oppure puoi salvare la traccia in una tabella sull'istanza database dopo il suo completamento. Puoi utilizzare SQL Server Profiler per salvare la traccia in un file sul computer o fare in modo che Tuning Advisor legga la tabella di traccia sull'istanza database.
# Esecuzione di una traccia lato client su un'istanza database SQL Server
**Per eseguire una traccia lato client su un'istanza database SQL Server**
1. Avvia SQL Server Profiler. SQL Server Profiler è installato nella sottocartella Performance Tools della cartella della tua istanza SQL Server. Per avviare una traccia lato client, devi caricare o definire un modello di definizione di traccia.
1. Nel menu SQL Server Profiler File (File di SQL Server Profiler), fai clic su **New Trace (Nuova traccia)**. Nella casella di dialogo **Connect to Server (Connessione al server)**, immetti l'endpoint dell'istanza database, la porta, il nome utente e la password master per il database per cui desideri eseguire la traccia.
1. Nella casella di dialogo **Trace Properties (Proprietà traccia)**, immetti un nome per la traccia e scegli un modello di definizione della traccia. Un modello predefinito, TSQL\$1Replay, viene fornito con l'applicazione. Puoi modificare questo modello per definire la tua traccia. Modifica gli eventi e le relative informazioni nella scheda **Events Selection (Selezione eventi)** della casella di dialogo **Trace Properties**.
Per ulteriori informazioni sui modelli di definizione della traccia e sull'utilizzo di SQL Server Profiler per specificare una traccia lato client, consulta [Database Engine Tuning Advisor](https://docs.microsoft.com/en-us/sql/relational-databases/performance/database-engine-tuning-advisor) nella documentazione Microsoft..
1. Avvia la traccia lato client e osserva in tempo reale le query SQL che vengono eseguite sull'istanza database.
1. Selezionare **Stop Trace (Arresta traccia)** dal menu **File (File)** quando hai completato la traccia. Salva i risultati in un file o come tabella di traccia sull'istanza database.
# Esecuzione di una traccia lato server su un'istanza database SQL Server
Scrivere script per la creazione di una traccia lato server può essere complicato e non rientra nell'ambito di questo documento. Questa sezione contiene script che puoi utilizzare come esempio. Come per le tracce lato client, l'obiettivo è creare un file del carico di lavoro o una tabella di traccia che puoi aprire con Database Engine Tuning Advisor.
Di seguito è riportato uno script sintetico di esempio per l'avvio di una traccia lato server e l'acquisizione dei dettagli in un file del carico di lavoro. La traccia viene inizialmente salvata nel file RDSTrace .trc nella directory D:\$1RDSDBDATA\$1Log e viene eseguita il rollover ogni 100 MB, quindi i file di traccia successivi vengono denominati RDSTrace \$11.trc, \$12.trc, ecc. RDSTrace
```
DECLARE @file_name NVARCHAR(245) = 'D:\RDSDBDATA\Log\RDSTrace';
DECLARE @max_file_size BIGINT = 100;
DECLARE @on BIT = 1
DECLARE @rc INT
DECLARE @traceid INT
EXEC @rc = sp_trace_create @traceid OUTPUT, 2, @file_name, @max_file_size
IF (@rc = 0) BEGIN
EXEC sp_trace_setevent @traceid, 10, 1, @on
EXEC sp_trace_setevent @traceid, 10, 2, @on
EXEC sp_trace_setevent @traceid, 10, 3, @on
. . .
EXEC sp_trace_setfilter @traceid, 10, 0, 7, N'SQL Profiler'
EXEC sp_trace_setstatus @traceid, 1
END
```
L'esempio seguente consiste in uno script per l'arresto di una traccia. La traccia creata dallo script precedente continua a essere eseguita finché non la arresti esplicitamente o il processo esaurisce lo spazio su disco.
```
DECLARE @traceid INT
SELECT @traceid = traceid FROM ::fn_trace_getinfo(default)
WHERE property = 5 AND value = 1 AND traceid <> 1
IF @traceid IS NOT NULL BEGIN
EXEC sp_trace_setstatus @traceid, 0
EXEC sp_trace_setstatus @traceid, 2
END
```
Puoi salvare i risultati di una traccia lato server in una tabella di database e servirti di questa tabella come carico di lavoro per Tuning Advisor utilizzando la funzione fn\$1trace\$1gettable. I comandi seguenti caricano i risultati di tutti i file denominati RDSTrace .trc nella directory D:\$1rdsdbdata\$1Log, inclusi tutti i file di rollover come \$11.trc, in una tabella denominata nel database corrente. RDSTrace RDSTrace
```
SELECT * INTO RDSTrace
FROM fn_trace_gettable('D:\rdsdbdata\Log\RDSTrace.trc', default);
```
Per salvare un file di rollover specifico in una tabella, ad esempio il file RDSTrace \$11.trc, specificate il nome del file di rollover e sostituite 1 invece di default come ultimo parametro di fn\$1trace\$1gettable.
```
SELECT * INTO RDSTrace_1
FROM fn_trace_gettable('D:\rdsdbdata\Log\RDSTrace_1.trc', 1);
```
# Esecuzione di Tuning Advisor con una traccia
Una volta creata una traccia come file locale o tabella di database, puoi eseguire Tuning Advisor sull'istanza database. Per utilizzare Tuning Advisor con Amazon RDS si segue la stessa procedura adottata quando si lavora con un'istanza SQL Server remota standalone. Puoi utilizzare l'interfaccia utente di Tuning Advisor sulla macchina client oppure l'utilità dta.exe dalla riga di comando. In entrambi i casi, devi connetterti all'istanza database Amazon RDS utilizzando il relativo endpoint e fornire il tuo nome utente e la tua password master quando utilizzi Tuning Advisor.
L'esempio di codice seguente mostra l'uso dell'utilità a riga di comando dta.exe su un'istanza database Amazon RDS con un endpoint **dta.cnazcmklsdei.us-east-1.rds.amazonaws.com**. Nell'esempio sono inclusi il nome utente master **admin** e la password utente master **test**, il database di esempio da sintonizzare è denominato dal computer **C:\$1RDSTrace.trc**. Il codice della riga di comando di esempio specifica una sessione di traccia denominata **RDSTrace1** e i file di output nel computer locale denominati **RDSTrace.sql** per lo script di output SQL, **RDSTrace.txt** per un file dei risultati e **RDSTrace.xml** per un file XML dell'analisi. Nel database RDSDTA è anche specificata una tabella degli errori denominata **RDSTraceErrors**.
```
dta -S dta.cnazcmklsdei.us-east-1.rds.amazonaws.com -U admin -P test -D RDSDTA -if C:\RDSTrace.trc -s RDSTrace1 -of C:\ RDSTrace.sql -or C:\ RDSTrace.txt -ox C:\ RDSTrace.xml -e RDSDTA.dbo.RDSTraceErrors
```
Ecco il codice della riga di comando di esempio, ma il carico di lavoro di input qui è una tabella nell'istanza Amazon RDS remota denominata **RDSTrace**, che si trova nel database **RDSDTA**.
```
dta -S dta.cnazcmklsdei.us-east-1.rds.amazonaws.com -U admin -P test -D RDSDTA -it RDSDTA.dbo.RDSTrace -s RDSTrace1 -of C:\ RDSTrace.sql -or C:\ RDSTrace.txt -ox C:\ RDSTrace.xml -e RDSDTA.dbo.RDSTraceErrors
```
Per un elenco completo dei parametri della riga di comando dell'utilità dta, consulta [dta Utility](https://docs.microsoft.com/en-us/sql/tools/dta/dta-utility) nella documentazione di Microsoft.
# Modifica di `db_owner` nell’account `rdsa` per il database Amazon RDS per SQL Server
Quando crei o ripristini un database in un'istanza database di RDS per SQL Server, Amazon RDS imposta il proprietario del database su `rdsa`. Se disponi di una distribuzione Multi-AZ che utilizza SQL Server Database Mirroring (DBM) o Always On Availability Groups ()AGs, Amazon RDS imposta il proprietario del database sull'istanza DB secondaria su. `NT AUTHORITY\SYSTEM` Il proprietario del database secondario non può essere modificato finché l'istanza database secondaria non viene promossa al ruolo principale. Nella maggior parte dei casi, impostare il proprietario del database su `NT AUTHORITY\SYSTEM` non è problematico durante l'esecuzione delle query, tuttavia può generare errori durante l'esecuzione di stored procedure nel sistema, come `sys.sp_updatestats` che richiedono autorizzazioni elevate per l'esecuzione.
È possibile utilizzare la seguente query per identificare il proprietario dei database di proprietà di `NT AUTHORITY\SYSTEM`:
```
SELECT name FROM sys.databases WHERE SUSER_SNAME(owner_sid) = 'NT AUTHORITY\SYSTEM';
```
Puoi utilizzare la stored procedure `rds_changedbowner_to_rdsa` di Amazon RDS per cambiare il proprietario del database in `rdsa`. Non è consentito utilizzare i seguenti database con `rds_changedbowner_to_rdsa`: `master, model, msdb, rdsadmin, rdsadmin_ReportServer, rdsadmin_ReportServerTempDB, SSISDB`.
Per modificare il proprietario del database in `rdsa`, chiama la stored procedure `rds_changedbowner_to_rdsa` e fornisci il nome del database.
**Example di utilizzo:**
```
exec msdb.dbo.rds_changedbowner_to_rdsa 'TestDB1';
```
Il parametro seguente è obbligatorio:
+ `@db_name`: il nome del database in cui modificare il proprietario del database in `rdsa`.
**Importante**
Non puoi utilizzare `rds_changedbowner_to_rdsa` per modificare la proprietà di un database con un account di accesso diverso da `rdsa`. Ad esempio, non è possibile modificare la proprietà del nome di accesso con cui è stato creato il database. Per ripristinare l’appartenenza persa al ruolo `db_owner` dell’utente master quando nessun altro utente del database può essere utilizzato per concedere l’appartenenza, reimposta la password dell’utente master per ottenere l’appartenenza al ruolo `db_owner`. Per ulteriori informazioni, consulta [Reimpostazione dell’appartenenza al ruolo db\$1owner per l’utente master per Amazon RDS per SQL Server](Appendix.SQLServer.CommonDBATasks.ResetPassword.md).
# Gestione di regole di confronto e set di caratteri per Amazon RDS per Microsoft SQL Server
Questo argomento fornisce indicazioni su come gestire regole di confronto e set di caratteri per Microsoft SQL Server in Amazon RDS. Illustra come configurare le regole di confronto durante la creazione del database e come modificarle in un secondo momento, garantendo una corretta gestione dei dati di testo in base ai requisiti linguistici e locali. Descrive inoltre le best practice per mantenere la compatibilità e le prestazioni negli ambienti SQL Server in Amazon RDS.
SQL Server supporta regole di confronto a più livelli. Quando crei l'istanza database, imposti le regole di confronto del server predefinite. Puoi ignorare le regole di confronto nel database, nella tabella o a livello di colonna.
**Topics**
+ [Regola di confronto a livello di server per Microsoft SQL Server](#Appendix.SQLServer.CommonDBATasks.Collation.Server)
+ [Regola di confronto a livello di database per Microsoft SQL Server](#Appendix.SQLServer.CommonDBATasks.Collation.Database-Table-Column)
## Regola di confronto a livello di server per Microsoft SQL Server
Quando crei un'istanza database di Microsoft SQL Server, puoi impostare le regole di confronto del server che desideri utilizzare. Se non scegli regole di confronto diverse, per impostazione predefinita le regole di confronto a livello di server sono SQL\$1Latin1\$1General\$1 \$1CI\$1AS. CP1 Le regole di confronto del server vengono applicate per impostazione predefinita a tutti i database e agli oggetti di database.
**Nota**
Non è possibile modificare le regole di confronto quando si esegue il ripristino da uno snapshot DB.
Amazon RDS al momento supporta le seguenti regole di confronto del server:
| Collation (Regola di confronto) | Description |
| --- | --- |
| Arabic\$1CI\$1AS | Arabo, senza distinzione tra maiuscole e minuscole, con distinzione dei caratteri accentati, senza distinzione tra tipi di kana, senza distinzione della larghezza |
| Cinese\$1PRC\$1 BIN2 | Chinese-RPC, ordinamento dei punti di codice binario |
| Chinese\$1PRC\$1CI\$1AS | TuChinese\$1PRC, senza distinzione tra maiuscole e minuscole, con distinzione dei caratteri accentati, senza distinzione tra tipi di kana, senza distinzione della larghezza |
| Chinese\$1Taiwan\$1Stroke\$1CI\$1AS | Chinese\$1Taiwan\$1Stroke, senza distinzione tra maiuscole e minuscole, con distinzione dei caratteri accentati, senza distinzione tra tipi di kana, senza distinzione della larghezza |
| Danish\$1Norwegian\$1CI\$1AS | Danese-Norvegese, senza distinzione tra maiuscole e minuscole, con distinzione dei caratteri accentati, senza distinzione tra tipi di kana, senza distinzione della larghezza |
| Danish\$1Norwegian\$1CI\$1AS\$1KS | Danish-Norwegian, case-insensitive, accent-sensitive, kanatype-insensitive, width-insensitive |
| Danish\$1Norwegian\$1CI\$1AS\$1KS\$1WS | Danish-Norwegian, case-insensitive, accent-sensitive, kanatype-sensitive, width-sensitive |
| Danish\$1Norwegian\$1CI\$1AS\$1WS | Danish-Norwegian, case-insensitive, accent-sensitive, kanatype-insensitive, width-sensitive |
| Danish\$1Norwegian\$1CS\$1AI | Danish-Norwegian, case-sensitive, accent-insensitive, kanatype-insensitive, width-insensitive |
| Danish\$1Norwegian\$1CS\$1AI\$1KS | Danish-Norwegian, case-sensitive, accent-insensitive, kanatype-sensitive, width-insensitive |
| Finnish\$1Swedish\$1100\$1BIN | Finnish-Swedish-100, binary sort |
| Finlandese\$1svedese\$1100\$1 BIN2 | Finnish-Swedish-100, ordinamento binario basato sul confronto dei punti di codice |
| Finnish\$1Swedish\$1100\$1CI\$1AI | Finnish-Swedish-100, case-insensitive, accent-insensitive, kanatype-insensitive, width-insensitive |
| Finnish\$1Swedish\$1100\$1CI\$1AS | Finnish-Swedish-100, case-insensitive, accent-sensitive, kanatype-insensitive, width-insensitive |
| Finnish\$1Swedish\$1CI\$1AS | Finnish, Swedish, and Swedish (Finland), case-insensitive, accent-sensitive, kanatype-insensitive, width-insensitive |
| French\$1CI\$1AS | Francese, senza distinzione tra maiuscole e minuscole, con distinzione dei caratteri accentati, senza distinzione tra tipi di kana, senza distinzione della larghezza |
| Greek\$1CI\$1AS | Greek, case-insensitive, accent-sensitive, kanatype-insensitive, width-insensitive |
| Greek\$1CS\$1AS | Greek, case-sensitive, accent-sensitive, kanatype-insensitive, width-insensitive |
| Hebrew\$1BIN | Hebrew, binary sort |
| Hebrew\$1CI\$1AS | Ebraico, non sensibile al maiuscolo/minuscolo, sensibile ai caratteri accentati, non sensibile al kana, non sensibile alla larghezza |
| Japanese\$1BIN | Giapponese, ordinamento binario |
| Japanese\$1CI\$1AS | Japanese, case-insensitive, accent-sensitive, kanatype-insensitive, width-insensitive |
| Japanese\$1CS\$1AS | Giapponese, con distinzione tra maiuscole e minuscole, con distinzione dei caratteri accentati, senza distinzione tra tipi di kana, senza distinzione della larghezza |
| Japanese\$1XJIS\$1140\$1CI\$1AS | Giapponese, senza distinzione tra maiuscole e minuscole, con distinzione dei caratteri accentati, senza distinzione tra tipi di kana, senza distinzione della larghezza, caratteri supplementari, senza distinzione della selezione di variazione |
| Japanese\$1XJIS\$1140\$1CI\$1AS\$1KS\$1VSS | Giapponese, senza distinzione tra maiuscole e minuscole, con distinzione dei caratteri accentati, con distinzione tra tipi di kana, senza distinzione della larghezza, caratteri supplementari, con distinzione della selezione di variazione |
| Japanese\$1XJIS\$1140\$1CI\$1AS\$1VSS | Giapponese, senza distinzione tra maiuscole e minuscole, con distinzione dei caratteri accentati, senza distinzione tra tipi di kana, senza distinzione della larghezza, caratteri supplementari, con distinzione della selezione di variazione |
| Japanese\$1XJIS\$1140\$1CS\$1AS\$1KS\$1WS | Giapponese, con distinzione tra maiuscole e minuscole, con distinzione dei caratteri accentati, con distinzione tra tipi di kana, con distinzione della larghezza, caratteri supplementari, senza distinzione della selezione di variazione |
| Korean\$1Wansung\$1CI\$1AS | Coreano-Wansung, senza distinzione tra maiuscole e minuscole, con distinzione dei caratteri accentati, senza distinzione tra tipi di kana, senza distinzione della larghezza |
| Latin1\$1General\$1100\$1BIN | Latin1-General-100, ordinamento binario |
| Latino 1\$1General\$1100\$1 BIN2 | Latin1-General-100, ordinamento dei punti di codice binario |
| Latino1\$1General\$1100\$1 \$1 BIN2 UTF8 | Latin1-General-100, ordinamento dei punti di codice binario, con codifica UTF-8 |
| Latin1\$1General\$1100\$1CI\$1AS | Latin1-General-100, senza distinzione tra maiuscole e minuscole, con distinzione dei caratteri accentati, senza distinzione tra tipi di kana, senza distinzione della larghezza |
| Latino1\$1General\$1100\$1CI\$1AS\$1SC\$1 UTF8 | Latin1-General-100, senza distinzione tra maiuscole e minuscole, con distinzione dei caratteri accentati, caratteri supplementari, con codifica UTF-8 |
| Latin1\$1General\$1BIN | Latin1-General, ordinamento binario |
| Latin1\$1General\$1 BIN2 | Latin1-General, ordinamento dei punti di codice binario |
| Latin1\$1General\$1CI\$1AI | Latin1-General, senza distinzione tra maiuscole e minuscole, senza distinzione dei caratteri accentati, senza distinzione tra tipi di kana, senza distinzione della larghezza |
| Latin1\$1General\$1CI\$1AS | Latin1-General, senza distinzione tra maiuscole e minuscole, con distinzione dei caratteri accentati, senza distinzione tra tipi di kana, senza distinzione della larghezza |
| Latin1\$1General\$1CI\$1AS\$1KS | Latin1-General, senza distinzione tra maiuscole e minuscole, con distinzione dei caratteri accentati, con distinzione tra tipi di kana, senza distinzione della larghezza |
| Latin1\$1General\$1CS\$1AS | Latin1-General, con distinzione tra maiuscole e minuscole, con distinzione dei caratteri accentati, senza distinzione tra tipi di kana, senza distinzione della larghezza |
| Modern\$1Spanish\$1CI\$1AS | Spagnolo-moderno, senza distinzione tra maiuscole e minuscole, con distinzione dei caratteri accentati, senza distinzione tra tipi di kana, senza distinzione della larghezza |
| Polish\$1CI\$1AS | Polacco, senza distinzione tra maiuscole e minuscole, con distinzione dei caratteri accentati, senza distinzione tra tipi di kana, senza distinzione della larghezza |
| SQL\$11xCompat\$1 \$1CI\$1AS CP850 | Latin1-General, senza distinzione tra maiuscole e minuscole, con distinzione dei caratteri accentati, senza distinzione tra tipi di kana, senza distinzione della larghezza per dati Unicode, Ordinamento SQL Server 49 su tabella codici 850 per dati non-Unicode |
| CP1SQL\$1Latin1\$1General\$1 \$1CI\$1AI | Latin1-General, senza distinzione tra maiuscole e minuscole, senza distinzione dei caratteri accentati, senza distinzione tra tipi di kana, senza distinzione della larghezza per dati Unicode, Ordinamento SQL Server 54 su tabella codici 1252 per dati non-Unicode |
| **SQL\$1Latin1\$1General\$1 \$1CI\$1AS (impostazione predefinitaCP1)** | Latin1-General, senza distinzione tra maiuscole e minuscole, con distinzione dei caratteri accentati, senza distinzione tra tipi di kana, senza distinzione della larghezza per dati Unicode, Ordinamento SQL Server 52 su tabella codici 1252 per dati non-Unicode |
| SQL\$1Latin1\$1General\$1 \$1CS\$1AS CP1 | Latin1-General, con distinzione tra maiuscole e minuscole, con distinzione dei caratteri accentati, senza distinzione tra tipi di kana, senza distinzione della larghezza per dati Unicode, Ordinamento SQL Server 51 su tabella codici 1252 per dati non-Unicode |
| CP437SQL\$1Latin1\$1General\$1 \$1CI\$1AI | Latin1-General, senza distinzione tra maiuscole e minuscole, senza distinzione dei caratteri accentati, senza distinzione tra tipi di kana, senza distinzione della larghezza per dati Unicode, Ordinamento SQL Server 34 su codepage 437 per dati non-Unicode |
| SQL\$1Latin1\$1General\$1 \$1BIN CP850 | Latin1-General, ordinamento binario per dati Unicode, SQL Server Ordinamento 40 su codepage 850 per dati non-Unicode |
| SQL\$1Latin1\$1generale\$1 \$1 CP850 BIN2 | Latin1-General, ordinamento dei punti di codice binario per dati Unicode, SQL Server Sort Order 40 on Code Page 850 per dati non-Unicode |
| SQL\$1Latin1\$1Generale\$1 CP850 \$1CI\$1AI | Latin1-General, senza distinzione tra maiuscole e minuscole, senza distinzione dei caratteri accentati, senza distinzione tra tipi di kana, senza distinzione della larghezza per dati Unicode, Ordinamento SQL Server 44 su tabella codici 850 per dati non-Unicode |
| CP850SQL\$1Latin1\$1General\$1 \$1CI\$1AS | Latin1-General, senza distinzione tra maiuscole e minuscole, con distinzione dei caratteri accentati, senza distinzione tra tipi di kana, senza distinzione della larghezza per dati Unicode, Ordinamento SQL Server 42 su tabella codici 850 per dati non-Unicode |
| SQL\$1Latin1\$1general\$1pref\$1 CP850 \$1CI\$1AS | Latin1-General-Pref, case-insensitive, accent-sensitive, kanatype-insensitive, width-insensitive per dati Unicode, SQL Server Sort Order 183 su tabella codici 850 per dati non-Unicode |
| CP1256SQL\$1Latin1\$1General\$1 \$1CI\$1AS | Latin1-General, senza distinzione tra maiuscole e minuscole, con distinzione dei caratteri accentati, senza distinzione tra tipi di kana, senza distinzione della larghezza per dati Unicode, Ordinamento SQL Server 146 su tabella codici 1256 per dati non-Unicode |
| CP1255SQL\$1Latin1\$1General\$1 \$1CS\$1AS | Latin1-General, case-sensitive, accent-sensitive, kanatype-insensitive, width-insensitive per dati Unicode, SQL Server Sort Order 137 su tabella codici 1255 per dati non-Unicode |
| Thai\$1CI\$1AS | Thailandese, senza distinzione tra maiuscole e minuscole, con distinzione dei caratteri accentati, senza distinzione tra tipi di kana, senza distinzione della larghezza |
| Turkish\$1CI\$1AS | Turco, senza distinzione tra maiuscole e minuscole, con distinzione dei caratteri accentati, senza distinzione tra tipi di kana, senza distinzione della larghezza |
È inoltre possibile recuperare l’elenco delle regole di confronto supportate a livello di codice utilizzando AWS CLI:
```
aws rds describe-db-engine-versions --engine sqlserver-ee --list-supported-character-sets --query 'DBEngineVersions[].SupportedCharacterSets[].CharacterSetName' | sort -u
```
Per scegliere le regole di confronto:
+ Se utilizzi la console Amazon RDS, quando crei una nuova istanza database scegli **Additional configuration** (Configurazione aggiuntiva), quindi immetti le regole di confronto nel campo **Collation** (Regole di confronto). Per ulteriori informazioni, consulta [Creazione di un'istanza database Amazon RDS](USER_CreateDBInstance.md).
+ Se stai usando il, usa l'opzione con il comando. AWS CLI`--character-set-name` `create-db-instance` Per ulteriori informazioni, consulta [create-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html).
+ Se utilizzi l'API Amazon RDS, scegli il parametro `CharacterSetName` con l'operazione `CreateDBInstance`. Per ulteriori informazioni, consulta [Create DBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html).
## Regola di confronto a livello di database per Microsoft SQL Server
Puoi cambiare la collazione predefinita a livello di database, tabella o colonna sovrascrivendola durante la creazione di un nuovo database o oggetto di database. Ad esempio, se le regole di confronto predefinite del server sono SQL\$1Latin1\$1General\$1 \$1CI\$1AS, puoi cambiarle in CP1 Mohawk\$1100\$1CI\$1AS per il supporto delle regole di confronto Mohawk. Può essere eseguito il cast del tipo anche per gli argomenti di una query, in modo tale da utilizzare una collazione diversa, se necessario.
Ad esempio, la seguente query cambierebbe le regole di confronto predefinite per la colonna AccountName in Mohawk\$1100\$1CI\$1AS
```
CREATE TABLE [dbo].[Account]
(
[AccountID] [nvarchar](10) NOT NULL,
[AccountName] [nvarchar](100) COLLATE Mohawk_100_CI_AS NOT NULL
) ON [PRIMARY];
```
Il motore di database di Microsoft SQL Server supporta lo standard Unicode tramite i tipi di dati incorporati NCHAR, NVARCHAR e NTEXT. Se ad esempio hai bisogno del supporto CJK, utilizzerai i tipi di dati Unicode per l'archiviazione di caratteri e sovrascriverai la collazione server predefinita durante la creazione di tuoi database e tabelle. Ecco alcuni collegamenti Microsoft a pagine che trattano della collazione e del supporto Unicode per SQL Server:
+ [Utilizzo delle collazioni](http://msdn.microsoft.com/en-us/library/ms187582%28v=sql.105%29.aspx)
+ [Collazione e terminologia internazionale](http://msdn.microsoft.com/en-us/library/ms143726%28v=sql.105%29)
+ [Utilizzo delle collazioni per SQL Server](http://msdn.microsoft.com/en-us/library/ms144260%28v=sql.105%29.aspx)
+ [Considerazioni di carattere internazionale per i database e i motori di database](http://msdn.microsoft.com/en-us/library/ms190245%28v=sql.105%29.aspx)
# Creazione di un utente del database per Amazon RDS per SQL Server
Puoi creare un utente di database per l'istanza database di Amazon RDS for Microsoft SQL Server eseguendo uno script T-SQL come nell'esempio di seguito. Utilizza un'applicazione come SQL Server Management Suite (SSMS). Accedi all'istanza database come l'utente principale creato quando è stata creata l'istanza database.
```
--Initially set context to master database
USE [master];
GO
--Create a server-level login named theirname with password theirpassword
CREATE LOGIN [theirname] WITH PASSWORD = 'theirpassword';
GO
--Set context to msdb database
USE [msdb];
GO
--Create a database user named theirname and link it to server-level login theirname
CREATE USER [theirname] FOR LOGIN [theirname];
GO
```
Per un esempio di aggiunta di un utente di database a un ruolo, consulta [Aggiunta di un utente al ruolo SQLagentUser](SQLServerAgent.AddUser.md).
**Nota**
Se si ottengono errori di autorizzazione durante l'aggiunta di un utente, è possibile ripristinare i privilegi modificando la password per l'utente principale dell'istanza database. Per ulteriori informazioni, consulta [Reimpostazione dell’appartenenza al ruolo db\$1owner per l’utente master per Amazon RDS per SQL Server](Appendix.SQLServer.CommonDBATasks.ResetPassword.md).
Non è consigliabile clonare le autorizzazioni degli utenti master nelle applicazioni. Per ulteriori informazioni, consulta [How to clone master user permissions in Amazon RDS per SQL Server](https://aws.amazon.com/blogs/database/how-to-clone-master-user-permissions-in-amazon-rds-for-sql-server/).
# Individuazione di un modello di ripristino per il database Amazon RDS per SQL Server
In Amazon RDS, modello di ripristino, periodo di retention e stato del database sono correlati.
È importante comprendere le conseguenze prima di apportare una modifiche a una di queste impostazioni. Ogni impostazione può influenzare le altre. Ad esempio:
+ Se modifichi il modello di ripristino del database in SIMPLE o BULK\$1LOGGED quando è abilitata la retention dei backup, Amazon RDS reimposta il modello di ripristino su FULL entro cinque minuti dalla modifica. Questo comporta anche l'acquisizione di uno snapshot dell'istanza database da parte di RDS.
+ Se imposti la retention dei backup su `0`, RDS reimposta la modalità di ripristino su SIMPLE.
+ Se modifichi il modello di ripristino del database da SIMPLE a una qualsiasi altra opzione quando la retention dei backup è impostata su `0` giorni, RDS reimposta il modello di ripristino nuovamente su SIMPLE.
**Importante**
Non effettuare mai il passaggio del modello di ripristino alle istanze Multi-AZ, sebbene sembri un'operazione che puoi eseguire, —ad esempio, tramite ALTER DATABASE. La retention dei backup e quindi il modello di ripristino su "FULL" (Completo) sono necessari per Multi-AZ. Se modifichi il modello di ripristino, RDS lo reimposta immediatamente su "FULL" (Completo).
Questa reimpostazione automatica forza RDS a ricreare completamente la replica. Durante il processo di ricreazione, la disponibilità del database viene ridotta per circa 30-90 minuti finché il mirroring non è pronto per il failover. Anche l'istanza database subisce un calo delle prestazioni nello stesso modo in cui avviene durante una conversione da Single-AZ a Multi-AZ. La durata di questo calo delle prestazioni dipende dalle dimensioni di storage —del database: più grande è lo storage archiviato, più a lungo durerà il calo.
Per ulteriori informazioni sui modelli di ripristino di SQL Server, consulta [Modelli di ripristino (SQL Server)](https://docs.microsoft.com/en-us/sql/relational-databases/backup-restore/recovery-models-sql-server) nella documentazione di Microsoft.
# Individuazione dell’ora dell’ultimo failover per Amazon RDS per SQL Server
Per determinare l'ora dell'ultimo failover, utilizza la seguente stored procedure:
```
execute msdb.dbo.rds_failover_time;
```
Questa procedura restituisce le seguenti informazioni.
****
| Parametro di output | Descrizione |
| --- | --- |
| errorlog\$1available\$1from | Mostra l'ora in cui i log degli errori sono disponibili nella directory dei log. |
| recent\$1failover\$1time | Mostra l'ora dell'ultimo failover, se è disponibile nei log degli errori. In caso contrario mostra `null`. |
**Nota**
La stored procedure esegue la ricerca di tutti i log degli errori di SQL Server disponibili nella directory di log per recuperare l'ora del failover più recente. Se i messaggi di failover sono stati sovrascritti da SQL Server, la procedura non recupera l'ora di failover.
**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.
| 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.
| errorlog\$1available\$1from | recent\$1failover\$1time |
| --- | --- |
| 2020-04-29 23:59:00.0100000 | 2020-05-05 18:57:51.8900000 |
# Risoluzione dei problemi di recupero point-in-time dovuti a un divario dei numeri nella sequenza di log
Quando si tenta il recupero point-in-time (PITR) in RDS per SQL Server, è possibile che si verifichino errori dovuti a divario dei numeri nella sequenza di log (LSN). Questi divari impediscono a RDS di ripristinare il database all’ora richiesta e RDS colloca l’istanza di ripristino in uno stato `incompatible-restore`.
Le cause comuni di tale problema sono indicate di seguito:
+ Modifiche manuali al modello di ripristino del database.
+ Modifiche automatiche al modello di ripristino da parte di RDS a causa di risorse insufficienti per il completamento dei backup dei log delle transazioni.
Per identificare i divari LSN nel database, esegui questa query:
```
SELECT * FROM msdb.dbo.rds_fn_list_tlog_backup_metadata(database_name)
ORDER BY backup_file_time_utc desc;
```
Se scopri un divario LSN, puoi:
+ Scegliere un punto di ripristino prima del divario LSN.
+ Attendere e ripristinare a un punto dopo il completamento del backup dell’istanza successiva.
Per evitare questo problema, è consigliabile non modificare manualmente il modello di ripristino dei database RDS per SQL Server, poiché ciò interrompe la durabilità dell’istanza. È inoltre consigliabile scegliere un tipo di istanza con risorse sufficienti per il carico di lavoro per garantire backup regolari dei log delle transazioni.
Per ulteriori informazioni sulla gestione dei log delle transazioni, consulta [SQL Server transaction log architecture and management guide](https://learn.microsoft.com/en-us/sql/relational-databases/sql-server-transaction-log-architecture-and-management-guide?view=sql-server-ver16) nella documentazione di Microsoft SQL Server.
# Negare o consentire la visualizzazione dei nomi dei database per Amazon RDS per SQL Server
L’utente master non può impostare `DENY VIEW ANY DATABASE TO LOGIN` per nascondere i database a un utente.
Per modificare questa autorizzazione, utilizza invece la seguente stored procedure:
+ Negare l’accesso alla visualizzazione del database a *LOGIN*:
```
EXEC msdb.dbo.rds_manage_view_db_permission @permission=‘DENY’, @server_principal=‘LOGIN’
go
```
+ Consentire l’accesso alla visualizzazione del database a *LOGIN*:
```
EXEC msdb.dbo.rds_manage_view_db_permission @permission='GRANT', @server_principal='LOGIN'
go
```
Quando utilizzi questa stored procedure, tieni presenti le considerazioni riportate di seguito:
+ I nomi dei database sono nascosti agli SSMS e alle DMV interne (viste a gestione dinamica). Tuttavia, i nomi dei database sono ancora visibili nelle tabelle di controllo, log e metadati. Si tratta di autorizzazioni server `VIEW ANY DATABASE` protette. Per ulteriori informazioni, consulta [DENY Server Permissions](https://learn.microsoft.com/en-us/sql/t-sql/statements/deny-server-permissions-transact-sql?view=sql-server-ver16#permissions).
+ Una volta ripristinata l’autorizzazione a `GRANT` (consentita), *LOGIN* può visualizzare tutti i database.
+ Se elimina e ricrea *LOGIN*, l’autorizzazione di visualizzazione relativa al LOGIN viene reimpostata su `ALLOW`.
+ Per le istanze Multi-AZ, imposta l’autorizzazione `GRANT` o `DENY` solo per il *LOGIN* sull’host primario. Le modifiche vengono propagate automaticamente all’host secondario.
+ Questa autorizzazione modifica solo se un login può visualizzare i nomi dei database. Tuttavia, l’accesso ai database e agli oggetti al loro interno vengono gestiti separatamente.
# Disattivazione degli inserti rapidi durante il caricamento in blocco per Amazon RDS per SQL Server
A partire da SQL Server 2016, gli inserimenti rapidi sono abilitati per impostazione predefinita. Gli inserti rapidi sfruttano la registrazione minima che si verifica mentre il database si trova nel modello di recupero con registrazione semplice o in blocco per ottimizzare le prestazioni di inserimento. Con inserti rapidi, ogni batch di carico di massa acquisisce nuove estensioni, ignorando la ricerca di allocazione per le estensioni esistenti con spazio libero disponibile per ottimizzare le prestazioni dell'inserto.
Tuttavia, con carichi di massa di inserti rapidi con piccole dimensioni batch possono portare a un aumento dello spazio inutilizzato consumato dagli oggetti. Se non è possibile aumentare la dimensione del batch, l'abilitazione del flag di traccia 692 può contribuire a ridurre lo spazio riservato inutilizzato, ma a scapito delle prestazioni. L'attivazione di questo flag di traccia disabilita gli inserti rapidi durante il caricamento di massa dei dati in heap o indici cluster.
È possibile attivare il flag di traccia 692 come parametro di avvio utilizzando gruppi di parametri DB. Per ulteriori informazioni, consulta [Gruppi di parametri per Amazon RDS](USER_WorkingWithParamGroups.md).
Il flag di traccia 692 è supportato per Amazon RDS su SQL Server 2016 e versioni successive. Per ulteriori informazioni sui flag di traccia, vedere [DBCC TRACEON - Trace Flags](https://docs.microsoft.com/en-us/sql/t-sql/database-console-commands/dbcc-traceon-trace-flags-transact-sql) nella documentazione di Microsoft.
# Eliminazione di un database in un’istanza database Amazon RDS per Microsoft SQL Server
Puoi rimuovere un database su un'istanza database Amazon RDS che esegue Microsoft SQL Server in un'implementazione Single-AZ o Multi-AZ. Per rimuovere il database, utilizzare il seguente comando:
```
--replace your-database-name with the name of the database you want to drop
EXECUTE msdb.dbo.rds_drop_database N'your-database-name'
```
**Nota**
Utilizza virgolette singole diritte nel comando. In caso contrario, si verifica un errore.
Dopo aver utilizzato questa procedura per la rimozione del database, Amazon RDS rimuove tutte le connessioni al database esistenti e la cronologia dei backup del database.
Per concedere l’autorizzazione per il backup e il ripristino ad altri utenti, segui questa procedura:
```
USE master
GO
CREATE LOGIN user1 WITH PASSWORD=N'changeThis', DEFAULT_DATABASE=master, CHECK_EXPIRATION=OFF, CHECK_POLICY=OFF
GO
USE msdb
GO
CREATE USER user1 FOR LOGIN user1
GO
use msdb
GO
GRANT EXECUTE ON msdb.dbo.rds_backup_database TO user1
GO
GRANT EXECUTE ON msdb.dbo.rds_restore_database TO user1
GO
```
# Ridenominazione di un database Amazon RDS per Microsoft SQL Server in un’implementazione Multi-AZ
Per assegnare un nuovo nome a un'istanza database Microsoft SQL Server che utilizza Multi-AZ, utilizzare la procedura seguente:
1. Innanzitutto, disattivare Multi-AZ per l'istanza database.
1. Rinomina il database eseguendo `rdsadmin.dbo.rds_modify_db_name`.
1. Quindi, attiva il mirroring Multi-AZ o i gruppi di disponibilità AlwaysON per l'istanza database, per riportarla nel suo stato originario.
Per ulteriori informazioni, consulta [Aggiunta di Multi-AZ a un'istanza database di Microsoft SQL Server](USER_SQLServerMultiAZ.md#USER_SQLServerMultiAZ.Adding).
**Nota**
Se l'istanza non utilizza Multi-AZ, non è necessario modificare alcuna impostazione prima o dopo aver eseguito `rdsadmin.dbo.rds_modify_db_name`.
Non è possibile rinominare un database su un’istanza sorgente di replica in lettura.
**Esempio: **nell'esempio seguente la stored procedure `rdsadmin.dbo.rds_modify_db_name` rinomina un database da **MOO** a **ZAR**. Ciò equivale all'esecuzione dell'istruzione `DDL ALTER DATABASE [MOO] MODIFY NAME = [ZAR]`.
```
EXEC rdsadmin.dbo.rds_modify_db_name N'MOO', N'ZAR'
GO
```
# Reimpostazione dell’appartenenza al ruolo db\$1owner per l’utente master per Amazon RDS per SQL Server
Se impedisci all’utente master di accedere al ruolo `db_owner` nel database RDS per SQL Server e nessun altro utente del database può concedere l’appartenenza, puoi ripristinare l’appartenenza persa modificando la password dell’utente master dell’istanza database.
Modificando la password dell’utente master dell’istanza database, RDS concede l’appartenenza `db_owner` ai database dell’istanza database che potrebbe essere stata revocata accidentalmente. Puoi modificare la password dell'istanza DB utilizzando la console Amazon RDS, il AWS CLI comando [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html)o utilizzando l'operazione [Modify DBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html) API. Per ulteriori informazioni sulla modifica di un'istanza database, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
# Ripristino di istanze database terminate in base alla licenza per Amazon RDS per SQL Server
Microsoft ha richiesto che alcuni clienti Amazon RDS che non hanno segnalato le proprie informazioni sulla mobilità delle licenze Microsoft interrompano la propria istanza database. Amazon RDS acquisisce snapshot di queste istanze database ed è possibile eseguire il ripristino dallo snapshot in una nuova istanza database con il modello con licenza inclusa.
Puoi eseguire il ripristino da una snapshot di Standard Edition creando un'istanza Standard Edition o Enterprise Edition.
Puoi eseguire il ripristino da una snapshot di Enterprise Edition creando un'istanza Standard Edition o Enterprise Edition.
**Per eseguire il ripristino da una snapshot SQL Server dopo che Amazon RDS ha creato una snapshot finale dell'istanza**
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, selezionare **Snapshots (Snapshot)**.
1. Selezionare lo snapshot dell'istanza database SQL Server. Amazon RDS crea uno snapshot finale dell'istanza database. Il nome della snapshot dell'istanza terminata è nel formato `instance_name-final-snapshot`. Ad esempio, se il nome dell'istanza DB è**mytest.cdxgahslksma.us-east-1.rds.com**, lo snapshot finale viene chiamato ** mytest-final-snapshot** e si trova nella stessa AWS regione dell'istanza DB originale.
1. Per **Actions (Operazioni)**, selezionare **Restore Snapshot (Ripristina snapshot)**.
Viene visualizzata la pagina **Restore DB Instance (Ripristina istanza database)**.
1. Per **License Model (Modello di licenza)**, scegliere **license-included (licenza inclusa)**.
1. Scegliere il motore di database di SQL Server che si desidera utilizzare.
1. Per **DB Instance Identifier (Identificatore istanze database)**, inserire il nome per l'istanza database ripristinata.
1. Selezionare **Restore DB Instance (Ripristina istanza database)**.
Per ulteriori informazioni sul ripristino da una snapshot, consulta [Ripristino in un’istanza database](USER_RestoreFromSnapshot.md).
# Transizione di un database Amazon RDS per SQL Server da OFFLINE a ONLINE
Puoi far passare il database Microsoft SQL Server in un'istanza database Amazon RDS da `OFFLINE` a `ONLINE`.
****
| Metodo SQL Server | Metodo Amazon RDS |
| --- | --- |
| MODIFICARE IL DATABASE *db\$1name* IMPOSTATO ONLINE; | ESEGUE rdsadmin.dbo.rds\$1set\$1database\$1online *db\$1name* |
# Utilizzo di Change Data Capture per Amazon RDS per SQL Server
Amazon RDS supporta Change Data Capture (CDC) per le istanze di database che eseguono Microsoft SQL Server. CDC "cattura" le modifiche effettuate ai dati delle tue tabelle. Memorizza i metadati di ogni modifica, ai quali potrai accedere successivamente. Per ulteriori informazioni sul funzionamento di CDC, consulta [Change Data Capture](https://docs.microsoft.com/en-us/sql/relational-databases/track-changes/track-data-changes-sql-server#Capture) nella documentazione di Microsoft. Prima di usare CDC con le istanze database Amazon RDS, abilitalo nel database eseguendo `msdb.dbo.rds_cdc_enable_db`. Dopo l'abilitazione di CDC, qualsiasi utente che sia `db_owner` del database interessato può abilitare o disabilitare CDC sulle tabelle di tale database.
**Importante**
Durante i ripristini, CDC verrà disabilitata. Tutti i metadati correlati saranno rimossi automaticamente dal database. Questo vale per i ripristini e point-in-time i ripristini delle istantanee. Dopo l'esecuzione di uno di questi tipi di ripristino, puoi riabilitare CDC e specificare di nuovo le tabelle da monitorare.
Per abilitare CDC per un'istanza DB, esegui la procedura archiviata `msdb.dbo.rds_cdc_enable_db`.
```
1. exec msdb.dbo.rds_cdc_enable_db 'database_name'
```
Per disabilitare CDC per un'istanza DB, esegui la procedura archiviata `msdb.dbo.rds_cdc_disable_db`.
```
1. exec msdb.dbo.rds_cdc_disable_db 'database_name'
```
Utilizza la procedura seguente per concedere le autorizzazioni CDC a un utente:
```
1. go
2. GRANT EXECUTE ON msdb.dbo.rds_cdc_enable_db TO User1
3. GRANT EXECUTE ON msdb.dbo.rds_cdc_disable_db TO User1
```
**Topics**
+ [Monitoraggio di tabelle con Change Data Capture](#Appendix.SQLServer.CommonDBATasks.CDC.tables)
+ [Processi di Change Data Capture](#Appendix.SQLServer.CommonDBATasks.CDC.jobs)
+ [Change Data Capture per istanze Multi-AZ](#Appendix.SQLServer.CommonDBATasks.CDC.Multi-AZ)
## Monitoraggio di tabelle con Change Data Capture
Dopo l'abilitazione di CDC sul database, puoi iniziare a monitorare specifiche tabelle. Puoi scegliere le tabelle da monitorare eseguendo [sys.sp\$1cdc\$1enable\$1table](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sys-sp-cdc-enable-table-transact-sql).
```
1. --Begin tracking a table
2. exec sys.sp_cdc_enable_table
3. @source_schema = N'source_schema'
4. , @source_name = N'source_name'
5. , @role_name = N'role_name'
6.
7. --The following parameters are optional:
8.
9. --, @capture_instance = 'capture_instance'
10. --, @supports_net_changes = supports_net_changes
11. --, @index_name = 'index_name'
12. --, @captured_column_list = 'captured_column_list'
13. --, @filegroup_name = 'filegroup_name'
14. --, @allow_partition_switch = 'allow_partition_switch'
15. ;
```
Per visualizzare la configurazione CDC per le tue tabelle, esegui [sys.sp\$1cdc\$1help\$1change\$1data\$1capture](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sys-sp-cdc-help-change-data-capture-transact-sql).
```
1. --View CDC configuration
2. exec sys.sp_cdc_help_change_data_capture
3.
4. --The following parameters are optional and must be used together.
5. -- 'schema_name', 'table_name'
6. ;
```
Per ulteriori informazioni sulle tabelle, funzioni e procedure memorizzate di CDC riportate nella documentazione di SQL Server, consulta le sezioni seguenti:
+ [Procedure memorizzate di Change Data Capture (Transact-SQL)](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/change-data-capture-stored-procedures-transact-sql)
+ [Funzioni di Change Data Capture (Transact-SQL)](https://docs.microsoft.com/en-us/sql/relational-databases/system-functions/change-data-capture-functions-transact-sql)
+ [Tabelle di Change Data Capture (Transact-SQL)](https://docs.microsoft.com/en-us/sql/relational-databases/system-tables/change-data-capture-tables-transact-sql)
## Processi di Change Data Capture
Quando abiliti CDC, SQL Server crea i relativi processi. I proprietari del database (`db_owner`) possono visualizzare, creare, modificare ed eliminare i processi di CDC. Tuttavia, l'account di sistema di RDS è il proprietario di tali processi. Pertanto, i processi non sono visibili per le viste e le procedure native o da SQL Server Management Studio.
Per controllare il comportamento di CDC in un database, utilizza procedure SQL Server native come [sp\$1cdc\$1enable\$1table](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sys-sp-cdc-enable-table-transact-sql) e [sp\$1cdc\$1start\$1job ](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sys-sp-cdc-start-job-transact-sql). Per modificare i parametri di un'attività di CDC, ad esempio `maxtrans` e `maxscans`, puoi utilizzare [sp\$1cdc\$1change\$1jobs. ](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sys-sp-cdc-change-job-transact-sql).
Per ulteriori informazioni sui processi di CDC, puoi interrogare le seguenti viste a gestione dinamica:
+ sys.dm\$1cdc\$1errors
+ sys.dm\$1cdc\$1log\$1scan\$1sessions
+ sysjobs
+ sysjobhistory
## Change Data Capture per istanze Multi-AZ
Se utilizzi CDC su un'istanza Multi-AZ, assicurati che la configurazione del processo di CDC del server mirror corrisponda a quella del server principale. I processi di CDC sono mappati in `database_id`. Se IDs il database secondario è diverso da quello principale, i job non verranno associati al database corretto. Per prevenire gli errori dopo un failover, RDS elimina e ricrea i processi sul nuovo server principale. I processi così ricreati utilizzano i parametri registrati dal server principale prima del failover.
Anche se questa procedura si svolge rapidamente, può sempre accadere che i processi di CDC vengano eseguiti prima che RDS possa correggerli. Di seguito sono descritti tre modi per forzare i parametri affinché siano coerenti tra le repliche principali e secondarie:
+ Usa gli stessi parametri di processo per tutti i database con CDC abilitata.
+ Prima di modificare la configurazione di un processo di CDC, converti l'istanza Multi-AZ in Single-AZ.
+ Trasferisci i parametri manualmente ogni volta che li modifichi sul server principale.
Per visualizzare e definire i parametri CDC utilizzati per ricreare i processi di CDC dopo un failover, utilizza `rds_show_configuration` e `rds_set_configuration`.
L'esempio seguente restituisce il valore impostato per `cdc_capture_maxtrans`. RDS configura automaticamente il valore di qualsiasi parametro impostato su `RDS_DEFAULT`.
```
-- Show configuration for each parameter on either primary and secondary replicas.
exec rdsadmin.dbo.rds_show_configuration 'cdc_capture_maxtrans';
```
Per impostare la configurazione sul secondario, eseguire `rdsadmin.dbo.rds_set_configuration`. Questa procedura imposta i valori del parametro per tutti i database sul server secondario. Queste impostazioni vengono utilizzate solo dopo un failover. L'esempio seguente imposta tutti `maxtrans` i processi di acquisizione CDC su*1000*:
```
--To set values on secondary. These are used after failover.
exec rdsadmin.dbo.rds_set_configuration 'cdc_capture_maxtrans', 1000;
```
Per impostare i parametri di un'attività di CDC sul server principale, utilizza [sys.sp\$1cdc\$1change\$1job](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sys-sp-cdc-change-job-transact-sql).
# Utilizzo di SQL Server Agent per Amazon RDS
Con Amazon RDS puoi utilizzare SQL Server Agent su un'istanza database che esegue Microsoft SQL Server Enterprise Edition, Standard Edition o Web Edition. SQL Server Agent è un servizio di Microsoft Windows che esegue attività pianificate di amministrazione, dette processi. Puoi utilizzare SQL Server Agent per eseguire processi T-SQL che ricostruiscono indici, eseguono controlli anticorruzione e aggregano i dati in un'istanza database SQL Server.
Quando crei un'istanza database SQL Server, l'utente master è iscritto nel ruolo `SQLAgentUserRole`.
SQL Server Agent può eseguire un processo pianificato, in risposta a un evento specifico, oppure su richiesta. Per ulteriori informazioni, consulta [SQL Server Agent](http://msdn.microsoft.com/en-us/library/ms189237) nella documentazione Microsoft.
**Nota**
Evita di pianificare i processi da eseguire durante le finestre di manutenzione e backup per l'istanza DB. I processi di manutenzione e backup che vengono avviati da AWS potrebbero interrompere un processo o causarne l'annullamento.
Nelle distribuzioni Multi-AZ, i processi di SQL Server Agent vengono replicati dall'host principale all'host secondario quando la funzionalità di replica del processo è attivata. Per ulteriori informazioni, consulta [Attivazione della replica di processo SQL Server Agent](#SQLServerAgent.Replicate).
Le implementazioni multi-AZ hanno un limite di 10.000 processi di SQL Server Agent. Se sono necessari limiti superiori, richiedere un aumento contattando Supporto. Aprire la pagina del [Centro di supporto Supporto AWS](https://console.aws.amazon.com/support/home#/) effettuando l'accesso se necessario, quindi selezionare **Crea caso**. Selezionare **Service limit increase (Aumento limiti del servizio)**. Compilare e inviare il modulo.
Per visualizzare la cronologia di uno specifico processo di SQL Server Agent in SQL Server Management Studio (SSMS), apri Object Explorer, fai clic con il pulsante destro del mouse sul processo e seleziona **View History (Visualizza cronologia)**.
Poiché SQL Server Agent è in esecuzione su un host gestito in un'istanza DB, alcune azioni non sono supportate:
+ L'esecuzione di processi di replica e di script da riga di comando con ActiveX, la shell dei comandi di Windows o con Windows PowerShell non è supportata.
+ Non è possibile avviare, arrestare o riavviare manualmente SQL Server Agent.
+ Le notifiche e-mail tramite SQL Server Agent non sono disponibili da un'istanza database.
+ Gli avvisi e gli operatori di SQL Server Agent non sono supportati.
+ L'utilizzo di SQL Server Agent per creare backup non è supportato. Utilizza Amazon RDS per il backup dell'istanza database.
+ Attualmente, RDS per SQL Server non supporta l’utilizzo di token SQL Server Agent.
## Attivazione della replica di processo SQL Server Agent
È possibile attivare la replica dei processi SQL Server Agent utilizzando la seguente stored procedure:
```
EXECUTE msdb.dbo.rds_set_system_database_sync_objects @object_types = 'SQLAgentJob';
```
È possibile eseguire la stored procedure su tutte le versioni di SQL Server supportate da Amazon RDS for SQL Server. I processi vengono replicati nelle seguenti categorie:
+ [Senza categoria (locale)]
+ [Senza categoria (multi-server)]
+ [Senza categoria]
+ Raccoglitore di dati
+ Tuning Advisor del motore del database
+ Manutenzione database
+ Full text
Vengono replicati solo i processi che utilizzano i passaggi del processo T-SQL. I processi con tipi di passaggi quali SQL Server Integration Services (SSIS), SQL Server Reporting Service (SSRS), Replication e PowerShell non vengono replicati. I processi che utilizzano Database Mail e gli oggetti a livello di server non vengono replicati.
**Importante**
L'host principale è l'origine della replica. Prima di attivare la replica di processo, assicurarsi che i processi SQL Server Agent siano sul principale. In caso contrario, è possibile che i processi SQL Server Agent vengano eliminati se la funzionalità viene attivata quando i processi più recenti si trovano sull'host secondario.
Utilizza la seguente funzione per verificare se la replica è attivata.
```
SELECT * from msdb.dbo.rds_fn_get_system_database_sync_objects();
```
Se i processi di SQL Server Agent sono in fase di replica, la query T-SQL restituisce quanto segue. Se i processi non si stanno replicando, non restituisce nulla per `object_class`.
![\[I processi SQL Server Agent sono in fase di replica\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/SQLAgentJob.png)
È possibile utilizzare la seguente funzione per trovare l'ultima volta che gli oggetti sono stati sincronizzati in base al fuso orario UTC.
```
SELECT * from msdb.dbo.rds_fn_server_object_last_sync_time();
```
Supponi, ad esempio, di modificare un processo SQL Server Agent all'01:00. Prevedi che l'orario di sincronizzazione più recente sia dopo l'01:00, il che suggerisce che la sincronizzazione è avvenuta.
Dopo la sincronizzazione, i valori restituiti per `date_created` e `date_modified` sul nodo secondario dovrebbero corrispondere.
![\[L'ultima volta che gli oggetti server sono stati sincronizzati è stato alle 01:21:23\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/SQLAgentJob_last_sync_time.png)
Se utilizzi anche la replica `tempdb`, puoi abilitare la replica sia per i processi di SQL Agent sia per la configurazione di `tempdb` specificandoli nel parametro `@object_type`:
```
EXECUTE msdb.dbo.rds_set_system_database_sync_objects @object_types = 'SQLAgentJob,TempDbFile';
```
Per ulteriori informazioni sulla replica `tempdb`, consulta [Configurazione di TempDB per le implementazioni Multi-AZ](SQLServer.TempDB.MAZ.md).
# Ruoli di SQL Server Agent
RDS per SQL Server supporta i seguenti ruoli di SQL Server Agent con diversi livelli di autorizzazioni per la gestione dei processi:
+ **SQLAgentUserRole**
Autorizzazioni
+ Creare e gestire i propri processi, programmi e operatori
+ Visualizzare le proprietà dei propri processi e programmi
+ Non è possibile visualizzare o gestire i processi creati da altri utenti
Questo ruolo è adatto agli utenti che devono creare e gestire i propri processi ma non richiedono l’accesso ai processi creati da altri utenti.
+ **SQLAgentReaderRole**
Autorizzazioni
+ Tutte le autorizzazioni di SQLAgentUserRole
+ Visualizzare un elenco di tutti i processi e programmi, inclusi quelli creati da altri
+ Visualizzare le proprietà di tutti i processi
+ Rivedere la cronologia dei processi
Questo ruolo è adatto agli utenti che devono monitorare lo stato di tutti i processi ma non devono gestirli.
+ **SQLAgentOperatorRole**
Autorizzazioni
+ Tutte le autorizzazioni di SQLAgentUserRole e SQLAgentReaderRole
+ Eseguire, arrestare o avviare i processi
+ Gestire la cronologia dei processi
+ Abilitare/disabilitare processi e programmi
+ Visualizzare operatori e proxy
Questo ruolo fornisce le autorizzazioni più estese ed è adatto agli utenti che devono avere il pieno controllo su tutti i processi.
Utilizza il comando seguente per assegnare i ruoli al tuo accesso SQL Server:
```
USE msdb;
EXEC sp_addrolemember 'SQLAgentOperatorRole', 'username';
```
## Gestione di SQLAgentOperatorRole in RDS per SQL Server
Per visualizzare i processi correnti, è necessario aggiungere SQLAgentOperatorRole all’accesso SQL Server e rimuoverlo prima di disconnettersi dal database.
Per visualizzare la struttura ad albero di SQL Server Agent in SQL Server Management Studio, segui queste istruzioni:
**Visualizzazione di SQL Server Agent in SQL Server Management Studio (SSMS)**
1. Utilizzando le credenziali di utente master RDS, accedi all’istanza RDS per SQL Server e concedi all’utente desiderato il ruolo SQLAgentUserRole.
```
USE msdb
GO
IF NOT EXISTS(SELECT name FROM sys.database_principals WHERE name = 'UserName')
BEGIN
CREATE USER UserName FROM LOGIN UserName
END
GO
ALTER ROLE SQLAgentUserRole ADD MEMBER UserName
GO
GRANT ALTER ON ROLE::[SQLAgentOperatorRole] to UserName
GO
```
Questi comandi creano l’utente nel database `msdb`, nel caso in cui non esista. Aggiungono inoltre l’utente in SQLAgentUserRole, in modo da rendere visibile la struttura ad albero di SQL Server Agent in SSMS. Infine, concedono all’utente le autorizzazioni di modifica sul ruolo SQLAgentOperatorRole. In questo modo, l’utente può aggiungere/rimuovere se stesso da tale ruolo.
1. Per aggiungerti a questo ruolo, connettiti all’istanza RDS per SQL Server come utente che deve visualizzare i processi ed esegui lo script seguente.
```
use msdb
go
ALTER ROLE SQLAgentOperatorRole ADD MEMBER UserName
GO
```
Quindi, fai clic con il pulsante destro del mouse sulla cartella **Processi** e scegli **Aggiorna**.
1. Quando esegui questa azione, nella scheda **Processi** viene visualizzato il pulsante **\$1** (più). Fai clic per espandere l’elenco dei processi di SQL Server Agent.
1.
**Importante**
Prima di disconnetterti dall’istanza RDS per SQL Server, devi rimuoverti da SQLAgentOperatorRole.
Per rimuovere il tuo accesso da SQLAgentOperatorRole, esegui la seguente query prima di disconnetterti o chiudere Management Studio:
```
USE msdb
GO
ALTER ROLE SQLAgentOperatorRole DROP MEMBER UserName
GO
```
Per ulteriori informazioni, consulta [Leveraging SQLAgentOperatorRole in RDS SQL Server](https://aws.amazon.com/blogs/database/leveraging-sqlagentoperatorrole-in-rds-sql-server/).
# Aggiunta di un utente al ruolo SQLagentUser
Per consentire un ulteriore accesso o utilizzo utente di SQL Server Agent, accedi come utente master ed esegui le operazioni seguenti.
1. Creazione di un altro login a livello di server con il comando `CREATE LOGIN`.
1. Creazione di un utente in `msdb` con il comando `CREATE USER` e collegamento di questo utente alle credenziali di accesso create nella fase precedente.
1. Aggiunta dell'utente al `SQLAgentUserRole` utilizzando la procedura memorizzata di sistema `sp_addrolemember`.
Supponi, ad esempio, che il tuo nome utente master sia **admin** e di voler concedere l'accesso a SQL Server Agent a un utente denominato **theirname** con una password **theirpassword**. In tal caso, puoi utilizzare la seguente procedura.
**Per aggiungere un utente al ruolo SQLAgentUser**
1. Accedi come utente master.
1. Esegui i comandi seguenti:
```
--Initially set context to master database
USE [master];
GO
--Create a server-level login named theirname with password theirpassword
CREATE LOGIN [theirname] WITH PASSWORD = 'theirpassword';
GO
--Set context to msdb database
USE [msdb];
GO
--Create a database user named theirname and link it to server-level login theirname
CREATE USER [theirname] FOR LOGIN [theirname];
GO
--Added database user theirname in msdb to SQLAgentUserRole in msdb
EXEC sp_addrolemember [SQLAgentUserRole], [theirname];
```
# Eliminazione di un processo SQL Server Agent
Puoi utilizzare la procedura archiviata `sp_delete_job` per eliminare i processi di SQL Server Agent su Amazon RDS for Microsoft SQL Server.
Non è possibile utilizzare SSMS per eliminare i processi di SQL Server Agent. Se provi a farlo, riceverai un messaggio di errore simile al seguente:
```
The EXECUTE permission was denied on the object 'xp_regread', database 'mssqlsystemresource', schema 'sys'.
```
Come servizio gestito, a RDS viene impedita l'esecuzione di procedure che accedono al registro di Windows. Quando si utilizza SSMS, tenta di eseguire un processo (`xp_regread`) per il quale RDS non è autorizzato.
**Nota**
In RDS per SQL Server, solo i membri del ruolo sysadmin possono aggiornare o eliminare i processi di proprietà di un account di accesso diverso. Per ulteriori informazioni, consulta [Leveraging SQLAgentOperatorRole in RDS SQL Server](https://aws.amazon.com/blogs/database/leveraging-sqlagentoperatorrole-in-rds-sql-server/).
**Per eliminare un processo di SQL Server Agent**
+ Eseguire la seguente istruzione T-SQL:
```
EXEC msdb..sp_delete_job @job_name = 'job_name';
```
# Utilizzo dei log di Amazon RDS per Microsoft SQL Server
Puoi utilizzare la console Amazon RDS per visualizzare, monitorare e scaricare i log di SQL Server Agent, Microsoft SQL Server e SQL Server Reporting Services (SSRS).
## Monitoraggio dei file di log
Se visualizzi un log nella console Amazon RDS, puoi visualizzarne i contenuti così come si presentano in quel momento. I log monitorati nella console vengono aperti in una modalità dinamica che ti consente di visualizzarne gli aggiornamenti in tempo quasi reale.
Solo l'ultimo log può essere monitorato. Supponiamo, ad esempio, che ti vengano mostrati i log seguenti:
![\[Un’immagine della sezione Log della console Amazon RDS con un log degli errore selezionato.\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/logs_sqlserver.png)
Solo il log/ERROR viene aggiornato attivamente, essendo il più recente. Puoi scegliere di monitorare altri log, ma questi sono statici e non si aggiornano.
## Archiviazione dei file di log
La console Amazon RDS mostra i log relativi all'ultima settimana fino alla giornata corrente. Puoi scaricare e archiviare i log per conservarli come riferimento dopo tale periodo. Uno dei modi per archiviare i log consiste nel caricarli in un bucket Amazon S3. Per istruzioni su come configurare un bucket Amazon S3 e caricare un file, consulta le [nozioni di base su Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/AmazonS3Basics.html) nella *Guida alle operazioni di base di Amazon Simple Storage Service* e fai clic su **Get Started (Inizia)**.
## Visualizzazione dei log dell'agente e degli errori
Per visualizzare i log dell'agente e degli errori di Microsoft SQL Server, usa la stored procedure `rds_read_error_log` in Amazon RDS con i parametri seguenti:
+ **`@index`** – Versione del log da recuperare. Il valore predefinito è 0 (recupero del log degli errori corrente). Specifica 1 per recuperare il log precedente, 2 per recuperare il log ancora precedente e così via.
+ **`@type`** – Tipo del log da recuperare. Specifica 1 per recuperare un log degli errori. Specifica 2 per recuperare un log degli agenti.
**Example**
Nell'esempio seguente viene richiesto il log degli errori corrente.
```
EXEC rdsadmin.dbo.rds_read_error_log @index = 0, @type = 1;
```
Per ulteriori informazioni sugli errori di SQL Server, consulta [Errori del motore di database](https://docs.microsoft.com/en-us/sql/relational-databases/errors-events/database-engine-events-and-errors) nella documentazione Microsoft.
# Utilizzo di file di traccia e file dump per Amazon RDS per SQL Server
In questa sezione viene descritto l'utilizzo dei file di traccia e dei file dump per le istanze database Amazon RDS che eseguono Microsoft SQL Server.
## Generazione di una query SQL di traccia
```
1. declare @rc int
2. declare @TraceID int
3. declare @maxfilesize bigint
4.
5. set @maxfilesize = 5
6.
7. exec @rc = sp_trace_create @TraceID output, 0, N'D:\rdsdbdata\log\rdstest', @maxfilesize, NULL
```
## Visualizzazione di una traccia aperta
```
1. select * from ::fn_trace_getinfo(default)
```
## Visualizzazione dei contenuti della traccia
```
1. select * from ::fn_trace_gettable('D:\rdsdbdata\log\rdstest.trc', default)
```
## Impostazione del periodo di retention dei file di traccia e dei file dump
I file di traccia e i file dump possono accumularsi e occupare spazio su disco. Per impostazione predefinita, Amazon RDS elimina i file di traccia e i file dump che risalgono a più di sette giorni prima.
Per visualizzare il periodo di retention corrente dei file di traccia e dei file dump, utilizza la procedura `rds_show_configuration`, come illustrato nell'esempio seguente.
```
1. exec rdsadmin..rds_show_configuration;
```
Per modificare il periodo di retention dei file di traccia, utilizza la procedura `rds_set_configuration` e imposta `tracefile retention` in minuti. L'esempio seguente imposta il periodo di retention dei file di traccia su 24 ore.
```
1. exec rdsadmin..rds_set_configuration 'tracefile retention', 1440;
```
Per modificare il periodo di retention dei file dump, utilizza la procedura `rds_set_configuration` e imposta `dumpfile retention` in minuti. L'esempio seguente imposta il periodo di retention del file dump su 3 giorni.
```
1. exec rdsadmin..rds_set_configuration 'dumpfile retention', 4320;
```
Per motivi di sicurezza, non puoi eliminare una traccia o un file dump specifici su un'istanza database SQL Server. Per modificare tutti i file di traccia o i file dump inutilizzati, imposta il periodo di retention dei file su 0.