Cette page a été traduite par l'API Cloud Translation.

Configurer une base de données Amazon RDS SQL Server

Les étapes suivantes expliquent comment configurer une base de données Amazon RDS SQL Server à utiliser avec Datastream:

Activez la capture des données modifiées (CDC, Change Data Capture) pour votre base de données source. Pour activer la CDC pour votre base de données source, connectez-vous à celle-ci et exécutez la commande suivante : une invite SQL, dans un terminal ou à l'aide du tableau de bord Amazon RDS:
```
EXEC msdb.dbo.rds_cdc_enable_db 'DATABASE_NAME'
```
Remplacez DATABASE_NAME par le nom de votre base de données source.
Activez la CDC sur chaque table pour laquelle vous devez capturer les modifications:
```
USE [DATABASE_NAME]
EXEC sys.sp_cdc_enable_table
@source_schema = N'SCHEMA_NAME',
@source_name = N'TABLE_NAME',
@role_name = NULL
GO
```
Remplacez les éléments suivants :
- DATABASE_NAME: nom de votre base de données source
- SCHEMA_NAME: nom du schéma auquel appartiennent les tables
- TABLE_NAME: nom de la table pour laquelle vous souhaitez activer la CDC
Démarrez l'agent SQL Server et assurez-vous qu'il s'exécute en permanence. Si le L'agent SQL Server reste indisponible pendant une période prolongée, les journaux peuvent donc être tronqués. ce qui a entraîné une perte définitive des données de modification non lues par Datastream.

Pour en savoir plus sur l'exécution de l'agent SQL Server, consultez Démarrez, arrêtez ou redémarrez une instance de l'agent SQL Server.

Remarque :Nous vous recommandons d'activer le redémarrage automatique pour le service de l'agent SQL Server afin d'éviter que celui-ci soit arrêté pendant plus longtemps.
Activer l'isolation d'instantané.

Lorsque vous remplissez des données à partir de votre base de données SQL Server, il est important de vous assurer des instantanés cohérents. Si vous n'appliquez pas les paramètres décrits dans ce les modifications apportées à la base de données pendant le processus de remplissage peuvent entraîner des doublons ou des résultats incorrects, en particulier pour les tables sans clé primaire.

L'activation de l'isolation d'instantané crée une vue temporaire de votre base de données au démarrage du processus de remplissage. Cela garantit que les données en cours de copie restent cohérentes, même si d'autres utilisateurs apportent des modifications aux tables actives en même temps. L'activation de l'isolation d'instantané peut avoir un léger impact sur les performances, essentielles pour une extraction fiable des données.

Pour activer l'isolation d'instantané:
1. Connectez-vous à votre base de données à l'aide d'un client SQL Server.
2. Exécutez la commande suivante :
```
ALTER DATABASE DATABASE_NAME SET ALLOW_SNAPSHOT_ISOLATION ON;
```
Remplacez DATABASE_NAME par le nom de votre base de données.
Créez un utilisateur Datastream:
1. Connectez-vous à la base de données source et saisissez la commande suivante:
```
USE DATABASE_NAME;
```
2. Créez un identifiant à utiliser lors de la configuration du profil de connexion dans Datastream.
```
CREATE LOGIN YOUR_LOGIN WITH PASSWORD = 'PASSWORD';
```
3. Créez un utilisateur et attribuez-lui les rôles db_owner et db_denydatawriter:
```
CREATE USER USER_NAME FOR LOGIN YOUR_LOGIN;
```
```
EXEC sp_addrolemember 'db_owner', 'USER_NAME';
EXEC sp_addrolemember 'db_denydatawriter', 'USER_NAME';
```
4. Ajoutez cet utilisateur à la base de données master:
```
USE master;
CREATE USER USER_NAME FOR LOGIN YOUR_LOGIN;
```

Étapes supplémentaires requises pour la méthode CDC pour les journaux de transactions

Les étapes décrites dans cette section ne sont requises que lorsque vous configurez votre base de données SQL Server source à utiliser avec la méthode CDC des journaux de transactions.

Accordez les autorisations SELECT pour la fonction sys.fn_dblog.
```
USE master;
GRANT SELECT ON sys.fn_dblog TO USER_NAME;
```

Ajoutez votre utilisateur à la base de données msdb et attribuez-lui les autorisations suivantes:

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

Attribuez les autorisations suivantes à votre utilisateur dans la base de données master:
```
  USE master;
  GRANT VIEW SERVER STATE TO YOUR_LOGIN;
```
Définissez la durée de conservation pendant laquelle vous souhaitez que les modifications soient disponibles sur votre source.
```
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'
```
Le paramètre @pollinginterval est mesuré en secondes avec la valeur recommandée définie sur 86399. Cela signifie que le journal des transactions conserve les modifications secondes (un jour). L'exécution de la procédure sp_cdc_start_job 'capture démarre les paramètres.

Configurez une protection contre la troncation des journaux.

Pour s'assurer que le lecteur CDC dispose de suffisamment de temps pour lire les journaux tout en autorisant pour éviter d'utiliser trop d'espace de stockage, vous pouvez configurer la troncation des journaux sauvegarde:

Connectez-vous à la base de données à l'aide d'un client SQL Server.

Créez une table factice dans la base de données :

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

Créez une procédure stockée qui exécute une transaction active pendant une période que vous spécifiez pour empêcher la troncation des journaux:

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;

Créez une autre procédure stockée. Cette fois, vous créez un job qui exécute procédure stockée que vous avez créée à l'étape précédente en fonction d'une :

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;

Exécutez la procédure stockée qui crée le job Datastream.
```
DECLARE @transaction_logs_retention_time INT = (INT)
EXEC [dbo].[SetUpDatastreamJob] @transaction_logs_retention_time
```
Remplacez INT par le nombre de minutes souhaité et conserver les journaux. Exemple :
- La valeur 60 définit la durée de conservation sur 1 heure
- La valeur 24 * 60 définit la durée de conservation sur 1 jour
- La valeur 3 * 24 * 60 définit la durée de conservation sur trois jours