Questa pagina è stata tradotta dall'API Cloud Translation.

Configura un database SQL Server Amazon RDS

I passaggi seguenti spiegano come configurare un database SQL Server Amazon RDS per l'utilizzo con Datastream:

Abilita la tecnologia Change Data Capture (CDC) per il database di origine. Per abilitare CDC per il database di origine, connettiti al database ed esegui questo comando tramite un prompt SQL, in un terminale o utilizzando la dashboard Amazon RDS:
```
EXEC msdb.dbo.rds_cdc_enable_db 'DATABASE_NAME'
```
Sostituisci DATABASE_NAME con il nome del database di origine.
Abilita la CDC in ogni tabella per la quale devi acquisire le modifiche:
```
USE [DATABASE_NAME]
EXEC sys.sp_cdc_enable_table
@source_schema = N'SCHEMA_NAME',
@source_name = N'TABLE_NAME',
@role_name = NULL
GO
```
Sostituisci quanto segue:
- DATABASE_NAME: il nome del database di origine
- SCHEMA_NAME: il nome dello schema a cui appartengono le tabelle
- TABLE_NAME: il nome della tabella per cui vuoi abilitare CDC
Avvia l'agente SQL Server e assicurati che sia sempre in esecuzione. Se L'agente SQL Server rimane inattivo per un periodo prolungato e i log potrebbero essere troncati, causando una perdita permanente dei dati delle modifiche non letti da Datastream.

Per informazioni sull'esecuzione dell'agente SQL Server, consulta Avvia, arresta o riavvia un'istanza dell'agente SQL Server.

Nota: consigliamo di attivare il riavvio automatico per il servizio dell'agente SQL Server per evitare che l'agente rimanga inattivo per un periodo di tempo più lungo.
Attiva l'isolamento degli snapshot.

Quando esegui il backfill dei dati dal database SQL Server, è importante verificare che di snapshot coerenti. Se non applichi le impostazioni descritte in questo le modifiche apportate al database durante il processo di backfill potrebbero comportare duplicati o risultati errati, in particolare per le tabelle senza chiavi primarie.

Se abiliti l'isolamento degli snapshot, all'inizio verrà creata una visualizzazione temporanea del database del processo di backfill. Ciò garantisce che i dati copiati rimangano coerenti, anche se altri utenti stanno apportando modifiche alle tabelle attive contemporaneamente. L'attivazione dell'isolamento degli snapshot potrebbe avere un leggero impatto sulle prestazioni, ma essenziale per un'estrazione affidabile dei dati.

Per abilitare l'isolamento degli snapshot:
1. Connettiti al tuo database utilizzando un client SQL Server.
2. Esegui questo comando:
```
ALTER DATABASE DATABASE_NAME SET ALLOW_SNAPSHOT_ISOLATION ON;
```
Sostituisci DATABASE_NAME con il nome del tuo database.
Crea un utente Datastream:
1. Connettiti al database di origine e inserisci il comando seguente:
```
USE DATABASE_NAME;
```
2. Crea un accesso da utilizzare durante la configurazione del profilo di connessione in Datastream.
```
CREATE LOGIN YOUR_LOGIN WITH PASSWORD = 'PASSWORD';
```
3. Crea un utente e assegnagli i ruoli db_owner e db_denydatawriter:
```
CREATE USER USER_NAME FOR LOGIN YOUR_LOGIN;
```
```
EXEC sp_addrolemember 'db_owner', 'USER_NAME';
EXEC sp_addrolemember 'db_denydatawriter', 'USER_NAME';
```
4. Aggiungi questo utente al database master:
```
USE master;
CREATE USER USER_NAME FOR LOGIN YOUR_LOGIN;
```

Passaggi aggiuntivi richiesti per il metodo CDC dei log delle transazioni

I passaggi descritti in questa sezione sono obbligatori solo quando configuri database SQL Server di origine da utilizzare con il metodo CDC dei log delle transazioni.

Concedi le autorizzazioni SELECT per la funzione sys.fn_dblog.
```
USE master;
GRANT SELECT ON sys.fn_dblog TO USER_NAME;
```

Aggiungi l'utente al database msdb e assegnagli le seguenti autorizzazioni:

USE msdb;
CREATE USER USER_NAME FOR LOGIN YOUR_LOGIN;
GRANT SELECT ON dbo.sysjobs TO USER_NAME;

Assegna le seguenti autorizzazioni all'utente nel database master:
```
  USE master;
  GRANT VIEW SERVER STATE TO YOUR_LOGIN;
```
Imposta il periodo di conservazione durante il quale vuoi che le modifiche siano disponibili nel tuo sorgente.
```
USE [DATABASE_NAME]
EXEC sys.sp_cdc_change_job @job_type = 'capture' , @pollinginterval = 86399
EXEC sp_cdc_stop_job 'capture'
EXEC sp_cdc_start_job 'capture'
```
Il parametro @pollinginterval viene misurato in secondi con un valore consigliato impostato su 86399. Ciò significa che il log delle transazioni conserva le modifiche per 86.399 secondi (un giorno). Avvio dell'esecuzione della procedura sp_cdc_start_job 'capture le impostazioni.

Configura una protezione da troncamento dei log.

Per assicurarti che il lettore CDC abbia tempo sufficiente per leggere i log, consentendo al contempo per evitare di consumare spazio di archiviazione, puoi configurare un troncamento dei log salvaguardia:

Connettiti al database utilizzando un client SQL Server.

Crea una tabella fittizia nel database:

USE [DATABASE_NAME];
CREATE TABLE dbo.gcp_datastream_truncation_safeguard (
  [id] INT IDENTITY(1,1) PRIMARY KEY,
  CreatedDate DATETIME DEFAULT GETDATE(),
  [char_column] CHAR(8)
  );

crea una stored procedure che esegue una transazione attiva per un periodo specificato per evitare il troncamento dei log:

CREATE PROCEDURE [dbo].[DatastreamLogTruncationSafeguard] @transaction_logs_retention_time INT
AS
BEGIN
  -- Start a new transaction
  BEGIN TRANSACTION;
  INSERT INTO dbo.gcp_datastream_truncation_safeguard (char_column) VALUES ('a')

DECLARE @formatted_time VARCHAR(5)
SET @formatted_time = CONVERT(VARCHAR(5), DATEADD(MINUTE, @transaction_logs_retention_time, 0), 108);
  -- Wait for X minutes before ending the transaction
  WAITFOR DELAY @formatted_time;
  -- Commit the transaction
  COMMIT TRANSACTION;
END;

Crea un'altra stored procedure. Questa volta devi creare un job che esegue stored procedure creata nel passaggio precedente in base a un cadenza:

CREATE PROCEDURE [dbo].[SetUpDatastreamJob] @transaction_logs_retention_time INT
AS
BEGIN
  DECLARE @database_name VARCHAR(MAX)
  SET @database_name =  (SELECT DB_NAME());;

  DECLARE @command_str VARCHAR(MAX);
  SET @command_str = CONCAT('Use ', @database_name,'; exec dbo.DatastreamLogTruncationSafeguard @transaction_logs_retention_time = ' + CAST(@transaction_logs_retention_time AS VARCHAR(10)));

  DECLARE @job_name VARCHAR(MAX);
SET @job_name =
  CONCAT(@database_name, '_', 'DatastreamLogTruncationSafeguardJob1')

    -- Add 3 schedules to the job to run again after specified time.
    IF
      NOT EXISTS(
        SELECT *
        FROM msdb.dbo.sysjobs
        WHERE name = @job_name
      )
        BEGIN
          EXEC
            msdb.dbo.sp_add_job
              @job_name
  = @job_name,
  @enabled = 1,
  @description = N'Execute the procedure to run an active transaction for x minutes.';

EXEC msdb.dbo.sp_add_jobstep @job_name = @job_name,
@step_name = N'Execute_DatastreamLogTruncationSafeguard',
@subsystem = N'TSQL',
@command = @command_str;

  -- Add a schedule that runs the stored procedure every given minutes starting now.
  DECLARE @schedule_name_1 VARCHAR(MAX);
  SET @schedule_name_1 = CONCAT(@database_name, '_', 'DatastreamEveryGivenMinutesFromNow')

  DECLARE @start_time_1 time;
  SET @start_time_1 = DATEADD(SECOND, 1, GETDATE());
  DECLARE @formatted_start_time_1 INT;
  SET @formatted_start_time_1 = CONVERT(INT, REPLACE(CONVERT(VARCHAR(8), @start_time_1, 114), ':' ,''));

  EXEC msdb.dbo.sp_add_schedule
  @schedule_name = @schedule_name_1,
  @freq_type = 4,  -- daily start
  @freq_subday_type = 4,  -- every X minutes daily
  @freq_interval = 1,
  @freq_subday_interval = @transaction_logs_retention_time,
  @active_start_time = @formatted_start_time_1;

  EXEC msdb.dbo.sp_attach_schedule
  @job_name = @job_name,
  @schedule_name = @schedule_name_1 ;

  -- Add a schedule that runs the stored procedure after every given minutes starting after some delay.
  DECLARE @schedule_name_2 VARCHAR(MAX);
  Set @schedule_name_2 = CONCAT(@database_name, '_', 'DatastreamEveryGivenMinutesAfterDelay');

  DECLARE @start_time_2 time;
  SET @start_time_2 = DATEADD(MINUTE, @transaction_logs_retention_time / 2, GETDATE());

  DECLARE @formatted_start_time_2 INT;
  SET @formatted_start_time_2 = CONVERT(INT, REPLACE(CONVERT(VARCHAR(8), @start_time_2, 114), ':' ,''));

  EXEC msdb.dbo.sp_add_schedule
  @schedule_name = @schedule_name_2,
  @freq_type = 4,  -- daily start
  @freq_subday_type = 4,  -- every x minutes daily
  @freq_interval = 1,
  @freq_subday_interval = @transaction_logs_retention_time,
  @active_start_time = @formatted_start_time_2;

  EXEC msdb.dbo.sp_attach_schedule
  @job_name = @job_name,
  @schedule_name = @schedule_name_2 ;

  -- Add a schedule that runs the stored procedure on the SQL Server Agent startup.
  DECLARE @schedule_name_agent_startup VARCHAR(MAX);
  Set @schedule_name_agent_startup = CONCAT(@database_name, '_', 'DatastreamSqlServerAgentStartupSchedule')

  EXEC msdb.dbo.sp_add_schedule
  @schedule_name = @schedule_name_agent_startup,
  @freq_type = 64,  -- start on SQL Server Agent startup
  @active_start_time = @formatted_start_time_1;

  EXEC msdb.dbo.sp_attach_schedule
  @job_name = @job_name,
  @schedule_name = @schedule_name_agent_startup ;

  EXEC msdb.dbo.sp_add_jobserver
  @job_name = @job_name,
  @server_name = @@servername ;
  END
END;

Eseguire la stored procedure che crea il job di Datastream.
```
DECLARE @transaction_logs_retention_time INT = (INT)
EXEC [dbo].[SetUpDatastreamJob] @transaction_logs_retention_time
```
Sostituisci INT con il numero di minuti che vuoi i log. Ad esempio:
- Il valore di 60 imposta il tempo di conservazione su 1 ora
- Il valore di 24 * 60 imposta il tempo di conservazione su 1 giorno
- Il valore di 3 * 24 * 60 imposta il tempo di conservazione su 3 giorni