Esta página se ha traducido con Cloud Translation API.

Configurar una base de datos de Amazon RDS SQL Server para CDC

En esta página se describe cómo configurar la captura de datos de cambios (CDC) para transmitir datos desde una base de datos de Amazon RDS SQL Server a un destino admitido, como BigQuery o Cloud Storage.

Habilita la captura de datos de cambios (CDC) en tu base de datos de origen. Para habilitar CDC en tu base de datos de origen, conéctate a la base de datos y ejecuta el siguiente comando en un mensaje de SQL, en un terminal o mediante el panel de control de Amazon RDS:
```
EXEC msdb.dbo.rds_cdc_enable_db 'DATABASE_NAME'
```
Sustituye DATABASE_NAME por el nombre de tu base de datos de origen.
Habilita CDC en cada tabla de 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
```
Haz los cambios siguientes:
- DATABASE_NAME: el nombre de la base de datos de origen
- SCHEMA_NAME: el nombre del esquema al que pertenecen las tablas.
- TABLE_NAME: el nombre de la tabla en la que quieres habilitar CDC
Inicia el agente de SQL Server y asegúrate de que se esté ejecutando en todo momento. Si el agente de SQL Server permanece inactivo durante un periodo prolongado, es posible que los registros se trunquen, lo que provocaría la pérdida permanente de los datos de cambios que Datastream no haya leído.

Para obtener información sobre cómo ejecutar el Agente SQL Server, consulta Iniciar, detener o reiniciar una instancia del Agente SQL Server.

Nota: Te recomendamos que actives el reinicio automático del servicio Agente de SQL Server para evitar que el agente esté inactivo durante más tiempo.
Habilita el aislamiento de instantáneas.

Cuando rellenas datos de tu base de datos de SQL Server, es importante que las copias de seguridad sean coherentes. Si no aplica los ajustes descritos en esta sección, los cambios realizados en la base de datos durante el proceso de relleno pueden provocar duplicados o resultados incorrectos, sobre todo en las tablas sin claves principales.

Si habilita el aislamiento de la captura, se creará una vista temporal de su base de datos al inicio del proceso de relleno. De esta forma, los datos que se copian siguen siendo coherentes, aunque otros usuarios hagan cambios en las tablas activas al mismo tiempo. Habilitar el aislamiento de instantáneas puede afectar ligeramente al rendimiento, pero es esencial para extraer datos de forma fiable.

Para habilitar el aislamiento de la captura, sigue estos pasos:
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;
```
Sustituye DATABASE_NAME por el nombre de tu base de datos.

Crea un usuario de Datastream:

Conéctate a la base de datos de origen e introduce el siguiente comando:
```
USE DATABASE_NAME;
```
Crea un inicio de sesión para usarlo al configurar 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';

Añade 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 de CDC de los registros de transacciones

Los pasos descritos en esta sección solo son necesarios cuando se configura la base de datos de origen de SQL Server para usarla con el método de CDC de los registros de transacciones.

Concede permisos a SELECT para la función sys.fn_dblog.

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

Añade tu 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;
```
Define el periodo de conservación durante el que quieres 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 y tiene un valor recomendado de 86399. Esto significa que el registro de transacciones conserva los cambios durante 86.399 segundos (un día). Al ejecutar el procedimiento sp_cdc_start_job 'capture, se inician los ajustes.

Configura una protección para evitar que se trunquen los registros.

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

Conéctate a la base de datos mediante 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 periodo que especifiques para evitar que se trunque el registro:

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 el procedimiento almacenado que creaste en el paso anterior según una cadencia especificada:

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
```
Sustituye INT por el número de minutos durante los que quieras conservar los registros. Por ejemplo:
- El valor de 60 define el tiempo de conservación en 1 hora.
- El valor de 24 * 60 define el tiempo de conservación en 1 día
- El valor de 3 * 24 * 60 establece el tiempo de conservación en 3 días.

Siguientes pasos

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

Configurar una base de datos de Amazon RDS SQL Server para CDC Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Pasos adicionales necesarios para el método de CDC de los registros de transacciones

Siguientes pasos

Configurar una base de datos de Amazon RDS SQL Server para CDC