Diese Seite wurde von der Cloud Translation API übersetzt.

Cloud SQL for SQL Server-Datenbank für CDC konfigurieren

Auf dieser Seite wird beschrieben, wie Sie Change Data Capture (CDC) konfigurieren, um Daten aus einer Cloud SQL for SQL Server-Datenbank in ein unterstütztes Ziel wie BigQuery oder Cloud Storage zu streamen.

eine Verbindung zur Cloud SQL-Instanz herstellen Sie können dazu den Befehl gcloud sql connect in der Cloud Shell-Eingabeaufforderung verwenden.
Aktivieren Sie CDC für die Datenbank, indem Sie den folgenden Befehl ausführen:
```
EXEC msdb.dbo.gcloudsql_cdc_enable_db 'DATABASE_NAME'
```
Ersetzen Sie DATABASE_NAME durch den Namen Ihrer Quelldatenbank.
Aktivieren Sie CDC für die Tabellen, für die Sie Änderungen erfassen müssen:
```
USE [DATABASE_NAME]
EXEC sys.sp_cdc_enable_table
@source_schema = N'SCHEMA_NAME',
@source_name = N'TABLE_NAME',
@role_name = NULL
GO
```
Hinweis :Sie müssen den Befehl für jede Tabelle ausführen, für die Sie CDC aktivieren möchten.
Snapshot-Isolation aktivieren.

Wenn Sie Daten aus Ihrer SQL Server-Datenbank nachziehen, ist es wichtig, dass die Snapshots konsistent sind. Wenn Sie die in diesem Abschnitt beschriebenen Einstellungen nicht anwenden, können Änderungen, die während des Backfill-Vorgangs an der Datenbank vorgenommen werden, zu Duplikaten oder falschen Ergebnissen führen, insbesondere bei Tabellen ohne Primärschlüssel.

Wenn Sie die Snapshot-Isolation aktivieren, wird zu Beginn des Backfill-Prozesses eine temporäre Ansicht Ihrer Datenbank erstellt. So bleiben die kopierten Daten konsistent, auch wenn andere Nutzer gleichzeitig Änderungen an den Live-Tabellen vornehmen. Die Aktivierung der Snapshot-Isolation kann sich geringfügig auf die Leistung auswirken, ist aber für eine zuverlässige Datenextraktion unerlässlich.

So aktivieren Sie die Snapshot-Isolation:
1. Stellen Sie eine Verbindung zur Datenbank über einen SQL Server-Client her.
2. Führen Sie dazu diesen Befehl aus:
```
ALTER DATABASE DATABASE_NAME SET ALLOW_SNAPSHOT_ISOLATION ON;
```
Ersetzen Sie DATABASE_NAME durch den Namen Ihrer Datenbank.
Datastream-Nutzer erstellen:
1. Wechseln Sie in der Google Cloud Console zur Seite Cloud SQL-Instanzen.
  
  Cloud SQL-Instanzen aufrufen
2. Erstellen Sie einen Nutzer und weisen Sie ihm die Rollen db_owner und db_denydatawriter zu:
```
CREATE USER USER_NAME FOR LOGIN YOUR_LOGIN;
```
```
EXEC sp_addrolemember 'db_owner', 'USER_NAME';
EXEC sp_addrolemember 'db_denydatawriter', 'USER_NAME';
```

Zusätzliche Schritte für die CDC-Methode für Transaktionslogs

Die in diesem Abschnitt beschriebenen Schritte sind nur erforderlich, wenn Sie Ihre SQL Server-Quelldatenbank zur Verwendung mit der CDC-Methode für Transaktionslogs konfigurieren.

Legen Sie das Abfrageintervall fest, für das die Änderungen in Ihrer Quelle verfügbar sein sollen.
```
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'
```
Der Parameter @pollinginterval wird in Sekunden gemessen. Der empfohlene Wert ist 86399. Das bedeutet,dass das Transaktionslog Änderungen für 86.399 Sekunden (einen Tag) beibehält. Durch Ausführen der sp_cdc_start_job 'capture-Prozedur werden die Einstellungen initiiert.

Richten Sie eine Absicherung zum Verhindern von abgeschnittenen Protokollen ein.

Damit der CDC-Reader genügend Zeit hat, die Logs zu lesen, und gleichzeitig das Abschneiden von Logs möglich ist, um Speicherplatz zu sparen, können Sie eine Absicherung für das Abschneiden von Logs einrichten:

Stellen Sie eine Verbindung zur Datenbank über einen SQL Server-Client her.

Erstellen Sie eine Dummy-Tabelle in der Datenbank:

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)
  );

Erstellen Sie eine gespeicherte Prozedur, die eine aktive Transaktion für einen von Ihnen angegebenen Zeitraum ausführt, um ein Abschneiden des Logs zu verhindern:

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;

Erstellen Sie eine weitere gespeicherte Prozedur. Dieses Mal erstellen Sie einen Job, der die gespeicherte Prozedur, die Sie im vorherigen Schritt erstellt haben, in einem bestimmten Rhythmus ausführt:

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;

Führen Sie die gespeicherte Prozedur aus, die den Datastream-Job erstellt.
```
DECLARE @transaction_logs_retention_time INT = (INT)
EXEC [dbo].[SetUpDatastreamJob] @transaction_logs_retention_time
```
Ersetzen Sie INT durch die Anzahl der Minuten, für die Sie die Logs beibehalten möchten. Beispiel:
- Der Wert von 60 legt die Aufbewahrungsdauer auf 1 Stunde fest.
- Mit dem Wert 24 * 60 wird die Aufbewahrungsdauer auf 1 Tag festgelegt.
- Der Wert von 3 * 24 * 60 legt die Aufbewahrungsdauer auf 3 Tage fest.

Aktivieren Sie die Wiederherstellung zu einem bestimmten Zeitpunkt (PITR).

Nächste Schritte

Weitere Informationen zur Funktionsweise von Datastream mit SQL Server-Quellen