Questa pagina è stata tradotta dall'API Cloud Translation.

Configura un database Cloud SQL per SQL Server per CDC

Questa pagina descrive come configurare Change Data Capture (CDC) per trasmettere in streaming i dati da un database Cloud SQL per SQL Server a una destinazione supportata, come BigQuery o Cloud Storage.

Connettersi all'istanza Cloud SQL. Puoi farlo utilizzando il comando gcloud sql connect nel prompt di Cloud Shell.
Abilita CDC nel database eseguendo questo comando:
```
EXEC msdb.dbo.gcloudsql_cdc_enable_db 'DATABASE_NAME'
```
Sostituisci DATABASE_NAME con il nome del database di origine.

Abilita CDC nelle tabelle per le quali 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

Abilita l'isolamento degli snapshot.

Quando esegui il backfill dei dati dal database SQL Server, è importante assicurarsi che gli snapshot siano coerenti. Se non applichi le impostazioni descritte in questa sezione, le modifiche apportate al database durante il processo di backfill potrebbero generare duplicati o risultati errati, soprattutto per le tabelle senza chiavi primarie.

L'abilitazione dell'isolamento dello snapshot crea una visualizzazione temporanea del database all'inizio del processo di backfill. Ciò garantisce che i dati copiati rimangano coerenti, anche se altri utenti apportano modifiche alle tabelle live contemporaneamente. L'attivazione dell'isolamento degli snapshot potrebbe influire leggermente sulle prestazioni, ma è essenziale per un'estrazione affidabile dei dati.

Per abilitare l'isolamento degli snapshot:
1. Connettiti al 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 database.
Crea un utente Datastream:
1. Nella console Google Cloud , vai alla pagina Istanze Cloud SQL.
  
  Vai a Istanze Cloud SQL
2. 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';
```

Passaggi aggiuntivi richiesti per il metodo CDC dei log delle transazioni

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

Imposta l'intervallo di polling per il quale vuoi che le modifiche siano disponibili nell'origine.
```
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 è 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). L'esecuzione della procedura sp_cdc_start_job 'capture avvia le impostazioni.

Configura una protezione per il troncamento dei log.

Per assicurarti che il lettore CDC abbia tempo sufficiente per leggere i log, consentendo al contempo il troncamento dei log per evitare di esaurire lo spazio di archiviazione, puoi configurare una protezione per il troncamento dei log:

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 che specifichi per evitare il troncamento del 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, crea un job che esegue la stored procedure creata nel passaggio precedente in base a una cadenza specifica:

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;

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

Abilita il recupero point-in-time (PITR).

Passaggi successivi

Scopri di più su come Datastream funziona con le origini SQL Server.