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

Configura una base de datos autoadministrada de SQL Server

En los siguientes pasos, se explica cómo configurar una base de datos de SQL Server autoadministrada para usarla con Datastream:

Habilita la CDC para tu base de datos de origen. Para ello, conéctate a la base de datos y ejecuta el siguiente comando en un mensaje de SQL o en una terminal:
```
USE [DATABASE_NAME]
GO
EXEC sys.sp_cdc_enable_db
GO
```
Reemplaza DATABASE_NAME por el nombre de la base de datos de origen.
Habilita la CDC en las tablas para las que necesitas 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
```
Nota: Debes ejecutar el comando para cada tabla en la que desees habilitar las CDC.

Reemplaza lo siguiente:
- DATABASE_NAME: Es el nombre de tu 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.
Crea un usuario de Datastream:
1. Conéctate a la base de datos de origen y, luego, ingresa el siguiente comando:
```
USE DATABASE_NAME;
```
2. Crea un acceso para usarlo mientras configuras el perfil de conexión en Datastream.
```
CREATE LOGIN YOUR_LOGIN WITH PASSWORD = 'PASSWORD';
```
3. Crea un usuario:
```
CREATE USER USER_NAME FOR LOGIN YOUR_LOGIN;
```
4. Asígnales el rol db_datareader:
```
EXEC sp_addrolemember 'db_datareader', 'USER_NAME';
```
5. Otórgale el permiso VIEW DATABASE STATE:
```
GRANT VIEW DATABASE STATE TO 'USER_NAME';
```
6. 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 que se describen en esta sección solo son obligatorios cuando configuras tu base de datos de SQL Server de origen para usarla con el método CDC de los registros de transacciones.

Conéctate a la base de datos de origen y asigna db_owner y db_denydatawriter. roles a tu usuario:

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

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 durante el cual quieres que estén disponibles los cambios 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 Se establece en 86399. Esto significa que el registro de transacciones retiene los cambios de 86,399 segundos (un día). La ejecución del procedimiento sp_cdc_start_job 'capture inicia la configuración.
Si hay trabajos de limpieza o captura en ejecución en tu base de datos, deténlos. Para obtener más información, consulta Administra y supervisa la captura de datos modificados.

Configura una protección de truncamiento de registros.

Para asegurarte de que el lector de CDC tenga tiempo suficiente para leer los registros, a la vez que permite truncamiento de registros para evitar que se use el espacio de almacenamiento, configura un truncamiento protección:

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

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

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;

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

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.