Diese Seite wurde von der Cloud Translation API übersetzt.

Selbstverwaltete SQL Server-Datenbank für CDC konfigurieren

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

Aktivieren Sie CDC für Ihre Quelldatenbank. Stellen Sie dazu eine Verbindung zur Datenbank her und führen Sie den folgenden Befehl an einer SQL-Eingabeaufforderung oder in einem Terminal aus:
```
USE [DATABASE_NAME]
GO
EXEC sys.sp_cdc_enable_db
GO
```
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.

Ersetzen Sie Folgendes:
- DATABASE_NAME: der Name Ihrer Quelldatenbank
- SCHEMA_NAME: Der Name des Schemas, zu dem die Tabellen gehören
- TABLE_NAME: der Name der Tabelle, für die Sie CDC aktivieren möchten
Starten Sie den SQL Server-Agent und sorgen Sie dafür, 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 gekürzt, was zu einem dauerhaften Verlust der Änderungsdaten führt, die nicht von Datastream gelesen wurden.

Informationen zum Ausführen des SQL Server-Agents finden Sie unter Starten, Beenden oder Neustarten einer Instanz des SQL Server-Agents.

Hinweis :Wir empfehlen, den automatischen Neustart für den SQL Server-Agent-Dienst zu aktivieren, um zu verhindern, dass der Agent längere Zeit nicht verfügbar ist.
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. Stellen Sie eine Verbindung zur Quelldatenbank her und geben Sie den folgenden Befehl ein:
```
USE DATABASE_NAME;
```
2. Erstellen Sie ein Log-in, das Sie beim Einrichten des Verbindungsprofils in Datastream verwenden können.
```
CREATE LOGIN YOUR_LOGIN WITH PASSWORD = 'PASSWORD';
```
3. Erstellen Sie einen Nutzer:
```
CREATE USER USER_NAME FOR LOGIN YOUR_LOGIN;
```
4. Weisen Sie ihnen die Rolle db_datareader zu:
```
EXEC sp_addrolemember 'db_datareader', 'USER_NAME';
```
5. Erteilen Sie ihnen die Berechtigung VIEW DATABASE STATE:
```
GRANT VIEW DATABASE STATE TO USER_NAME;
```
6. Fügen Sie diesen Nutzer der Datenbank master hinzu:
```
USE master;
CREATE USER USER_NAME FOR LOGIN YOUR_LOGIN;
```

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.

Stellen Sie eine Verbindung zur Quelldatenbank her und weisen Sie Ihrem Nutzer die Rollen db_owner und db_denydatawriter zu:

USE DATABASE_NAME;
EXEC sp_addrolemember 'db_owner', 'USER_NAME';
EXEC sp_addrolemember 'db_denydatawriter', 'USER_NAME';

Erteilen Sie die Berechtigungen SELECT für die Funktion sys.fn_dblog.
```
USE master;
GRANT SELECT ON sys.fn_dblog TO USER_NAME;
```

Fügen Sie Ihren Nutzer der msdb-Datenbank hinzu und weisen Sie ihm die folgenden Berechtigungen zu:

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

Weisen Sie Ihrem Nutzer in der Datenbank master die folgenden Berechtigungen zu:
```
  USE master;
  GRANT VIEW SERVER STATE TO YOUR_LOGIN;
```
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.
Wenn in Ihrer Datenbank Bereinigungs- oder Erfassungsjobs ausgeführt werden, beenden Sie sie. Weitere Informationen finden Sie unter Change Data Capture verwalten und überwachen.

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

DECLARE @transactionLog TABLE (beginLSN BINARY(10), endLSN BINARY(10))
INSERT @transactionLog EXEC sp_repltrans

DECLARE @currentDateTime DATETIME = GETDATE()
DECLARE @cutoffDateTime DATETIME = DATEADD(MINUTE, -@transaction_logs_retention_time, @currentDateTime)

DECLARE @firstValidLSN BINARY(10) = NULL
DECLARE @lastValidLSN BINARY(10) = NULL
DECLARE @firstTxnTime DATETIME = NULL
DECLARE @lastTxnTime DATETIME = NULL

SELECT TOP 1
    @lastTxnTime = t.logStartTime,
    @lastValidLSN = t.beginLSN
FROM (
  SELECT
    beginLSN AS beginLSN,
    (SELECT TOP 1 [begin time]
    FROM fn_dblog(stuff(stuff(CONVERT(CHAR(24), beginLSN, 1), 19, 0, ':'), 11, 0, ':'), DEFAULT)) AS logStartTime
  FROM @transactionLog
) t
ORDER BY t.beginLSN DESC

-- If all transactions are before cutoff, clear everything
IF (@lastTxnTime < @cutoffDateTime)
BEGIN
    EXEC sp_repldone NULL, NULL, 0, 0, 1
END
ELSE
BEGIN
    -- Find the earliest transaction
    SELECT TOP 1
      @firstTxnTime = t.logStartTime,
      @firstValidLSN = ISNULL(@firstValidLSN, t.beginLSN)
    FROM (
      SELECT
        beginLSN AS beginLSN,
        (SELECT TOP 1 [begin time]
        FROM fn_dblog(stuff(stuff(CONVERT(CHAR(24), beginLSN, 1), 19, 0, ':'), 11, 0, ':'), DEFAULT)) AS logStartTime
      FROM @transactionLog
    ) t
    ORDER BY t.beginLSN ASC

    IF (@firstTxnTime < @cutoffDateTime)
    BEGIN
        -- Identify the earliest and latest LSNs within VLogs before cutoff
        SELECT
          @firstValidLSN = SUBSTRING(MAX(t.lsnMarkers), 1, 10),
          @lastValidLSN = SUBSTRING(MAX(t.lsnMarkers), 11, 10)
        FROM (
          SELECT MIN(beginLSN + endLSN) AS lsnMarkers
          FROM @transactionLog
          GROUP BY SUBSTRING(beginLSN, 1, 4)
        ) t
        WHERE (
          SELECT TOP 1 [begin time]
          FROM fn_dblog(stuff(stuff(CONVERT(CHAR(24), t.lsnMarkers, 1), 19, 0, ':'), 11, 0, ':'), DEFAULT)
          WHERE Operation = 'LOP_BEGIN_XACT'
        ) < @cutoffDateTime

        EXEC sp_repldone @firstValidLSN, @lastValidLSN, 0, 0, 0
    END
  END
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')
    DECLARE @current_time INT
  = CAST(FORMAT(GETDATE(), 'HHmmss') AS INT);

  -- Schedule the procedure to run after every 5 minutes.
  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 every 5 minutes.' ;

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

      DECLARE @schedule_name_1 VARCHAR(MAX);
    SET @schedule_name_1 = CONCAT(@database_name, '_', 'DatastreamEveryFiveMinutesSchedule')

    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 = 5,
    @active_start_time = @current_time;

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

    -- 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 = @current_time;

    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.

Nächste Schritte

Weitere Informationen zur Funktionsweise von Datastream mit SQL Server-Quellen