Diese Seite wurde von der Cloud Translation API übersetzt.

Amazon RDS SQL Server-Datenbank konfigurieren

In den folgenden Schritten wird beschrieben, wie eine Amazon RDS-SQL Server-Datenbank konfiguriert wird zur Verwendung mit Datastream:

Aktivieren Sie Change Data Capture (CDC) für Ihre Quelldatenbank. Wenn Sie CDC für Ihre Quelldatenbank aktivieren möchten, stellen Sie eine Verbindung zur Datenbank her und führen Sie den folgenden Befehl in einer SQL-Aufforderung, in einem Terminal oder über das Amazon RDS-Dashboard aus:
```
EXEC msdb.dbo.rds_cdc_enable_db 'DATABASE_NAME'
```
Ersetzen Sie DATABASE_NAME durch den Namen Ihrer Quelldatenbank.
Aktivieren Sie CDC für jede Tabelle, für die Änderungen erfasst werden 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
```
Ersetzen Sie Folgendes:
- DATABASE_NAME: der Name der 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 ausfällt, werden die Protokolle möglicherweise abgeschnitten, 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 Eine Instanz des SQL Server-Agents starten, stoppen 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.

Wenn Sie Daten aus Ihrer SQL Server-Datenbank nachfüllen, ist es wichtig, für konsistente Snapshots zu sorgen. Wenn Sie die in diesem Abschnitt beschriebenen Einstellungen nicht anwenden, können Änderungen an der Datenbank während des Backfill-Prozesses zu Duplikaten oder falschen Ergebnissen führen, insbesondere bei Tabellen ohne Primärschlüssel.

Wenn Sie die Snapshot-Isolation aktivieren, wird zu Beginn eine temporäre Ansicht der Datenbank erstellt des Backfill-Prozesses. So bleiben die kopierten Daten konsistent, auch wenn andere Nutzer gleichzeitig Änderungen an den Livetabellen vornehmen. Das Aktivieren der Snapshot-Isolierung kann sich für eine zuverlässige Datenextraktion.

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.
Erstellen Sie einen Datastream-Nutzer:
1. Stellen Sie eine Verbindung zur Quelldatenbank her und geben Sie den folgenden Befehl ein:
```
USE DATABASE_NAME;
```
2. Erstellen Sie ein Log-in für die Einrichtung des Verbindungsprofils in Datastream.
```
CREATE LOGIN YOUR_LOGIN WITH PASSWORD = 'PASSWORD';
```
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';
```
4. 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 Ihr SQL Server-Quelldatenbank zur Verwendung mit der CDC-Methode für Transaktionslogs.

Gewähren Sie SELECT-Berechtigungen für die Funktion sys.fn_dblog.
```
USE master;
GRANT SELECT ON sys.fn_dblog TO USER_NAME;
```

Fügen Sie den Nutzer zur Datenbank „msdb“ 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 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 mit einem empfohlenen Wert gemessen auf 86399 festgelegt. Das bedeutet,dass Änderungen im Transaktionslog für 86.399 Sekunden (ein Tag). Durch Ausführen des sp_cdc_start_job 'capture-Verfahrens werden die Einstellungen gestartet.

Richten Sie eine Absicherung für das Kürzen von Protokollen ein.

Um sicherzustellen, dass der CDC-Leser genügend Zeit hat, um die Protokolle zu lesen, während Kürzung von Protokollen, um zu verhindern, dass Speicherplatz belegt wird, können Sie diese Kürzung einrichten. Absicherung:

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 im vorherigen Schritt erstellte gespeicherte Prozedur gemäß einer bestimmten Taktung 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 die Protokolle aufbewahrt werden sollen. Beispiel:
- Der Wert von 60 legt die Aufbewahrungsdauer auf 1 Stunde fest
- Der Wert von 24 * 60 legt die Aufbewahrungsdauer auf 1 Tag fest.
- Mit dem Wert 3 * 24 * 60 wird die Aufbewahrungsdauer auf 3 Tage festgelegt.

Nächste Schritte

Weitere Informationen zur Funktionsweise von Datastream mit SQL Server-Quellen