Diese Seite wurde von der Cloud Translation API übersetzt.

Cloud SQL for SQL Server-Datenbank konfigurieren

In den folgenden Schritten wird beschrieben, wie Sie eine Cloud SQL for SQL Server-Datenbank für die Verwendung mit Datastream konfigurieren:

eine Verbindung zur Cloud SQL-Instanz herstellen Dazu können Sie den Befehl gcloud sql connect in der Cloud Shell-Eingabeaufforderung verwenden.
Aktivieren Sie CDC für die Datenbank mit dem folgenden Befehl:
```
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.
Starten Sie den SQL Server-Agent und stellen Sie sicher, dass er immer ausgeführt wird. Wenn der SQL Server-Agent über einen längeren Zeitraum nicht verfügbar ist, werden die Logs möglicherweise abgeschnitten. Dies führt zu einem dauerhaften Verlust der Änderungsdaten, die von Datastream nicht gelesen wurden.

Informationen zum Ausführen des SQL Server-Agents finden Sie unter Instanz des SQL Server-Agents starten, beenden oder neu starten.

Hinweis: Wir empfehlen, den automatischen Neustart für den SQL Server-Agent-Dienst zu aktivieren, um zu verhindern, dass der Agent über einen längeren Zeitraum nicht ausgeführt wird.
Snapshot-Isolation aktivieren.

Beim Backfill von Daten aus Ihrer SQL Server-Datenbank ist es wichtig, für konsistente Snapshots zu sorgen. Wenn Sie die in diesem Abschnitt beschriebenen Einstellungen nicht anwenden, können während des Backfill-Prozesses an der Datenbank vorgenommene Änderungen 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. Dadurch wird sichergestellt, dass die kopierten Daten einheitlich bleiben, auch wenn andere Nutzer gleichzeitig Änderungen an den Live-Tabellen vornehmen. Das Aktivieren 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 zu Ihrer 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.
Erstellen Sie einen Datastream-Nutzer:
1. Wechseln Sie in der Google Cloud Console zur Seite Cloud SQL-Instanzen.
  
  Cloud SQL-Instanzen aufrufen
2. Erstelle einen Log-in.
3. 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 erforderliche Schritte für die CDC-Methode der Transaktionslogs

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

Legen Sie die Aufbewahrungsdauer fest, für die 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 Änderungen 86.399 Sekunden (einen Tag) im Transaktionslog gespeichert werden. Mit der sp_cdc_start_job 'capture-Prozedur werden die Einstellungen initiiert.

Richten Sie einen Schutz vor abgeschnittenen Logs ein.

Damit der CDC-Leser genügend Zeit hat, die Logs zu lesen, und gleichzeitig das Abschneiden von Logs zulässt, um zu verhindern, dass der Speicherplatz belegt wird, können Sie einen Schutz vor abgeschnittenen 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 das 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, nach 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 speichern möchten. Beispiel:
- Der Wert von 60 legt die Aufbewahrungsdauer auf 1 Stunde fest
- Der Wert von 24 * 60 legt die Aufbewahrungsdauer auf 1 Tag fest.
- Der Wert von 3 * 24 * 60 legt die Aufbewahrungsdauer auf 3 Tage fest.