Se usó la API de Cloud Translation para traducir esta página.

Configura una base de datos de SQL Server de Amazon RDS

En los siguientes pasos, se explica cómo configurar una base de datos de SQL Server en Amazon RDS para usar con Datastream:

Habilitar la captura de datos modificados (CDC) para la base de datos de origen Para habilitar la CDC para tu base de datos de origen, conéctate a la base de datos y ejecuta el siguiente comando en un mensaje de SQL, en una terminal o con el panel de Amazon RDS:
```
EXEC msdb.dbo.rds_cdc_enable_db 'DATABASE_NAME'
```
Reemplaza DATABASE_NAME por el nombre de tu base de datos de origen.
Habilita la CDC en cada tabla en la que necesites capturar cambios:
```
USE [DATABASE_NAME]
EXEC sys.sp_cdc_enable_table
@source_schema = N'SCHEMA_NAME',
@source_name = N'TABLE_NAME',
@role_name = NULL
GO
```
Reemplaza lo siguiente:
- DATABASE_NAME: Es el nombre de la base de datos de origen.
- SCHEMA_NAME: Es el nombre del esquema al que pertenecen las tablas.
- TABLE_NAME: Es el nombre de la tabla para la que deseas habilitar las CDC
Inicia el agente de SQL Server y asegúrate de que se esté ejecutando en todo momento. Si el botón El Agente de SQL Server permanece inactivo durante un período prolongado. Es posible que los registros se trunquen. lo que provocaba una pérdida permanente de los datos de cambio que Datastream no leyó.

Para obtener información sobre cómo ejecutar el agente de SQL Server, consulta Inicia, detén o reinicia una instancia del agente de SQL Server.

Nota: Recomendamos que configures el reinicio automático para el servicio del agente de SQL Server a fin de evitar que el agente quede inactivo durante más tiempo.
Habilitar el aislamiento de instantánea

Cuando reabasteces datos de tu base de datos de SQL Server, es importante garantizar que los instantáneas sean coherentes. Si no aplicas la configuración que se describe en esta los cambios realizados en la base de datos durante el proceso de reabastecimiento duplicados o resultados incorrectos, especialmente para tablas sin claves primarias.

Si habilitas el aislamiento de instantáneas, se crea una vista temporal de tu base de datos al comienzo del proceso de reabastecimiento. Esto garantiza que los datos que se copian sigan siendo coherentes, incluso si otros usuarios hacen cambios en las tablas dinámicas al mismo tiempo. Habilitar el aislamiento de instantáneas puede tener un ligero impacto en el rendimiento, pero que son esenciales para la extracción de datos confiable.

Para habilitar el aislamiento de instantánea, haz lo siguiente:
1. Conéctate a tu base de datos con un cliente de SQL Server.
2. Ejecuta el siguiente comando:
```
ALTER DATABASE DATABASE_NAME SET ALLOW_SNAPSHOT_ISOLATION ON;
```
Reemplaza DATABASE_NAME por el nombre de tu base de datos.

Crea un usuario de Datastream:

Conéctate a la base de datos de origen y, luego, ingresa el siguiente comando:
```
USE DATABASE_NAME;
```
Crea un acceso para usarlo mientras configuras el perfil de conexión en Datastream.
```
CREATE LOGIN YOUR_LOGIN WITH PASSWORD = 'PASSWORD';
```

Crea un usuario y asígnale los roles db_owner y db_denydatawriter:

CREATE USER USER_NAME FOR LOGIN YOUR_LOGIN;

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

Agrega este usuario a la base de datos master:

USE master;
CREATE USER USER_NAME FOR LOGIN YOUR_LOGIN;

Pasos adicionales necesarios para el método CDC de registros de transacción

Los pasos descritos en esta sección solo son necesarios cuando configuras tu base de datos de origen de SQL Server para usar con el método de CDC de registros de transacción.

Otorga permisos SELECT a la función sys.fn_dblog.

USE master;
GRANT SELECT ON sys.fn_dblog TO USER_NAME;

Agrega el usuario a la base de datos msdb y asígnale los siguientes permisos:

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

Asigna los siguientes permisos a tu usuario en la base de datos master:
```
  USE master;
  GRANT VIEW SERVER STATE TO YOUR_LOGIN;
```
Establece el período de retención para el que deseas que los cambios estén disponibles en tu fuente.
```
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'
```
El parámetro @pollinginterval se mide en segundos con un valor recomendado establecido en 86399. Esto significa que el registro de transacciones retiene los cambios de 86,399 segundos (un día). Ejecutar el procedimiento sp_cdc_start_job 'capture inicia la configuración.

Configura una protección de truncamiento de registros.

Para asegurarte de que el lector de CDC tenga tiempo suficiente para leer los registros y, al mismo tiempo, permitir que el truncamiento de registros evite que se agote el espacio de almacenamiento, puedes configurar una protección de truncamiento de registros:

Conéctate a la base de datos con un cliente de SQL Server.

Crea una tabla ficticia en la base de datos:

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

Crea un procedimiento almacenado que ejecute una transacción activa durante un período que especifiques para evitar el truncamiento de registros:

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;

Crea otro procedimiento almacenado. Esta vez, crearás un trabajo que ejecute procedimiento almacenado que creaste en el paso anterior según un procedimiento Cadencia:

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;

Ejecuta el procedimiento almacenado que crea el trabajo de Datastream.
```
DECLARE @transaction_logs_retention_time INT = (INT)
EXEC [dbo].[SetUpDatastreamJob] @transaction_logs_retention_time
```
Reemplaza INT por la cantidad de minutos de duración que deseas. para retener los registros. Por ejemplo:
- El valor de 60 establece el tiempo de retención en 1 hora.
- El valor de 24 * 60 establece el tiempo de retención en 1 día.
- El valor de 3 * 24 * 60 establece el tiempo de retención en 3 días.

¿Qué sigue?

Obtén más información sobre cómo funciona Datastream con las fuentes de SQL Server.