

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Orígenes para la migración de datos
<a name="CHAP_Source"></a>

AWS Database Migration Service (AWS DMS) puede utilizar muchos de los motores de datos más populares como fuente de replicación de datos. El origen de la base de datos puede hallarse en un motor autoadministrado en ejecución en una instancia de Amazon EC2 o en una base de datos en las instalaciones. O puede ser una fuente de datos de un AWS servicio como Amazon RDS o Amazon S3.

Para obtener una lista completa de orígenes válidos, consulte [Orígenes de AWS DMS](CHAP_Introduction.Sources.md#CHAP_Introduction.Sources.title).

**Topics**
+ [Uso de una base de datos Oracle como fuente para AWS DMS](CHAP_Source.Oracle.md)
+ [Uso de una base de datos de Microsoft SQL Server como fuente para AWS DMS](CHAP_Source.SQLServer.md)
+ [Uso de la base de datos SQL de Microsoft Azure como fuente para AWS DMS](CHAP_Source.AzureSQL.md)
+ [Uso de Microsoft Azure SQL Managed Instance como fuente para AWS DMS](CHAP_Source.AzureMgd.md)
+ [Uso del servidor flexible Microsoft Azure Database para PostgreSQL como fuente para AWS DMS](CHAP_Source.AzureDBPostgreSQL.md)
+ [Uso del servidor flexible Microsoft Azure Database for MySQL como fuente para AWS DMS](CHAP_Source.AzureDBMySQL.md)
+ [Uso de OCI MySQL Heatwave como fuente para AWS DMS](CHAP_Source.heatwave.md)
+ [Uso de Google Cloud para MySQL como fuente de AWS DMS](CHAP_Source.GC.md)
+ [Uso de Google Cloud para PostgreSQL como fuente para AWS DMS](CHAP_Source.GCPostgres.md)
+ [Uso de una base de datos PostgreSQL como fuente AWS DMS](CHAP_Source.PostgreSQL.md)
+ [Uso de una base de datos compatible con MySQL como fuente para AWS DMS](CHAP_Source.MySQL.md)
+ [Uso de una base de datos SAP ASE como fuente para AWS DMS](CHAP_Source.SAP.md)
+ [Uso de MongoDB como fuente para AWS DMS](CHAP_Source.MongoDB.md)
+ [Uso de Amazon DocumentDB (compatible con MongoDB) como fuente para AWS DMS](CHAP_Source.DocumentDB.md)
+ [Uso de Amazon S3 como fuente de AWS DMS](CHAP_Source.S3.md)
+ [Uso de la base de datos IBM Db2 para Linux, Unix, Windows y Amazon RDS (Db2 LUW) como fuente para AWS DMS](CHAP_Source.DB2.md)
+ [Uso de IBM Db2 para z/OS bases de datos como fuente para AWS DMS](CHAP_Source.DB2zOS.md)

# Uso de una base de datos Oracle como fuente para AWS DMS
<a name="CHAP_Source.Oracle"></a>

Puede migrar datos de una o varias bases de datos Oracle utilizando AWS DMS. Con una base de datos de Oracle como origen, podrá migrar datos a cualquiera de los destinos compatibles con AWS DMS.

AWS DMS admite las siguientes ediciones de bases de datos Oracle:
+ Oracle Enterprise Edition
+ Oracle Standard Edition
+ Oracle Express Edition
+ Oracle Personal Edition

Para obtener información sobre las versiones de las bases de datos Oracle que AWS DMS admiten como fuente, consulte[Fuentes de AWS DMS](CHAP_Introduction.Sources.md).

Puede utilizar la Capa de conexión segura (SSL) para cifrar las conexiones entre el punto de enlace de Oracle y la instancia de replicación. Para obtener más información acerca de cómo usar SSL con un punto de enlace de Oracle, consulte [Compatibilidad con SSL para un punto de enlace de Oracle](#CHAP_Security.SSL.Oracle).

AWS DMS admite el uso del cifrado de datos transparente (TDE) de Oracle para cifrar los datos en reposo en la base de datos de origen. Para obtener más información sobre el uso de Oracle TDE con un punto de enlace de origen de Oracle, consulte [Métodos de cifrado compatibles para utilizar Oracle como fuente de AWS DMS](#CHAP_Source.Oracle.Encryption).

AWS admite el uso de la versión 1.2 y posteriores de TLS con los puntos de conexión de Oracle (y todos los demás tipos de puntos de conexión) y recomienda utilizar la versión 1.3 o posterior de TLS.

Siga estos pasos para configurar una base de datos Oracle como punto final de origen: AWS DMS 

1. Cree un usuario de Oracle con los permisos adecuados para acceder AWS DMS a su base de datos de origen de Oracle.

1. Cree un punto de conexión de origen de Oracle que se ajuste a la configuración de base de datos de Oracle que haya elegido. Para crear una full-load-only tarea, no es necesaria ninguna configuración adicional.

1. Para crear una tarea que gestione la captura de datos de cambios (una tarea de CDC exclusiva o completa), elija Oracle LogMiner o AWS DMS Binary Reader para capturar los cambios en los datos. Si elige LogMiner Binary Reader, se determinan algunos de los permisos y opciones de configuración posteriores. Para ver una comparación entre un lector binario LogMiner y un lector binario, consulte la siguiente sección.

**nota**  
Para obtener más información sobre las tareas de carga completa, las tareas exclusivas de CDC y las tareas de carga completa y de CDC, consulte [Creación de una tarea](CHAP_Tasks.Creating.md)

Para obtener más información sobre cómo trabajar con bases de datos fuente de Oracle AWS DMS, consulte las siguientes secciones. 

**Topics**
+ [Uso de Oracle LogMiner o AWS DMS Binary Reader para CDC](#CHAP_Source.Oracle.CDC)
+ [Flujos de trabajo para configurar una base de datos fuente Oracle AWS autogestionada o gestionada para AWS DMSConfiguración de una base de datos de origen de Oracle](#CHAP_Source.Oracle.Workflows)
+ [Trabajar con una base de datos Oracle autogestionada como fuente de AWS DMS](#CHAP_Source.Oracle.Self-Managed)
+ [Trabajar con una base AWS de datos Oracle gestionada como fuente de AWS DMS](#CHAP_Source.Oracle.Amazon-Managed)
+ [Limitaciones del uso de Oracle como fuente de AWS DMS](#CHAP_Source.Oracle.Limitations)
+ [Compatibilidad con SSL para un punto de enlace de Oracle](#CHAP_Security.SSL.Oracle)
+ [Métodos de cifrado compatibles para utilizar Oracle como fuente de AWS DMS](#CHAP_Source.Oracle.Encryption)
+ [Métodos de compresión compatibles para utilizar Oracle como fuente de AWS DMS](#CHAP_Source.Oracle.Compression)
+ [Replicación de tablas anidadas utilizando Oracle como fuente de AWS DMS](#CHAP_Source.Oracle.NestedTables)
+ [Almacenar REDO en Oracle ASM cuando se utiliza Oracle como fuente de AWS DMS](#CHAP_Source.Oracle.REDOonASM)
+ [Configuración del punto final cuando se utiliza Oracle como fuente de AWS DMS](#CHAP_Source.Oracle.ConnectionAttrib)
+ [Tipos de datos de origen para Oracle](#CHAP_Source.Oracle.DataTypes)

## Uso de Oracle LogMiner o AWS DMS Binary Reader para CDC
<a name="CHAP_Source.Oracle.CDC"></a>

En AWS DMS, hay dos métodos para leer los registros rehechos al realizar la captura de datos de cambios (CDC) para Oracle como fuente: Oracle LogMiner y AWS DMS Binary Reader. LogMiner es una API de Oracle para leer los redo logs en línea y los archivos redo log archivados. El lector binario es un AWS DMS método que lee y analiza directamente los archivos redo log sin procesar. Estos métodos tienen las características siguientes.


| Característica | LogMiner | Binary Reader | 
| --- | --- | --- | 
| Fácil de configurar | Sí | No | 
| Menor impacto en el sistema fuente I/O y la CPU | No | Sí | 
| Mejor rendimiento de CDC | No | Sí | 
| Compatible con clústeres de tablas de Oracle | Sí | No | 
| Compatible con todos los tipos de compresión en columnas híbrida (HCC) de Oracle | Sí |  Parcialmente Binary Reader no admite QUERY LOW para realizar tareas con CDC. Todos los demás tipos de HCC son totalmente compatibles.  | 
| Solo se admiten columnas de LOB en Oracle 12c | No (el soporte LOB no está disponible LogMiner en Oracle 12c). | Sí | 
| Admite instrucciones UPDATE que afectan solo a las columnas de LOB | No | Sí | 
| Compatible con el cifrado de datos transparente (TDE) de Oracle |  Parcialmente Cuando se utiliza Oracle LogMiner, AWS DMS no admite el cifrado TDE a nivel de columna para Amazon RDS for Oracle.  |  Parcialmente Binary Reader admite TDE solo para bases de datos de Oracle autoadministradas.  | 
| Admite todos los métodos de compresión de Oracle | Sí | No | 
| Compatible con transacciones XA | No | Sí | 
| RAC |  Sí No se recomienda, debido a motivos de rendimiento y a algunas limitaciones internas de DMS.  |  Sí Altamente recomendado  | 

**nota**  
De forma predeterminada, AWS DMS utiliza Oracle LogMiner para (CDC).   
AWS DMS admite métodos de cifrado de datos transparente (TDE) cuando se trabaja con una base de datos fuente de Oracle. Si las credenciales de TDE que especifique son incorrectas, la tarea de migración de AWS DMS no genera ningún error, lo que puede afectar a la replicación continua de las tablas cifradas. Para obtener más información acerca de la especificación de credenciales de TDE, consulte [Métodos de cifrado compatibles para utilizar Oracle como fuente de AWS DMS](#CHAP_Source.Oracle.Encryption).

Entre las principales ventajas de utilizarlos LogMiner con se AWS DMS incluyen las siguientes:
+ LogMiner es compatible con la mayoría de las opciones de Oracle, como las opciones de cifrado y compresión. Binary Reader no admite todas las opciones de Oracle, especialmente la compresión y la mayoría de las opciones de cifrado.
+ LogMiner ofrece una configuración más sencilla, especialmente en comparación con la configuración de acceso directo de Binary Reader o cuando los registros rehechos se gestionan mediante Oracle Automatic Storage Management (ASM).
+ LogMiner admite clústeres de tablas para su uso por parte de. AWS DMS Binary Reader no.

Entre las principales ventajas de utilizar Binary Reader se AWS DMS incluyen las siguientes:
+ En el caso de las migraciones con un gran volumen de cambios, LogMiner es posible que esto afecte en parte I/O o en la CPU al ordenador que aloja la base de datos de origen de Oracle. Binary Reader tiene menos probabilidades de tener un I/O impacto en la CPU, ya que los registros se extraen directamente en lugar de realizar múltiples consultas a la base de datos.
+ En el caso de las migraciones con un gran volumen de cambios, el rendimiento de CDC suele ser mucho mejor cuando se utiliza Binary Reader en comparación con Oracle LogMiner.
+ Binary Reader es compatible con CDC LOBs en la versión 12c de Oracle. LogMiner no lo hace.

En general, utilice Oracle LogMiner para migrar su base de datos Oracle, a menos que se dé una de las siguientes situaciones:
+ Necesita ejecutar varias tareas de migración en la base de datos de origen de Oracle.
+ El volumen de cambios o el volumen de registros REDO en la base de datos de Oracle de origen es alto o tiene cambios y también está utilizando Oracle ASM.

**nota**  
Si cambia entre el uso de Oracle LogMiner y el de AWS DMS Binary Reader, asegúrese de reiniciar la tarea de CDC. 

### Configuración para CDC en una base de datos de origen de Oracle
<a name="CHAP_Source.Oracle.CDC.Configuration"></a>

Para que un punto de conexión de origen de Oracle se conecte a la base de datos para realizar una tarea de captura de datos de cambios (CDC), es posible que deba especificar atributos de conexión adicionales. Esto puede ser válido para una tarea de carga completa y de CDC o para una tarea exclusiva de CDC. Los atributos de conexión adicionales que especifique dependen del método que utilice para acceder a los redo logs: Oracle LogMiner o AWS DMS Binary Reader. 

Debe especificar atributos de conexión adicionales al crear un punto de conexión de origen. Si tiene varios valores de atributos de conexión, sepárelos entre sí mediante punto y coma sin espacios en blanco adicionales (por ejemplo, `oneSetting;thenAnother`).

AWS DMS utiliza LogMiner de forma predeterminada. No es necesario que especifique más atributos de conexión para utilizarla. 

Para usar Binary Reader para acceder a los registros de REDO, agregue los siguientes atributos de conexión adicional.

```
useLogMinerReader=N;useBfile=Y;
```

Utilice el siguiente formato para que los atributos de conexión adicionales obtengan acceso a un servidor que utiliza ASM con Binary Reader.

```
useLogMinerReader=N;useBfile=Y;asm_user=asm_username;asm_server=RAC_server_ip_address:port_number/+ASM;
```

Establezca el parámetro de solicitud de punto de enlace de origen `Password` en la contraseña de usuario de Oracle y la contraseña de ASM, separadas por una coma de la siguiente manera.

```
oracle_user_password,asm_user_password
```

Cuando el origen de Oracle utiliza ASM, se puede trabajar con opciones de alto rendimiento en Binary Reader para el procesamiento de transacciones a escala. Estas opciones incluyen atributos de conexión adicionales para especificar el número de subprocesos paralelos (`parallelASMReadThreads`) y el número de búferes de lectura anticipada (`readAheadBlocks`). Configurar de estos atributos de forma conjunta puede mejorar significativamente el rendimiento de la tarea de CDC. La configuración siguiente proporciona buenos resultados para la mayoría de las configuraciones de ASM.

```
useLogMinerReader=N;useBfile=Y;asm_user=asm_username;asm_server=RAC_server_ip_address:port_number/+ASM;
    parallelASMReadThreads=6;readAheadBlocks=150000;
```

Para obtener más información sobre los valores que se admiten en los atributos de conexión adicionales, consulte [Configuración del punto final cuando se utiliza Oracle como fuente de AWS DMS](#CHAP_Source.Oracle.ConnectionAttrib).

Además, el rendimiento de una tarea de CDC con un origen de Oracle que usa ASM depende de otros ajustes que elija. Estas configuraciones incluyen sus atributos de conexión adicionales de AWS DMS y las configuraciones de SQL para configurar el origen de Oracle. Para obtener más información sobre los atributos de conexión adicionales para un origen de Oracle con ASM, consulte [Configuración del punto final cuando se utiliza Oracle como fuente de AWS DMS](#CHAP_Source.Oracle.ConnectionAttrib)

También debe elegir un punto de partida de CDC adecuado. Por lo general, al hacer esto, querrá identificar el punto de procesamiento de la transacción que captura la primera transacción abierta desde la que se inició la CDC. De lo contrario, la tarea de CDC puede omitir las transacciones abiertas anteriormente. Para una base de datos de origen de Oracle, puede elegir un punto de partida nativo de CDC en función del número de cambio del sistema (SCN) de Oracle para identificar la primera transacción abierta. Para obtener más información, consulte [Realizar la replicación comenzando desde un punto de inicio de CDC](CHAP_Task.CDC.md#CHAP_Task.CDC.StartPoint).

Para obtener más información sobre cómo configurar CDC para una base de datos de Oracle autoadministrada como origen, consulte [Se requieren privilegios de cuenta cuando se utiliza Oracle LogMiner para acceder a los redo logs](#CHAP_Source.Oracle.Self-Managed.LogMinerPrivileges), [Se requieren privilegios de cuenta cuando se utiliza AWS DMS Binary Reader para acceder a los redo logs](#CHAP_Source.Oracle.Self-Managed.BinaryReaderPrivileges) y [Privilegios de cuenta adicionales necesarios al utilizar Binary Reader con Oracle ASM](#CHAP_Source.Oracle.Self-Managed.ASMBinaryPrivileges).

Para obtener más información sobre cómo configurar CDC para una base AWS de datos Oracle gestionada como fuente, consulte [Configurar una tarea de CDC para utilizar Binary Reader con una fuente de RDS para Oracle para AWS DMS](#CHAP_Source.Oracle.Amazon-Managed.CDC) y[Uso de un Amazon RDS Oracle Standby (leer réplica) como fuente con Binary Reader for CDC en AWS DMS](#CHAP_Source.Oracle.Amazon-Managed.StandBy).

## Flujos de trabajo para configurar una base de datos fuente Oracle AWS autogestionada o gestionada para AWS DMS


## Configuración de una base de datos de origen de Oracle
<a name="CHAP_Source.Oracle.Workflows"></a>

Para configurar una instancia de base de datos de origen autoadministrada, siga los siguientes pasos del flujo de trabajo, en función de cómo realice la CDC. 


| Para este paso del flujo de trabajo | Si utiliza CDC, haga LogMiner lo siguiente | Si realiza la CDC con Binary Reader, haga lo siguiente | 
| --- | --- | --- | 
| Conceda privilegios de cuenta de Oracle. | Consulte [Se requieren privilegios de cuenta de usuario en una fuente de Oracle autogestionada para AWS DMS](#CHAP_Source.Oracle.Self-Managed.Privileges). | Consulte [Se requieren privilegios de cuenta de usuario en una fuente de Oracle autogestionada para AWS DMS](#CHAP_Source.Oracle.Self-Managed.Privileges). | 
| Prepare la base de datos de origen para la replicación mediante CDC. | Consulte [Preparar una base de datos fuente autogestionada de Oracle para los CDC mediante AWS DMS](#CHAP_Source.Oracle.Self-Managed.Configuration). | Consulte [Preparar una base de datos fuente autogestionada de Oracle para los CDC mediante AWS DMS](#CHAP_Source.Oracle.Self-Managed.Configuration). | 
| Conceda los privilegios de usuario de Oracle adicionales necesarios para CDC. | Consulte [Se requieren privilegios de cuenta cuando se utiliza Oracle LogMiner para acceder a los redo logs](#CHAP_Source.Oracle.Self-Managed.LogMinerPrivileges). | Consulte [Se requieren privilegios de cuenta cuando se utiliza AWS DMS Binary Reader para acceder a los redo logs](#CHAP_Source.Oracle.Self-Managed.BinaryReaderPrivileges). | 
| Para una instancia de Oracle con ASM, conceda los privilegios de cuenta de usuario adicionales necesarios para acceder a ASM para CDC. | Sin acción adicional. AWS DMS admite Oracle ASM sin privilegios de cuenta adicionales. | Consulte [Privilegios de cuenta adicionales necesarios al utilizar Binary Reader con Oracle ASM](#CHAP_Source.Oracle.Self-Managed.ASMBinaryPrivileges). | 
| Si aún no lo ha hecho, configure la tarea para utilizar LogMiner nuestro Binary Reader for CDC. | Consulte [Uso de Oracle LogMiner o AWS DMS Binary Reader para CDC](#CHAP_Source.Oracle.CDC). | Consulte [Uso de Oracle LogMiner o AWS DMS Binary Reader para CDC](#CHAP_Source.Oracle.CDC). | 
| Configure Oracle Standby como origen para la CDC. | AWS DMS no admite Oracle Standby como fuente. | Consulte [Uso de un Oracle Standby autogestionado como fuente con Binary Reader para CDC en AWS DMS](#CHAP_Source.Oracle.Self-Managed.BinaryStandby). | 

Utilice los siguientes pasos del flujo de trabajo para configurar una instancia de base AWS de datos fuente de Oracle gestionada.


| Para este paso del flujo de trabajo | Si utiliza CDC LogMiner, haga lo siguiente | Si realiza la CDC con Binary Reader, haga lo siguiente | 
| --- | --- | --- | 
| Conceda privilegios de cuenta de Oracle. | Para obtener más información, consulte [Se requieren privilegios de cuenta de usuario en una fuente de Oracle AWS gestionada por Oracle para AWS DMS](#CHAP_Source.Oracle.Amazon-Managed.Privileges). | Para obtener más información, consulte [Se requieren privilegios de cuenta de usuario en una fuente de Oracle AWS gestionada por Oracle para AWS DMS](#CHAP_Source.Oracle.Amazon-Managed.Privileges). | 
| Prepare la base de datos de origen para la replicación mediante CDC. | Para obtener más información, consulte [Configuración de una fuente de Oracle AWS gestionada por Oracle para AWS DMS](#CHAP_Source.Oracle.Amazon-Managed.Configuration). | Para obtener más información, consulte [Configuración de una fuente de Oracle AWS gestionada por Oracle para AWS DMS](#CHAP_Source.Oracle.Amazon-Managed.Configuration). | 
| Conceda los privilegios de usuario de Oracle adicionales necesarios para CDC. | No se requieren privilegios de cuenta adicionales. | Para obtener más información, consulte [Configurar una tarea de CDC para utilizar Binary Reader con una fuente de RDS para Oracle para AWS DMS](#CHAP_Source.Oracle.Amazon-Managed.CDC). | 
| Si aún no lo ha hecho, configure la tarea para utilizar nuestro LogMiner lector binario para los CDC. | Para obtener más información, consulte [Uso de Oracle LogMiner o AWS DMS Binary Reader para CDC](#CHAP_Source.Oracle.CDC). | Para obtener más información, consulte [Uso de Oracle LogMiner o AWS DMS Binary Reader para CDC](#CHAP_Source.Oracle.CDC). | 
| Configure Oracle Standby como origen para la CDC. | AWS DMS no admite Oracle Standby como fuente. | Para obtener más información, consulte [Uso de un Amazon RDS Oracle Standby (leer réplica) como fuente con Binary Reader for CDC en AWS DMS](#CHAP_Source.Oracle.Amazon-Managed.StandBy). | 

## Trabajar con una base de datos Oracle autogestionada como fuente de AWS DMS
<a name="CHAP_Source.Oracle.Self-Managed"></a>

Una *base de datos autoadministrada* es una base de datos que configura y controla, ya sea una instancia de base de datos en las instalaciones o una base de datos en Amazon EC2. A continuación, puede obtener información sobre los privilegios y las configuraciones que necesita para utilizar una base de datos Oracle autogestionada con. AWS DMS

### Se requieren privilegios de cuenta de usuario en una fuente de Oracle autogestionada para AWS DMS
<a name="CHAP_Source.Oracle.Self-Managed.Privileges"></a>

Para utilizar una base de datos Oracle como fuente AWS DMS, conceda los siguientes privilegios al usuario de Oracle especificado en la configuración de conexión del punto final de Oracle.

**nota**  
Al conceder privilegios, utilice el nombre real de los objetos, no el sinónimo de cada uno de ellos. Por ejemplo, utilice `V_$OBJECT` con el guion bajo, no `V$OBJECT` sin el guion bajo.

```
GRANT CREATE SESSION TO dms_user;
GRANT SELECT ANY TRANSACTION TO dms_user;
GRANT SELECT ON V_$ARCHIVED_LOG TO dms_user;
GRANT SELECT ON V_$LOG TO dms_user;
GRANT SELECT ON V_$LOGFILE TO dms_user;
GRANT SELECT ON V_$LOGMNR_LOGS TO dms_user;
GRANT SELECT ON V_$LOGMNR_CONTENTS TO dms_user;
GRANT SELECT ON V_$DATABASE TO dms_user;
GRANT SELECT ON V_$THREAD TO dms_user;
GRANT SELECT ON V_$PARAMETER TO dms_user;
GRANT SELECT ON V_$NLS_PARAMETERS TO dms_user;
GRANT SELECT ON V_$TIMEZONE_NAMES TO dms_user;
GRANT SELECT ON V_$TRANSACTION TO dms_user;
GRANT SELECT ON V_$CONTAINERS TO dms_user;                   
GRANT SELECT ON ALL_INDEXES TO dms_user;
GRANT SELECT ON ALL_OBJECTS TO dms_user;
GRANT SELECT ON ALL_TABLES TO dms_user;
GRANT SELECT ON ALL_USERS TO dms_user;
GRANT SELECT ON ALL_CATALOG TO dms_user;
GRANT SELECT ON ALL_CONSTRAINTS TO dms_user;
GRANT SELECT ON ALL_CONS_COLUMNS TO dms_user;
GRANT SELECT ON ALL_TAB_COLS TO dms_user;
GRANT SELECT ON ALL_IND_COLUMNS TO dms_user;
GRANT SELECT ON ALL_ENCRYPTED_COLUMNS TO dms_user;
GRANT SELECT ON ALL_LOG_GROUPS TO dms_user;
GRANT SELECT ON ALL_TAB_PARTITIONS TO dms_user;
GRANT SELECT ON SYS.DBA_REGISTRY TO dms_user;
GRANT SELECT ON SYS.OBJ$ TO dms_user;
GRANT SELECT ON DBA_TABLESPACES TO dms_user;
GRANT SELECT ON DBA_OBJECTS TO dms_user; -– Required if the Oracle version is earlier than 11.2.0.3.
GRANT SELECT ON SYS.ENC$ TO dms_user; -– Required if transparent data encryption (TDE) is enabled. For more information on using Oracle TDE with AWS DMS, see Métodos de cifrado compatibles para utilizar Oracle como fuente de AWS DMS.
GRANT SELECT ON GV_$TRANSACTION TO dms_user; -– Required if the source database is Oracle RAC in AWS DMS versions 3.4.6 and higher.
GRANT SELECT ON V_$DATAGUARD_STATS TO dms_user; -- Required if the source database is Oracle Data Guard and Oracle Standby is used in the latest release of DMS version 3.4.6, version 3.4.7, and higher.
GRANT SELECT ON V_$DATABASE_INCARNATION TO dms_user;
```

Conceda el privilegio adicional siguiente a cada tabla replicada cuando utilice una lista de tablas específica.

```
GRANT SELECT on any-replicated-table to dms_user;
```

Conceda el siguiente privilegio adicional para utilizar la característica de validación.

```
GRANT EXECUTE ON SYS.DBMS_CRYPTO TO dms_user;
```

Otorgue el siguiente privilegio adicional si utiliza un lector binario en lugar de LogMiner.

```
GRANT SELECT ON SYS.DBA_DIRECTORIES TO dms_user;
```

Conceda el siguiente privilegio adicional para exponer las vistas.

```
GRANT SELECT on ALL_VIEWS to dms_user;
```

Para exponer las vistas, también debe agregar el atributo de conexión adicional `exposeViews=true` al punto de conexión de origen.

Conceda el siguiente privilegio adicional cuando utilice replicaciones sin servidor.

```
GRANT SELECT on dba_segments to dms_user;
GRANT SELECT on v_$tablespace to dms_user;
GRANT SELECT on dba_tab_subpartitions to dms_user;
GRANT SELECT on dba_extents to dms_user;
```

Para obtener información acerca de las replicaciones sin servidor, consulte [Trabajando con AWS DMS Serverless](CHAP_Serverless.md).

Conceda los siguientes privilegios adicionales cuando utilice las evaluaciones previas a la migración específicas de Oracle.

```
GRANT SELECT on gv_$parameter  to dms_user;
GRANT SELECT on v_$instance to dms_user;
GRANT SELECT on v_$version to dms_user;
GRANT SELECT on gv_$ASM_DISKGROUP to dms_user;
GRANT SELECT on gv_$database to dms_user;
GRANT SELECT on dba_db_links to dms_user;
GRANT SELECT on gv_$log_History to dms_user;
GRANT SELECT on gv_$log to dms_user;
GRANT SELECT ON DBA_TYPES TO dms_user;
GRANT SELECT ON DBA_USERS to dms_user;
GRANT SELECT ON DBA_DIRECTORIES to dms_user;
GRANT EXECUTE ON SYS.DBMS_XMLGEN TO dms_user;
```

Para obtener información sobre las evaluaciones previas a la migración específicas de Oracle, consulte [Evaluaciones de Oracle](CHAP_Tasks.AssessmentReport.Oracle.md).

#### Requisitos previos para gestionar las transacciones abiertas en Oracle Standby
<a name="CHAP_Source.Oracle.Self-Managed.Privileges.Standby"></a>

Cuando utilice AWS DMS las versiones 3.4.6 y posteriores, lleve a cabo los siguientes pasos para gestionar las transacciones abiertas de Oracle Standby. 

1. Cree un enlace de base de datos denominado `AWSDMS_DBLINK` en la base de datos principal. `DMS_USER` utilizará el enlace de la base de datos para conectarse a la base de datos principal. Tenga en cuenta que el enlace de la base de datos se ejecuta desde la instancia en espera para consultar las transacciones abiertas que se ejecutan en la base de datos principal. Consulte el siguiente ejemplo. 

   ```
   CREATE PUBLIC DATABASE LINK AWSDMS_DBLINK 
      CONNECT TO DMS_USER IDENTIFIED BY DMS_USER_PASSWORD
      USING '(DESCRIPTION=
               (ADDRESS=(PROTOCOL=TCP)(HOST=PRIMARY_HOST_NAME_OR_IP)(PORT=PORT))
               (CONNECT_DATA=(SERVICE_NAME=SID))
             )';
   ```

1. Compruebe que se ha establecido la conexión con el enlace de base de datos mediante `DMS_USER`, como se muestra en el siguiente ejemplo.

   ```
   select 1 from dual@AWSDMS_DBLINK
   ```

### Preparar una base de datos fuente autogestionada de Oracle para los CDC mediante AWS DMS
<a name="CHAP_Source.Oracle.Self-Managed.Configuration"></a>

Prepare la base de datos de Oracle autoadministrada como origen para ejecutar una tarea de CDC de la siguiente manera: 
+ [Verificar que sea AWS DMS compatible con la versión de la base de datos fuente](#CHAP_Source.Oracle.Self-Managed.Configuration.DbVersion).
+ [Asegurarse de que el modo ARCHIVELOG esté activado](#CHAP_Source.Oracle.Self-Managed.Configuration.ArchiveLogMode).
+ [Configuración del registro complementario](#CHAP_Source.Oracle.Self-Managed.Configuration.SupplementalLogging).

#### Verificar que sea AWS DMS compatible con la versión de la base de datos fuente
<a name="CHAP_Source.Oracle.Self-Managed.Configuration.DbVersion"></a>

Ejecute una consulta como la siguiente para comprobar que la versión actual de la base de datos de origen de Oracle es compatible con AWS DMS.

```
SELECT name, value, description FROM v$parameter WHERE name = 'compatible';
```

Aquí, `name`, `value` y `description` son columnas presentes en algún lugar de la base de datos que se están consultando en función del valor de `name`. Si esta consulta se ejecuta sin errores, AWS DMS es compatible con la versión actual de la base de datos y puede continuar con la migración. Si la consulta genera un error, AWS DMS no es compatible con la versión actual de la base de datos. Para continuar con la migración, primero convierta la base de datos Oracle a una versión compatible con AWS DMS.

#### Asegurarse de que el modo ARCHIVELOG esté activado
<a name="CHAP_Source.Oracle.Self-Managed.Configuration.ArchiveLogMode"></a>

Puede ejecutar Oracle en dos modos diferentes: `ARCHIVELOG` y `NOARCHIVELOG`. Para ejecutar una tarea de CDC, ejecute la base de datos en modo `ARCHIVELOG`. Para saber si la base de datos está en modo `ARCHIVELOG`, ejecute la siguiente consulta.

```
SQL> SELECT log_mode FROM v$database;
```

Si se devuelve el modo `NOARCHIVELOG`, establezca la base de datos en `ARCHIVELOG` según las instrucciones de Oracle. 

#### Configuración del registro complementario
<a name="CHAP_Source.Oracle.Self-Managed.Configuration.SupplementalLogging"></a>

Para capturar los cambios en curso, es AWS DMS necesario que habilite un registro adicional mínimo en la base de datos de origen de Oracle. Además, debe habilitar el registro adicional en cada tabla replicada de la base de datos.

De forma predeterminada, AWS DMS agrega un registro `PRIMARY KEY` suplementario en todas las tablas replicadas. Para permitir AWS DMS agregar registros `PRIMARY KEY` adicionales, otorgue el siguiente privilegio para cada tabla replicada.

```
ALTER on any-replicated-table;
```

Puede deshabilitar el registro `PRIMARY KEY` suplementario predeterminado agregado AWS DMS mediante el atributo de conexión adicional. `addSupplementalLogging` Para obtener más información, consulte [Configuración del punto final cuando se utiliza Oracle como fuente de AWS DMS](#CHAP_Source.Oracle.ConnectionAttrib).

Asegúrese de activar el registro suplementario si la tarea de replicación actualiza una tabla mediante una cláusula `WHERE` que no hace referencia a una columna de clave principal.

**Configuración manual del registro suplementario**

1. Ejecute la siguiente consulta para comprobar si el registro suplementario está habilitado para la base de datos.

   ```
   SELECT supplemental_log_data_min FROM v$database;
   ```

   Si el resultado devuelto es `YES` o `IMPLICIT`, el registro suplementario está habilitado para la base de datos.

   De lo contrario, habilite el registro suplementario para la base de datos ejecutando el siguiente comando.

   ```
   ALTER DATABASE ADD SUPPLEMENTAL LOG DATA;
   ```

1. Asegúrese de que se agrega el registro suplementario requerido se agrega para cada tabla replicada.

   Considere lo siguiente:
   + Si se agrega un registro complementario de `ALL COLUMNS` a la tabla, no necesita agregar más registros.
   + Si existe una clave principal, agregue un registro suplementario para la clave principal. Puede hacerlo utilizando el formato para agregar un registro suplementario en la clave principal misma o agregando un registro suplementario en las columnas de la clave principal en la base de datos.

     ```
     ALTER TABLE Tablename ADD SUPPLEMENTAL LOG DATA (PRIMARY KEY) COLUMNS;
     ALTER DATABASE ADD SUPPLEMENTAL LOG DATA (PRIMARY KEY) COLUMNS;
     ```
   + Si no hay una clave principal y la tabla tiene un solo índice único, agregue todas las columnas del índice único al registro suplementario.

     ```
     ALTER TABLE TableName ADD SUPPLEMENTAL LOG GROUP LogGroupName (UniqueIndexColumn1[, UniqueIndexColumn2] ...) ALWAYS;
     ```

     Usar `SUPPLEMENTAL LOG DATA (UNIQUE INDEX) COLUMNS` no añade las columnas de índice único al registro.
   + Si no existe ninguna clave principal y la tabla tiene varios índices únicos, AWS DMS selecciona el primer índice único de una lista ascendente ordenada alfabéticamente. Debe agregar un registro complementario en las columnas del índice seleccionado, como en el elemento anterior.

     Usar `SUPPLEMENTAL LOG DATA (UNIQUE INDEX) COLUMNS` no añade las columnas de índice único al registro.
   + Si no existe ninguna clave principal y no hay un índice único, agregue el registro suplementario en todas las columnas.

     ```
     ALTER TABLE TableName ADD SUPPLEMENTAL LOG DATA (ALL) COLUMNS;
     ```

     En algunos casos, el índice único o la clave primaria de la tabla de destino son diferentes del índice único o la clave primaria de la tabla de origen. En dichos casos, agregue manualmente el registro suplementario en las columnas de la tabla de origen que componen el índice único o la clave principal de la tabla de destino.

     Si cambia la clave principal de la tabla de destino, debe agregar el registro suplementario en las columnas del índice seleccionadas, en lugar de en las columnas de la clave principal o el índice único originales.

Si se define un filtro o una transformación para una tabla, es posible que deba habilitar el registro adicional.

Considere lo siguiente:
+ Si se agrega un registro complementario de `ALL COLUMNS` a la tabla, no necesita agregar más registros.
+ Si la tabla contiene un índice único o una clave principal, agregue registros suplementarios en cada columna con un filtro o transformación. Sin embargo, hágalo solo si esas columnas son diferentes de la clave principal o de las columnas de índice únicas.
+ Si una transformación incluye tan solo una columna, no agregue esta columna a un grupo de registro suplementario. Por ejemplo, para una transformación `A+B`, agregue un registro suplementario en ambas columnas `A` y `B`. Sin embargo, para una transformación `substring(A,10)` no agregue un registro suplementario en la columna `A`.
+ Para configurar el registro suplementario en columnas de clave principal o de índice único y en otras columnas específicas que se filtran o transforman, puede configurar el registro suplementario `USER_LOG_GROUP`. Agregue este registro en las columnas de clave principal o índice único y cualquier otra columna específica que se filtre o transforme.

  Por ejemplo, para replicar una tabla denominada `TEST.LOGGING` con la clave principal `ID` y un filtro según la columna `NAME`, puede ejecutar un comando similar al siguiente para crear el registro suplementario del grupo de registros.

  ```
  ALTER TABLE TEST.LOGGING ADD SUPPLEMENTAL LOG GROUP TEST_LOG_GROUP (ID, NAME) ALWAYS;
  ```

### Se requieren privilegios de cuenta cuando se utiliza Oracle LogMiner para acceder a los redo logs
<a name="CHAP_Source.Oracle.Self-Managed.LogMinerPrivileges"></a>

Para acceder a los redo logs mediante Oracle LogMiner, conceda los siguientes privilegios al usuario de Oracle especificado en la configuración de conexión del punto final de Oracle.

```
GRANT EXECUTE on DBMS_LOGMNR to dms_user;
GRANT SELECT on V_$LOGMNR_LOGS to dms_user;
GRANT SELECT on V_$LOGMNR_CONTENTS to dms_user;
GRANT LOGMINING to dms_user; -– Required only if the Oracle version is 12c or higher.
```

### Se requieren privilegios de cuenta cuando se utiliza AWS DMS Binary Reader para acceder a los redo logs
<a name="CHAP_Source.Oracle.Self-Managed.BinaryReaderPrivileges"></a>

Para acceder a los redo logs mediante el lector AWS DMS binario, conceda los siguientes privilegios al usuario de Oracle especificado en la configuración de conexión del punto final de Oracle.

```
GRANT SELECT on v_$transportable_platform to dms_user;   -– Grant this privilege if the redo logs are stored in Oracle Automatic Storage Management (ASM) and AWS DMS accesses them from ASM.
GRANT CREATE ANY DIRECTORY to dms_user;                  -– Grant this privilege to allow AWS DMS to use Oracle BFILE read file access in certain cases. This access is required when the replication instance does not have file-level access to the redo logs and the redo logs are on non-ASM storage.
GRANT EXECUTE on DBMS_FILE_TRANSFER to dms_user;         -– Grant this privilege to copy the redo log files to a temporary folder using the CopyToTempFolder method.
GRANT EXECUTE on DBMS_FILE_GROUP to dms_user;
```

Binary Reader funciona con características de archivos de Oracle que incluyen los directorios de Oracle. Cada objeto de directorio de Oracle incluye el nombre de la carpeta que contiene los archivos de registros REDO que se van a procesar. Estos directorios de Oracle no están representados en el nivel del sistema de archivos. En cambio, se trata de directorios lógicos que se crean en el nivel de bases de datos de Oracle. Puede verlos en la vista `ALL_DIRECTORIES` de Oracle.

Si desea AWS DMS crear estos directorios de Oracle, otorgue el `CREATE ANY DIRECTORY` privilegio especificado anteriormente. AWS DMS crea los nombres de los directorios con el `DMS_` prefijo. Si no concede el privilegio `CREATE ANY DIRECTORY`, cree manualmente los directorios correspondientes. En algunos casos, cuando se crean manualmente los directorios de Oracle, el usuario de Oracle especificado en el punto de enlace de origen de Oracle no es el usuario que creó estos directorios. En estos casos, otorgue también el privilegio `READ on DIRECTORY`.

**nota**  
AWS DMS Los CDC no admiten Active Dataguard Standby si no está configurado para utilizar el servicio de retransporte automático.

En algunos casos, puede utilizar Oracle Managed Files (OMF) para almacenar los registros. O bien, el punto de conexión de origen está en ADG y no se puede conceder el privilegio CREATE ANY DIRECTORY. En estos casos, cree manualmente los directorios con todas las ubicaciones de registro posibles antes de iniciar la tarea de AWS DMS replicación. Si AWS DMS no encuentra el directorio creado previamente que espera, la tarea se detiene. Además, AWS DMS no elimina las entradas que ha creado en la `ALL_DIRECTORIES` vista, por lo que las elimina manualmente.

### Privilegios de cuenta adicionales necesarios al utilizar Binary Reader con Oracle ASM
<a name="CHAP_Source.Oracle.Self-Managed.ASMBinaryPrivileges"></a>

Para acceder a los registros REDO en Automatic Storage Management (ASM) mediante Binary Reader, otorgue los siguientes privilegios al usuario de Oracle especificado en la configuración de conexión del punto de conexión de Oracle.

```
SELECT ON v_$transportable_platform
SYSASM -– To access the ASM account with Oracle 11g Release 2 (version 11.2.0.2) and higher, grant the Oracle endpoint user the SYSASM privilege. For older supported Oracle versions, it's typically sufficient to grant the Oracle endpoint user the SYSDBA privilege.
```

Puede validar el acceso a la cuenta de ASM abriendo un símbolo del sistema e invocando una de las instrucciones siguientes, en función de la versión de Oracle especificada anteriormente.

Si necesita el privilegio `SYSDBA`, utilice lo siguiente.

```
sqlplus asmuser/asmpassword@+asmserver as sysdba
```

Si necesita el privilegio `SYSASM`, utilice lo siguiente. 

```
sqlplus asmuser/asmpassword@+asmserver as sysasm
```

### Uso de un Oracle Standby autogestionado como fuente con Binary Reader para CDC en AWS DMS
<a name="CHAP_Source.Oracle.Self-Managed.BinaryStandby"></a>

Para configurar una instancia de Oracle Standby como origen al utilizar Binary Reader para CDC, comience con los siguientes requisitos previos:
+ AWS DMS actualmente solo es compatible con Oracle Active Data Guard Standby.
+ Asegúrese de que la configuración de Oracle Data Guard utilice:
  + Servicios de transporte REDO para transferencias automatizadas de datos REDO.
  + Aplique los servicios para aplicar REDO automáticamente a la base de datos en espera.

Para confirmar que se cumplen esos requisitos, ejecute la siguiente consulta.

```
SQL> select open_mode, database_role from v$database;
```

A partir del resultado de esa consulta, confirme que la base de datos en espera está abierta en modo SOLO LECTURA y que la función REDO se aplica automáticamente. Por ejemplo:

```
OPEN_MODE             DATABASE_ROLE
--------------------  ----------------
READ ONLY WITH APPLY  PHYSICAL STANDBY
```

**Configuración de una instancia de Oracle Standby como origen al utilizar Binary Reader para CDC**

1. Conceda los privilegios adicionales necesarios para acceder a los archivos de registro en espera.

   ```
   GRANT SELECT ON v_$standby_log TO dms_user;
   ```

1. Cree un punto de conexión de origen para Oracle Standby mediante Consola de administración de AWS o AWS CLI. Al crear el punto de conexión, especifique los siguientes atributos de conexión adicionales.

   ```
   useLogminerReader=N;useBfile=Y;
   ```
**nota**  
En AWS DMS, puede utilizar atributos de conexión adicionales para especificar si desea migrar desde los registros archivados en lugar de hacerlo desde los redo registros. Para obtener más información, consulte [Configuración del punto final cuando se utiliza Oracle como fuente de AWS DMS](#CHAP_Source.Oracle.ConnectionAttrib).

1. Configure el destino de los registros archivados.

   Binary Reader de DMS para el origen de Oracle sin ASM utiliza los directorios de Oracle para acceder a los registros REDO archivados. Si la base de datos está configurada para utilizar el área de recuperación rápida (FRA) como destino de los registros de archivado, la ubicación de los archivos REDO archivados no es constante. Cada día que se generan archivos REDO archivados, se crea un nuevo directorio en el FRA con el formato de nombre de directorio YYYY\$1MM\$1DD. Por ejemplo: 

   ```
   DB_RECOVERY_FILE_DEST/SID/archivelog/YYYY_MM_DD
   ```

   Cuando DMS necesita acceder a los archivos REDO archivados en el directorio FRA recién creado y se utiliza la base de datos principal de lectura y escritura como origen, DMS crea un directorio de Oracle nuevo o sustituye uno existente, de la siguiente manera. 

   ```
   CREATE OR REPLACE DIRECTORY dmsrep_taskid AS ‘DB_RECOVERY_FILE_DEST/SID/archivelog/YYYY_MM_DD’;
   ```

   Cuando la base de datos en espera se utiliza como origen, DMS no puede crear ni sustituir el directorio de Oracle porque la base de datos está en modo de solo lectura. Sin embargo, tiene la opción de realizar uno de estos pasos adicionales: 

   1. Modifique `log_archive_dest_id_1` para usar una ruta real en lugar de un FRA en una configuración tal que Oracle no cree subdirectorios diarios:

      ```
      ALTER SYSTEM SET log_archive_dest_1=’LOCATION=full directory path’
      ```

      A continuación, cree un objeto de directorio de Oracle para que lo utilice DMS:

      ```
      CREATE OR REPLACE DIRECTORY dms_archived_logs AS ‘full directory path’;
      ```

   1. Cree un destino de registro de archivo adicional y un objeto de directorio de Oracle dirigido a ese destino. Por ejemplo:

      ```
      ALTER SYSTEM SET log_archive_dest_3=’LOCATION=full directory path’; 
      CREATE DIRECTORY dms_archived_log AS ‘full directory path’;
      ```

      A continuación, agregue un atributo de conexión adicional al punto de conexión de origen de la tarea:

      ```
      archivedLogDestId=3
      ```

   1. Cree previamente de forma manual objetos de directorio de Oracle para que los utilice DMS.

      ```
      CREATE DIRECTORY dms_archived_log_20210301 AS ‘DB_RECOVERY_FILE_DEST/SID/archivelog/2021_03_01’;
      CREATE DIRECTORY dms_archived_log_20210302 AS ‘DB_RECOVERY_FILE_DEST>/SID>/archivelog/2021_03_02’; 
      ...
      ```

   1. Cree un trabajo de programador de Oracle que se ejecute a diario y cree el directorio necesario.

1. Configure el destino del registro en línea. 

   Cree un directorio de Oracle que apunte hacia el directorio del sistema operativo con los registros redo en espera:

   ```
   CREATE OR REPLACE DIRECTORY STANDBY_REDO_DIR AS '<full directory path>';
   GRANT READ ON DIRECTORY STANDBY_REDO_DIR TO <dms_user>;
   ```

### Uso de una base de datos gestionada por los usuarios en Oracle Cloud Infrastructure (OCI) como fuente para los CDC en AWS DMS
<a name="CHAP_Source.Oracle.Self-Managed.OCI"></a>

Una base de datos administrada por el usuario es una base de datos que configura y controla, como una base de datos de Oracle creada en una máquina virtual (VM), bare metal o un servidor Exadata. O bien, bases de datos que configura y controla y que se ejecutan en una infraestructura dedicada, como Oracle Cloud Infrastructure (OCI). La siguiente información describe los privilegios y las configuraciones que necesita para utilizar una base de datos administrada por los usuarios de Oracle en OCI como origen de captura de datos de cambios (CDC) en AWS DMS.

**Configuración de una base de datos de Oracle administrada por los usuarios alojada en OCI como origen de captura de datos de cambios**

1. Conceda privilegios de cuenta de usuario necesarios para una base de datos de origen de Oracle administrada por usuarios en OCI. Para obtener más información, consulte [Privilegios de cuenta para un punto de conexión de origen de Oracle autoadministrado](#CHAP_Source.Oracle.Self-Managed.Privileges).

1. Conceda privilegios de cuenta necesarios al utilizar Binary Reader para acceder a los registros de REDO. Para obtener más información, consulte [Privilegios de cuenta necesarios al utilizar Binary Reader](#CHAP_Source.Oracle.Self-Managed.BinaryReaderPrivileges).

1. Agregue privilegios de cuenta necesarios al utilizar Binary Reader con Oracle Automatic Storage Management (ASM). Para obtener más información, consulte [Privilegios de cuenta adicionales necesarios al utilizar Binary Reader con Oracle ASM](#CHAP_Source.Oracle.Self-Managed.ASMBinaryPrivileges).

1. Configure el registro suplementario. Para obtener más información, consulte [Configuración de un registro suplementario](#CHAP_Source.Oracle.Self-Managed.Configuration.SupplementalLogging).

1. Configure el cifrado de TDE. Para obtener más información, consulte [Métodos de cifrado cuando se utiliza una base de datos de Oracle como punto de conexión de origen](#CHAP_Source.Oracle.Encryption).

Las siguientes limitaciones se aplican al replicar datos de una base de datos de origen de Oracle en Oracle Cloud Infrastructure (OCI).

**Limitaciones**
+ DMS no admite el uso de Oracle LogMiner para acceder a los redo logs.
+ DMS no es compatible con una base de datos autónoma.

## Trabajar con una base AWS de datos Oracle gestionada como fuente de AWS DMS
<a name="CHAP_Source.Oracle.Amazon-Managed"></a>

Una base AWS de datos gestionada es una base de datos que se encuentra en un servicio de Amazon, como Amazon RDS, Amazon Aurora o Amazon S3. A continuación, encontrará los privilegios y las configuraciones que debe configurar al utilizar una base de datos Oracle AWS gestionada con. AWS DMS

### Se requieren privilegios de cuenta de usuario en una fuente de Oracle AWS gestionada por Oracle para AWS DMS
<a name="CHAP_Source.Oracle.Amazon-Managed.Privileges"></a>

Conceda los siguientes privilegios a la cuenta de usuario de Oracle especificada en la definición del punto de conexión de origen de Oracle.

**importante**  
Para todos los valores de parámetros, como `dms_user` y `any-replicated-table`, Oracle supone que el valor está todo en mayúsculas a no ser que especifique el valor con un identificador que distingue entre mayúsculas y minúsculas. Por ejemplo, supongamos que crea un valor de `dms_user` sin usar comillas, como en `CREATE USER myuser` o `CREATE USER MYUSER`. En este caso, Oracle identifica y almacena el valor todo en mayúsculas (`MYUSER`). Si utiliza comillas, como en `CREATE USER "MyUser"` o `CREATE USER 'MyUser'`, Oracle identifica y almacena el valor que distingue entre mayúsculas y minúsculas que especifique (`MyUser`).

```
GRANT CREATE SESSION to dms_user;
GRANT SELECT ANY TRANSACTION to dms_user;
GRANT SELECT on DBA_TABLESPACES to dms_user;
GRANT SELECT ON any-replicated-table to dms_user;
GRANT EXECUTE on rdsadmin.rdsadmin_util to dms_user;
 -- For Oracle 12c or higher:
GRANT LOGMINING to dms_user; – Required only if the Oracle version is 12c or higher.
```

Además, conceda permisos `SELECT` y `EXECUTE` sobre los objetos `SYS` mediante el procedimiento de Amazon RDS `rdsadmin.rdsadmin_util.grant_sys_object` como se muestra. Para obtener más información, consulte [Concesión de privilegios SELECT o EXECUTE a objetos SYS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html#Appendix.Oracle.CommonDBATasks.TransferPrivileges).

```
exec rdsadmin.rdsadmin_util.grant_sys_object('ALL_VIEWS', 'dms_user', 'SELECT');
exec rdsadmin.rdsadmin_util.grant_sys_object('ALL_TAB_PARTITIONS', 'dms_user', 'SELECT');
exec rdsadmin.rdsadmin_util.grant_sys_object('ALL_INDEXES', 'dms_user', 'SELECT');
exec rdsadmin.rdsadmin_util.grant_sys_object('ALL_OBJECTS', 'dms_user', 'SELECT');
exec rdsadmin.rdsadmin_util.grant_sys_object('ALL_TABLES', 'dms_user', 'SELECT');
exec rdsadmin.rdsadmin_util.grant_sys_object('ALL_USERS', 'dms_user', 'SELECT');
exec rdsadmin.rdsadmin_util.grant_sys_object('ALL_CATALOG', 'dms_user', 'SELECT');
exec rdsadmin.rdsadmin_util.grant_sys_object('ALL_CONSTRAINTS', 'dms_user', 'SELECT');
exec rdsadmin.rdsadmin_util.grant_sys_object('ALL_CONS_COLUMNS', 'dms_user', 'SELECT');
exec rdsadmin.rdsadmin_util.grant_sys_object('ALL_TAB_COLS', 'dms_user', 'SELECT');
exec rdsadmin.rdsadmin_util.grant_sys_object('ALL_IND_COLUMNS', 'dms_user', 'SELECT');
exec rdsadmin.rdsadmin_util.grant_sys_object('ALL_LOG_GROUPS', 'dms_user', 'SELECT');
exec rdsadmin.rdsadmin_util.grant_sys_object('V_$ARCHIVED_LOG', 'dms_user', 'SELECT');
exec rdsadmin.rdsadmin_util.grant_sys_object('V_$LOG', 'dms_user', 'SELECT');
exec rdsadmin.rdsadmin_util.grant_sys_object('V_$LOGFILE', 'dms_user', 'SELECT');
exec rdsadmin.rdsadmin_util.grant_sys_object('V_$DATABASE', 'dms_user', 'SELECT');
exec rdsadmin.rdsadmin_util.grant_sys_object('V_$THREAD', 'dms_user', 'SELECT');
exec rdsadmin.rdsadmin_util.grant_sys_object('V_$PARAMETER', 'dms_user', 'SELECT');
exec rdsadmin.rdsadmin_util.grant_sys_object('V_$NLS_PARAMETERS', 'dms_user', 'SELECT');
exec rdsadmin.rdsadmin_util.grant_sys_object('V_$TIMEZONE_NAMES', 'dms_user', 'SELECT');
exec rdsadmin.rdsadmin_util.grant_sys_object('V_$TRANSACTION', 'dms_user', 'SELECT');
exec rdsadmin.rdsadmin_util.grant_sys_object('V_$CONTAINERS', 'dms_user', 'SELECT');
exec rdsadmin.rdsadmin_util.grant_sys_object('DBA_REGISTRY', 'dms_user', 'SELECT');
exec rdsadmin.rdsadmin_util.grant_sys_object('OBJ$', 'dms_user', 'SELECT');
exec rdsadmin.rdsadmin_util.grant_sys_object('ALL_ENCRYPTED_COLUMNS', 'dms_user', 'SELECT');
exec rdsadmin.rdsadmin_util.grant_sys_object('V_$LOGMNR_LOGS', 'dms_user', 'SELECT');
exec rdsadmin.rdsadmin_util.grant_sys_object('V_$LOGMNR_CONTENTS','dms_user','SELECT');
exec rdsadmin.rdsadmin_util.grant_sys_object('DBMS_LOGMNR', 'dms_user', 'EXECUTE');

-- (as of Oracle versions 12.1 and higher)
exec rdsadmin.rdsadmin_util.grant_sys_object('REGISTRY$SQLPATCH', 'dms_user', 'SELECT');

-- (for Amazon RDS Active Dataguard Standby (ADG))
exec rdsadmin.rdsadmin_util.grant_sys_object('V_$STANDBY_LOG', 'dms_user', 'SELECT'); 

-- (for transparent data encryption (TDE))

exec rdsadmin.rdsadmin_util.grant_sys_object('ENC$', 'dms_user', 'SELECT'); 
               
-- (for validation with LOB columns)
exec rdsadmin.rdsadmin_util.grant_sys_object('DBMS_CRYPTO', 'dms_user', 'EXECUTE');
                    
-- (for binary reader)
exec rdsadmin.rdsadmin_util.grant_sys_object('DBA_DIRECTORIES','dms_user','SELECT'); 
                    
-- Required when the source database is Oracle Data guard, and Oracle Standby is used in the latest release of DMS version 3.4.6, version 3.4.7, and higher.

exec rdsadmin.rdsadmin_util.grant_sys_object('V_$DATAGUARD_STATS', 'dms_user', 'SELECT');
```

Para obtener más información sobre el uso de Amazon RDS Active Dataguard Standby (ADG) con AWS DMS , consulte [Uso de un Amazon RDS Oracle Standby (leer réplica) como fuente con Binary Reader for CDC en AWS DMS](#CHAP_Source.Oracle.Amazon-Managed.StandBy).

Para obtener más información sobre el uso de Oracle TDE con AWS DMS, consulte. [Métodos de cifrado compatibles para utilizar Oracle como fuente de AWS DMS](#CHAP_Source.Oracle.Encryption)

#### Requisitos previos para gestionar las transacciones abiertas en Oracle Standby
<a name="CHAP_Source.Oracle.Amazon-Managed.Privileges.Standby"></a>

Cuando utilice AWS DMS las versiones 3.4.6 y posteriores, lleve a cabo los siguientes pasos para gestionar las transacciones abiertas de Oracle Standby. 

1. Cree un enlace de base de datos denominado `AWSDMS_DBLINK` en la base de datos principal. `DMS_USER` utilizará el enlace de la base de datos para conectarse a la base de datos principal. Tenga en cuenta que el enlace de la base de datos se ejecuta desde la instancia en espera para consultar las transacciones abiertas que se ejecutan en la base de datos principal. Consulte el siguiente ejemplo. 

   ```
   CREATE PUBLIC DATABASE LINK AWSDMS_DBLINK 
      CONNECT TO DMS_USER IDENTIFIED BY DMS_USER_PASSWORD
      USING '(DESCRIPTION=
               (ADDRESS=(PROTOCOL=TCP)(HOST=PRIMARY_HOST_NAME_OR_IP)(PORT=PORT))
               (CONNECT_DATA=(SERVICE_NAME=SID))
             )';
   ```

1. Compruebe que se ha establecido la conexión con el enlace de base de datos mediante `DMS_USER`, como se muestra en el siguiente ejemplo.

   ```
   select 1 from dual@AWSDMS_DBLINK
   ```

### Configuración de una fuente de Oracle AWS gestionada por Oracle para AWS DMS
<a name="CHAP_Source.Oracle.Amazon-Managed.Configuration"></a>

Antes de utilizar una base AWS de datos Oracle gestionada como fuente AWS DMS, lleve a cabo las siguientes tareas para la base de datos Oracle:
+ Habilitar copias de seguridad automáticas. Para obtener más información sobre la habilitación de copias de seguridad automáticas, consulte [Habilitación de copias de seguridad automáticas](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithAutomatedBackups.html#USER_WorkingWithAutomatedBackups.Enabling) en la *Guía del usuario de Amazon RDS*.
+ Configure el registro suplementario.
+ Configure el archivado. El archivado de los redo logs de su instancia de base de datos Amazon RDS for Oracle AWS DMS permite recuperar la información del registro mediante LogMiner Oracle o Binary Reader. 

**Para configurar el archivado**

1. Ejecute el comando `rdsadmin.rdsadmin_util.set_configuration` para configurar el archivado.

   Por ejemplo, para retener los registros REDO archivados durante 24 horas, ejecute el siguiente comando.

   ```
   exec rdsadmin.rdsadmin_util.set_configuration('archivelog retention hours',24);
   commit;
   ```
**nota**  
La confirmación es necesaria para que un cambio surta efecto.

1. Asegúrese de que el almacenamiento dispone de espacio suficiente para los registros REDO archivados durante el periodo de retención especificado. Por ejemplo, si el periodo de retención es de 24 horas, calcule el tamaño total de los registros REDO archivados acumulados durante una hora normal de procesamiento de transacciones y multiplique ese total por 24. Compare este total calculado de 24 horas con el espacio de almacenamiento disponible y decida si tiene suficiente espacio de almacenamiento para gestionar el procesamiento de las transacciones durante 24 horas.

**Para configurar el registro suplementario**

1. Para habilitar el registro suplementario en el nivel de base de datos, ejecute el siguiente comando.

   ```
   exec rdsadmin.rdsadmin_util.alter_supplemental_logging('ADD');
   ```

1. Ejecute el siguiente comando para habilitar el registro suplementario de claves principales.

   ```
   exec rdsadmin.rdsadmin_util.alter_supplemental_logging('ADD','PRIMARY KEY');
   ```

1. (Opcional) Habilite el registro complementario en el nivel de clave en el nivel de tabla.

   La base de datos de origen incurre en pequeños gastos adicionales si el registro suplementario del nivel de la clave está habilitado. Por lo tanto, si migra solo un subconjunto de tablas, es posible que le interese habilitar el registro suplementario del nivel de la clave en el nivel de la tabla. Para habilitar el registro suplementario del nivel de la clave en el nivel de la tabla, ejecute el siguiente comando.

   ```
   alter table table_name add supplemental log data (PRIMARY KEY) columns;
   ```

### Configurar una tarea de CDC para utilizar Binary Reader con una fuente de RDS para Oracle para AWS DMS
<a name="CHAP_Source.Oracle.Amazon-Managed.CDC"></a>

Puede configurar el acceso AWS DMS a los registros de redo de instancias de Amazon RDS for Oracle de origen mediante Binary Reader for CDC. 

**nota**  
Para utilizar Oracle LogMiner, basta con los privilegios de cuenta de usuario mínimos requeridos. Para obtener más información, consulte [Se requieren privilegios de cuenta de usuario en una fuente de Oracle AWS gestionada por Oracle para AWS DMS](#CHAP_Source.Oracle.Amazon-Managed.Privileges).

Para utilizar AWS DMS Binary Reader, especifique ajustes y atributos de conexión adicionales para el punto final de origen de Oracle, según su AWS DMS versión.

La compatibilidad con Binary Reader está disponible en las siguientes versiones de Amazon RDS para Oracle:
+ Oracle 11.2: versiones 11.2.0.4V11 y superiores
+ Oracle 12.1: versiones 12.1.0.2V7 y superiores
+ Oracle 12.2: todas las versiones
+ Oracle 18.0: todas las versiones
+ Oracle 19.0: todas las versiones

**Para configurar la CDC mediante Binary Reader de**

1. Inicie sesión en la base de datos de origen de Amazon RDS para Oracle como usuario principal y ejecute los siguientes procedimientos almacenados para crear los directorios en el nivel de servidor.

   ```
   exec rdsadmin.rdsadmin_master_util.create_archivelog_dir;
   exec rdsadmin.rdsadmin_master_util.create_onlinelog_dir;
   ```

1. Conceda los siguientes privilegios a la cuenta de usuario de Oracle que se utiliza para acceder al punto de conexión de origen de Oracle.

   ```
   GRANT READ ON DIRECTORY ONLINELOG_DIR TO dms_user;
   GRANT READ ON DIRECTORY ARCHIVELOG_DIR TO dms_user;
   ```

1. Configure los atributos de conexión adicionales siguientes en el punto de conexión de origen de Oracle en Amazon RDS:
   + Para las versiones 11.2 y 12.1 de Oracle de RDS, configure lo siguiente.

     ```
     useLogminerReader=N;useBfile=Y;accessAlternateDirectly=false;useAlternateFolderForOnline=true;
     oraclePathPrefix=/rdsdbdata/db/{$DATABASE_NAME}_A/;usePathPrefix=/rdsdbdata/log/;replacePathPrefix=true;
     ```
   + Para las versiones 12.2, 18.0 y 19.0 de Oracle de RDS, configure lo siguiente.

     ```
     useLogminerReader=N;useBfile=Y;
     ```

**nota**  
Asegúrese de que no haya espacios en blanco tras el separador de punto y coma (;) para varias configuraciones de atributos, por ejemplo, `oneSetting;thenAnother`.

Para obtener más información sobre la configuración de una tarea de CDC, consulte [Configuración para CDC en una base de datos de origen de Oracle](#CHAP_Source.Oracle.CDC.Configuration).

### Uso de un Amazon RDS Oracle Standby (leer réplica) como fuente con Binary Reader for CDC en AWS DMS
<a name="CHAP_Source.Oracle.Amazon-Managed.StandBy"></a>

Compruebe los siguientes requisitos previos para utilizar Amazon RDS para Oracle Standby como origen cuando utilice Binary Reader para CDC en AWS DMS:
+ Utilice el usuario principal de Oracle para configurar Binary Reader.
+ Asegúrese de que AWS DMS actualmente solo admite el uso de Oracle Active Data Guard Standby.

Una vez hecho esto, utilice el siguiente procedimiento para utilizar RDS para Oracle Standby como origen cuando utilice Binary Reader para CDC.

**Configuración de RDS para Oracle Standby como origen al utilizar Binary Reader para CDC**

1. Inicie sesión en la instancia principal de RDS para Oracle como usuario principal.

1. Ejecute los siguientes procedimientos almacenados, tal como se documenta en la guía del usuario de Amazon RDS para crear los directorios en el nivel de servidor.

   ```
   exec rdsadmin.rdsadmin_master_util.create_archivelog_dir;
   exec rdsadmin.rdsadmin_master_util.create_onlinelog_dir;
   ```

1. Identifique los directorios creados en el paso 2.

   ```
   SELECT directory_name, directory_path FROM all_directories
   WHERE directory_name LIKE ( 'ARCHIVELOG_DIR_%' )
           OR directory_name LIKE ( 'ONLINELOG_DIR_%' )
   ```

   Por ejemplo, el código anterior muestra una lista de directorios como la siguiente.  
![\[Table showing directory names and their corresponding paths for archive and online logs.\]](http://docs.aws.amazon.com/es_es/dms/latest/userguide/images/datarep-rds-server-level-directories.png)

1. Conceda el privilegio `Read` de los directorios anteriores a la cuenta de usuario de Oracle que se utiliza para acceder a Oracle Standby.

   ```
   GRANT READ ON DIRECTORY ARCHIVELOG_DIR_A TO dms_user;
   GRANT READ ON DIRECTORY ARCHIVELOG_DIR_B TO dms_user;
   GRANT READ ON DIRECTORY ONLINELOG_DIR_A TO dms_user;
   GRANT READ ON DIRECTORY ONLINELOG_DIR_B TO dms_user;
   ```

1. Realice un cambio de registro de archivado en la instancia principal. De este modo, se asegura de que los cambios en `ALL_DIRECTORIES` también se transfieran a Oracle Standby.

1. Ejecute una consulta de `ALL_DIRECTORIES` en Oracle Standby para confirmar que se han aplicado los cambios.

1. Cree un punto final de origen para Oracle Standby mediante la consola AWS DMS de administración o AWS Command Line Interface (AWS CLI). Al crear el punto de conexión, especifique los siguientes atributos de conexión adicionales.

   ```
   useLogminerReader=N;useBfile=Y;archivedLogDestId=1;additionalArchivedLogDestId=2
   ```

1. Después de crear el punto final, utilice **Probar la conexión** del **punto final en la página Crear punto final** de la consola o el AWS CLI `test-connection` comando para comprobar que la conectividad está establecida.

## Limitaciones del uso de Oracle como fuente de AWS DMS
<a name="CHAP_Source.Oracle.Limitations"></a>

Se aplican las siguientes restricciones cuando se utiliza una base de datos de Oracle como origen para AWS DMS:
+ AWS DMS admite los tipos de datos de Oracle Extended en AWS DMS la versión 3.5.0 y versiones posteriores.
+ AWS DMS no admite nombres de objetos largos (más de 30 bytes).
+ AWS DMS no admite índices basados en funciones.
+ Si administra el registro suplementario y realiza transformaciones en cualquiera de las columnas, asegúrese de que el registro suplementario esté activado para todos los campos y columnas. Para obtener información sobre cómo configurar un registro suplementario, consulte los siguientes temas:
  + Para una base de datos de origen de Oracle autoadministrada, consulte [Configuración del registro complementario](#CHAP_Source.Oracle.Self-Managed.Configuration.SupplementalLogging).
  + Para obtener información sobre una base AWS de datos fuente de Oracle gestionada, consulte. [Configuración de una fuente de Oracle AWS gestionada por Oracle para AWS DMS](#CHAP_Source.Oracle.Amazon-Managed.Configuration)
+ AWS DMS no es compatible con la base de datos raíz de contenedores multiusuario (CDB\$1ROOT). Es compatible con un PDB que utilice Binary Reader.
+ AWS DMS no admite restricciones diferidas.
+ AWS DMS la versión 3.5.3 y superior es totalmente compatible con Secure. LOBs
+ AWS DMS admite la `rename table table-name to new-table-name` sintaxis de todas las versiones 11 y superiores de Oracle compatibles. Esta sintaxis no se admite para ninguna base de datos origen de la versión 10 de Oracle.
+ AWS DMS no reproduce los resultados de la sentencia `ALTER TABLE ADD column data_type DEFAULT default_value` DDL. En lugar de replicar `default_value` en el destino, establece la nueva columna en `NULL`.
+ Si utiliza la AWS DMS versión 3.4.7 o superior, para replicar los cambios que resultan de las operaciones de partición o subpartición, haga lo siguiente antes de iniciar una tarea de DMS.
  + Cree manualmente la estructura de tablas particionadas (DDL); 
  + Asegúrese de que DDL sea la misma tanto en el origen de Oracle como en el destino de Oracle; 
  + Establezca el atributo de conexión adicional `enableHomogenousPartitionOps=true`.

  Para obtener más información acerca de `enableHomogenousPartitionOps`, consulte [Configuración del punto final cuando se utiliza Oracle como fuente de AWS DMS](#CHAP_Source.Oracle.ConnectionAttrib). Además, tenga en cuenta que en las tareas FULL\$1CDC, DMS no replica los cambios en los datos capturados como parte de los cambios en caché. En ese caso de uso, vuelva a crear la estructura de la tabla en el destino de Oracle y vuelva a cargar las tablas en cuestión.

  Antes de la versión 3.4.7 AWS DMS :

  DMS no replica los cambios de datos resultantes de operaciones de partición o subpartición (`ADD`, `DROP`, `EXCHANGE` y `TRUNCATE`). Es posible que dichas actualizaciones provoquen los siguientes errores durante la replicación:
  + Para las operaciones `ADD`, las actualizaciones y eliminaciones de los datos agregados pueden generar una advertencia de «0 rows affected» (0 filas afectadas).
  + Para las operaciones `TRUNCATE` y `DROP`, las nuevas inserciones podrían generar errores de «duplicates» (duplicados).
  + `EXCHANGE` puede generar tanto una advertencia de «0 rows affected» (0 filas afectadas) «0 filas afectadas» como errores de «duplicates» (duplicados).

  Para replicar los cambios resultantes de operaciones de partición o subpartición, vuelva a cargar las tablas en cuestión. Después de agregar una nueva partición vacía, las operaciones en la partición recién agregada se replican en el destino normalmente.
+ AWS DMS las versiones anteriores a la 3.4 no admiten los cambios de datos en el destino que se produzcan al ejecutar la `CREATE TABLE AS` declaración en la fuente. Sin embargo, la nueva tabla se crea en el destino.
+ AWS DMS no captura los cambios realizados por el `DBMS_REDEFINITION` paquete de Oracle, por ejemplo, los metadatos de la tabla y el `OBJECT_ID` campo.
+ Cuando el modo LOB de tamaño limitado está activado, BLOB/CLOB las columnas vacías de la fuente de Oracle se replican como valores NULOS. Cuando el modo de LOB completo está activado, se replican como una cadena vacía (' ').
+ Al capturar los cambios con Oracle 11 LogMiner, se pierde una actualización de una columna CLOB con una longitud de cadena superior a 1982 y el destino no se actualiza.
+ Durante la captura de datos de cambios (CDC), AWS DMS no admite actualizaciones por lotes en columnas numéricas definidas como clave principal.
+ AWS DMS no admite determinados `UPDATE` comandos. El siguiente ejemplo es un comando `UPDATE` no admitido.

  ```
  UPDATE TEST_TABLE SET KEY=KEY+1;
  ```

  Aquí, `TEST_TABLE` es el nombre de la tabla y `KEY` es una columna numérica definida como una clave principal.
+ AWS DMS no admite el modo LOB completo para cargar columnas LONG y LONG RAW. En su lugar, puede utilizar el modo de LOB limitado para migrar estos tipos de datos a un destino de Oracle. En el modo LOB limitado, AWS DMS trunca a 64 KB los datos que haya configurado como columnas LONG o LONG RAW de más de 64 KB.
+ AWS DMS no admite el modo LOB completo para cargar columnas XMLTYPE. En su lugar, puede utilizar el modo de LOB limitado para migrar columnas XMLTYPE a un destino de Oracle. En el modo de LOB limitado, DMS trunca los datos que superen la variable “Tamaño máximo de LOB” definida por el usuario. El valor máximo recomendado para el “Tamaño máximo de LOB” es de 100 MB.
+ AWS DMS no replica las tablas cuyos nombres contengan apóstrofes.
+ AWS DMS apoya a los CDC desde puntos de vista materializados. Sin embargo, DMS no es compatible con CDC desde ningún otro punto de vista.
+ AWS DMS no admite los CDC para tablas organizadas por índices con un segmento adicional.
+ AWS DMS no admite la `Drop Partition` operación para tablas particionadas por referencia con el valor establecido en. `enableHomogenousPartitionOps` `true`
+ Cuando se utiliza Oracle LogMiner para acceder a los registros de redo, AWS DMS tiene las siguientes limitaciones:
  + Solo para Oracle 12, AWS DMS no replica ningún cambio en las columnas LOB.
  + AWS DMS no admite transacciones de XA en la replicación cuando se utiliza Oracle LogMiner.
  + Oracle LogMiner no admite conexiones a una base de datos conectable (PDB). Para conectarse a un PDB, acceda a los registros REDO mediante Binary Reader.
  + No se admiten las operaciones SHRINK SPACE.
+ Cuando utiliza Binary Reader, AWS DMS tiene estas limitaciones:
  + No admite clústeres de tablas.
  + Solo admite las operaciones `SHRINK SPACE` en el nivel de tabla. Este nivel incluye la tabla completa, las particiones y las subparticiones.
  + No admite cambios en las tablas organizadas por índices con compresión de claves.
  + No admite la implementación de registros redo en línea en dispositivos sin procesar.
  + Binary Reader solo admite TDE para las bases de datos de Oracle autoadministradas, ya que RDS para Oracle no admite la recuperación de contraseñas del wallet para las claves de cifrado de TDE.
+ AWS DMS no admite conexiones a una fuente de Amazon RDS Oracle mediante un proxy de Oracle Automatic Storage Management (ASM).
+ AWS DMS no admite columnas virtuales. 
+ AWS DMS no admite el tipo de `ROWID` datos ni las vistas materializadas basadas en una columna ROWID.

  AWS DMS es compatible parcialmente con Oracle Materialized Views. Para cargas completas, DMS puede hacer una copia de carga completa de una vista materializada de Oracle. DMS copia la vista materializada como tabla base en el sistema de destino e ignora las columnas ROWID de la vista materializada. Para la replicación continua (CDC), DMS intenta replicar los cambios en los datos de la vista materializada, pero es posible que los resultados no sean los ideales. En concreto, si la vista materializada se actualiza por completo, DMS replica las eliminaciones individuales de todas las filas, seguidas de las inserciones individuales de todas las filas. Se trata de un ejercicio que consume muchos recursos y podría funcionar mal en vistas materializadas con un gran número de filas. Para una replicación continua en la que las vistas materializadas se actualizan rápidamente, DMS intenta procesar y replicar los cambios de datos de actualización rápida. En cualquier caso, DMS omite las columnas ROWID de la vista materializada.
+ AWS DMS no carga ni captura tablas temporales globales.
+ Para los destinos de S3 que utilizan la replicación, habilite el registro adicional en cada columna para que las actualizaciones de las filas de origen puedan capturar todos los valores de las columnas. A continuación, se muestra un ejemplo: `alter table yourtablename add supplemental log data (all) columns;`.
+ La actualización de una fila con una clave única compuesta que contiene `null` no se puede replicar en el destino.
+ AWS DMS no admite el uso de varias claves de cifrado TDE de Oracle en el mismo punto final de origen. Cada punto de conexión solo puede tener un atributo para el nombre de clave de cifrado de TDE “`securityDbEncryptionName`” y una contraseña de TDE para esta clave.
+ Al replicar desde Amazon RDS for Oracle, solo se admite TDE con espacios de tablas cifrados y mediante Oracle. LogMiner
+ AWS DMS no admite varias operaciones de cambio de nombre de tablas en rápida sucesión.
+ Cuando se utiliza Oracle 19.0 como fuente, AWS DMS no admite las siguientes funciones:
  + Redirección de DML de Data-Guard
  + Tablas híbridas particionadas
  + Cuentas de Oracle exclusivas de esquemas
+ AWS DMS no admite la migración de tablas o vistas del tipo `BIN$` o`DR$`.
+ A partir de Oracle 18.x, no AWS DMS admite la captura de datos de cambios (CDC) desde Oracle Express Edition (Oracle Database XE).
+ Al migrar datos de una columna CHAR, DMS trunca los espacios finales. 
+ AWS DMS no admite la replicación desde contenedores de aplicaciones.
+ AWS DMS no admite la ejecución de bases de datos Oracle Flashback y puntos de restauración, ya que estas operaciones afectan a la coherencia de los archivos Oracle Redo Log.
+ Antes de la AWS DMS versión 3.5.3, el `INSERT` procedimiento de carga directa con la opción de ejecución paralela no se admitía en los siguientes casos:
  + Tablas sin comprimir con más de 255 columnas
  + El tamaño de la fila supera los 8 K
  + Tablas de Exadata HCC
  + Base de datos que se ejecuta en la plataforma Big Endian
+ Una tabla de origen sin clave principal ni única requiere que el registro complementario ALL COLUMN esté habilitado. Crea más actividades de registro REDO y puede aumentar la latencia de DMS CDC.
+ AWS DMS no migra los datos de las columnas invisibles de la base de datos de origen. Para incluir estas columnas en el ámbito de la migración, use la instrucción `ALTER TABLE` para hacer visibles estas columnas.
+ En todas las versiones de Oracle, AWS DMS no replica el resultado de `UPDATE` las operaciones en `XMLTYPE` las columnas LOB.
+ AWS DMS no admite la replicación desde tablas con restricciones de validez temporal.
+ Si la fuente de Oracle deja de estar disponible durante una tarea de carga completa, AWS DMS podría marcar la tarea como completada tras varios intentos de reconexión, aunque la migración de datos siga incompleta. En este escenario, las tablas de destino solo contienen los registros migrados antes de la pérdida de conexión, lo que podría crear incoherencias de datos entre los sistemas de origen y de destino. Para garantizar la integridad de los datos, debe reiniciar completamente la tarea de carga completa o volver a cargar las tablas específicas afectadas por la interrupción de la conexión.

## Compatibilidad con SSL para un punto de enlace de Oracle
<a name="CHAP_Security.SSL.Oracle"></a>

AWS DMS Los puntos de conexión de Oracle admiten SSL V3 para los modos SSL `none` y `verify-ca` SSL. Para utilizar SSL con un punto de enlace de Oracle, cargue el wallet de Oracle para el punto de enlace en lugar de archivos de certificado .pem. 

**Topics**
+ [Uso de un certificado existente para Oracle SSL](#CHAP_Security.SSL.Oracle.Existing)
+ [Uso de un certificado autofirmado para Oracle SSL](#CHAP_Security.SSL.Oracle.SelfSigned)

### Uso de un certificado existente para Oracle SSL
<a name="CHAP_Security.SSL.Oracle.Existing"></a>

Para utilizar una instalación de cliente Oracle existente para crear el archivo wallet de Oracle desde el archivo de certificado CA, siga los pasos que se indican a continuación.

**Para utilizar una instalación de cliente de Oracle existente para Oracle SSL con AWS DMS**

1. Establezca la variable del sistema `ORACLE_HOME` en la ubicación del directorio `dbhome_1` ejecutando el siguiente comando.

   ```
   prompt>export ORACLE_HOME=/home/user/app/user/product/12.1.0/dbhome_1                        
   ```

1. Adjunte `$ORACLE_HOME/lib` a la variable del sistema `LD_LIBRARY_PATH`.

   ```
   prompt>export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$ORACLE_HOME/lib                        
   ```

1. Cree un directorio para el wallet de Oracle en `$ORACLE_HOME/ssl_wallet`.

   ```
   prompt>mkdir $ORACLE_HOME/ssl_wallet
   ```

1. Coloque el archivo `.pem` del certificado CA en el directorio `ssl_wallet`. Si utiliza Amazon RDS, puede descargar el archivo del certificado de entidad de certificación raíz `rds-ca-2015-root.pem` alojado por Amazon RDS. Para obtener más información sobre la descarga de este archivo, consulte [Uso SSL/TLS para cifrar una conexión a una instancia](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/UsingWithRDS.SSL.html) de base de datos en la Guía del *usuario de Amazon RDS*.

1. Si su certificado CA contiene más de un archivo PEM (como un paquete global o regional de Amazon RDS), debe dividirlo en archivos separados y añadirlos a la cartera de Oracle mediante el siguiente script bash. Este script requiere que se introduzcan dos parámetros: la ruta al certificado CA y la ruta a la carpeta de la cartera de Oracle creada anteriormente.

   ```
   #!/usr/bin/env bash
   
   certnum=$(grep -c BEGIN <(cat $1))
   
   cnt=0
   temp_cert=""
   while read line
   do
   if [ -n "$temp_cert" -a "$line" == "-----BEGIN CERTIFICATE-----" ]
   then
   cnt=$(expr $cnt + 1)
   printf "\rImporting certificate # $cnt of $certnum"
   orapki wallet add -wallet "$2" -trusted_cert -cert <(echo -n "${temp_cert}") -auto_login_only 1>/dev/null 2>/dev/null
   temp_cert=""
   fi
   temp_cert+="$line"$'\n'
   done < <(cat $1)
   
   cnt=$(expr $cnt + 1)
   printf "\rImporting certificate # $cnt of $certnum"
   orapki wallet add -wallet "$2" -trusted_cert -cert <(echo -n "${temp_cert}") -auto_login_only 1>/dev/null 2>/dev/null
   echo ""
   ```

Cuando haya completado los pasos anteriores, podrá importar el archivo wallet con la llamada a la API `ImportCertificate` especificando el parámetro certificate-wallet. A continuación, podrá utilizar el certificado wallet importado al seleccionar `verify-ca` como el modo SSL al crear o modificar su punto de enlace de Oracle.

**nota**  
 Los monederos de Oracle son archivos binarios. AWS DMS acepta estos archivos tal cual. 

### Uso de un certificado autofirmado para Oracle SSL
<a name="CHAP_Security.SSL.Oracle.SelfSigned"></a>

Para utilizar un certificado autofirmado para Oracle SSL, siga los pasos siguientes, suponiendo que la contraseña de wallet de Oracle sea de `oracle123`.

**Para utilizar un certificado autofirmado para Oracle SSL con AWS DMS**

1. Cree un directorio que utilizará para trabajar con el certificado autofirmado.

   ```
   mkdir -p /u01/app/oracle/self_signed_cert
   ```

1. Cambie al directorio que ha creado en el paso anterior.

   ```
   cd /u01/app/oracle/self_signed_cert
   ```

1. Cree una clave raíz.

   ```
   openssl genrsa -out self-rootCA.key 2048
   ```

1. Firme usted mismo un certificado raíz con la clave raíz que ha creado en el paso anterior.

   ```
   openssl req -x509 -new -nodes -key self-rootCA.key 
           -sha256 -days 3650 -out self-rootCA.pem
   ```

   Utilice parámetros de entrada como los siguientes.
   + `Country Name (2 letter code) [XX]`, por ejemplo: `AU`
   + `State or Province Name (full name) []`, por ejemplo: `NSW`
   + `Locality Name (e.g., city) [Default City]`, por ejemplo: `Sydney`
   + `Organization Name (e.g., company) [Default Company Ltd]`, por ejemplo: `AmazonWebService`
   + `Organizational Unit Name (e.g., section) []`, por ejemplo: `DBeng`
   + `Common Name (e.g., your name or your server's hostname) []`, por ejemplo: `aws`
   + `Email Address []`, por ejemplo: abcd.efgh@amazonwebservice.com

1. Cree un directorio wallet de Oracle para la base de datos de Oracle.

   ```
   mkdir -p /u01/app/oracle/wallet
   ```

1. Cree un nuevo wallet de Oracle.

   ```
   orapki wallet create -wallet "/u01/app/oracle/wallet" -pwd oracle123 -auto_login_local
   ```

1. Añada el certificado raíz al wallet de Oracle.

   ```
   orapki wallet add -wallet "/u01/app/oracle/wallet" -pwd oracle123 -trusted_cert 
   -cert /u01/app/oracle/self_signed_cert/self-rootCA.pem
   ```

1. Enumere el contenido del wallet de Oracle. La lista debe incluir el certificado raíz. 

   ```
   orapki wallet display -wallet /u01/app/oracle/wallet -pwd oracle123
   ```

   Por ejemplo, es posible que tenga un aspecto similar al siguiente.

   ```
   Requested Certificates:
   User Certificates:
   Trusted Certificates:
   Subject:        CN=aws,OU=DBeng,O= AmazonWebService,L=Sydney,ST=NSW,C=AU
   ```

1. Genere la solicitud de firma del certificado (CSR) mediante la utilidad ORAPKI.

   ```
   orapki wallet add -wallet "/u01/app/oracle/wallet" -pwd oracle123 
   -dn "CN=aws" -keysize 2048 -sign_alg sha256
   ```

1. Ejecute el comando siguiente.

   ```
   openssl pkcs12 -in /u01/app/oracle/wallet/ewallet.p12 -nodes -out /u01/app/oracle/wallet/nonoracle_wallet.pem
   ```

   Esto tiene una salida similar a la siguiente.

   ```
   Enter Import Password:
   MAC verified OK
   Warning unsupported bag type: secretBag
   ```

1. Inserte 'dms' como nombre común.

   ```
   openssl req -new -key /u01/app/oracle/wallet/nonoracle_wallet.pem -out certdms.csr
   ```

   Utilice parámetros de entrada como los siguientes.
   + `Country Name (2 letter code) [XX]`, por ejemplo: `AU`
   + `State or Province Name (full name) []`, por ejemplo: `NSW`
   + `Locality Name (e.g., city) [Default City]`, por ejemplo: `Sydney`
   + `Organization Name (e.g., company) [Default Company Ltd]`, por ejemplo: `AmazonWebService`
   + `Organizational Unit Name (e.g., section) []`, por ejemplo: `aws`
   + `Common Name (e.g., your name or your server's hostname) []`, por ejemplo: `aws`
   + `Email Address []`, por ejemplo: abcd.efgh@amazonwebservice.com

   Asegúrese de que no es lo mismo que en el paso 4. Puede hacerlo, por ejemplo, cambiando el nombre de la unidad organizativa por un nombre diferente, como se muestra.

   Ingrese los siguientes atributos adicionales para enviarlos con la solicitud de certificado.
   + `A challenge password []`, por ejemplo: `oracle123`
   + `An optional company name []`, por ejemplo: `aws`

1. Obtenga la firma del certificado.

   ```
   openssl req -noout -text -in certdms.csr | grep -i signature
   ```

   La clave de firma de esta publicación es `sha256WithRSAEncryption`.

1. Utilice el siguiente comando para generar el archivo de certificado (`.crt`).

   ```
   openssl x509 -req -in certdms.csr -CA self-rootCA.pem -CAkey self-rootCA.key 
   -CAcreateserial -out certdms.crt -days 365 -sha256
   ```

   Esto muestra una salida similar a la siguiente.

   ```
   Signature ok
   subject=/C=AU/ST=NSW/L=Sydney/O=awsweb/OU=DBeng/CN=aws
   Getting CA Private Key
   ```

1. Añada el certificado al wallet.

   ```
   orapki wallet add -wallet /u01/app/oracle/wallet -pwd oracle123 -user_cert -cert certdms.crt
   ```

1. Ver wallet. Debería tener dos entradas. Consulte el siguiente código.

   ```
   orapki wallet display -wallet /u01/app/oracle/wallet -pwd oracle123
   ```

1. Configure el archivo `sqlnet.ora` (`$ORACLE_HOME/network/admin/sqlnet.ora`).

   ```
   WALLET_LOCATION =
      (SOURCE =
        (METHOD = FILE)
        (METHOD_DATA =
          (DIRECTORY = /u01/app/oracle/wallet/)
        )
      ) 
   
   SQLNET.AUTHENTICATION_SERVICES = (NONE)
   SSL_VERSION = 1.0
   SSL_CLIENT_AUTHENTICATION = FALSE
   SSL_CIPHER_SUITES = (SSL_RSA_WITH_AES_256_CBC_SHA)
   ```

1. Detenga el listener de Oracle.

   ```
   lsnrctl stop
   ```

1. Añada entradas para SSL en el archivo `listener.ora` (`$ORACLE_HOME/network/admin/listener.ora`).

   ```
   SSL_CLIENT_AUTHENTICATION = FALSE
   WALLET_LOCATION =
     (SOURCE =
       (METHOD = FILE)
       (METHOD_DATA =
         (DIRECTORY = /u01/app/oracle/wallet/)
       )
     )
   
   SID_LIST_LISTENER =
    (SID_LIST =
     (SID_DESC =
      (GLOBAL_DBNAME = SID)
      (ORACLE_HOME = ORACLE_HOME)
      (SID_NAME = SID)
     )
    )
   
   LISTENER =
     (DESCRIPTION_LIST =
       (DESCRIPTION =
         (ADDRESS = (PROTOCOL = TCP)(HOST = localhost.localdomain)(PORT = 1521))
         (ADDRESS = (PROTOCOL = TCPS)(HOST = localhost.localdomain)(PORT = 1522))
         (ADDRESS = (PROTOCOL = IPC)(KEY = EXTPROC1521))
       )
     )
   ```

1. Configure el archivo `tnsnames.ora` (`$ORACLE_HOME/network/admin/tnsnames.ora`).

   ```
   <SID>=
   (DESCRIPTION=
           (ADDRESS_LIST = 
                   (ADDRESS=(PROTOCOL = TCP)(HOST = localhost.localdomain)(PORT = 1521))
           )
           (CONNECT_DATA =
                   (SERVER = DEDICATED)
                   (SERVICE_NAME = <SID>)
           )
   )
   
   <SID>_ssl=
   (DESCRIPTION=
           (ADDRESS_LIST = 
                   (ADDRESS=(PROTOCOL = TCPS)(HOST = localhost.localdomain)(PORT = 1522))
           )
           (CONNECT_DATA =
                   (SERVER = DEDICATED)
                   (SERVICE_NAME = <SID>)
           )
   )
   ```

1. Reinicie el listener de Oracle.

   ```
   lsnrctl start
   ```

1. Muestre el estado de listener de Oracle.

   ```
   lsnrctl status
   ```

1. Pruebe la conexión SSL a la base de datos desde localhost utilizando sqlplus y la entrada tnsnames SSL.

   ```
   sqlplus -L ORACLE_USER@SID_ssl
   ```

1. Compruebe que se ha conectado correctamente mediante SSL.

   ```
   SELECT SYS_CONTEXT('USERENV', 'network_protocol') FROM DUAL;
   
   SYS_CONTEXT('USERENV','NETWORK_PROTOCOL')
   --------------------------------------------------------------------------------
   tcps
   ```

1. Cambie de directorio al directorio con el certificado autofirmado.

   ```
   cd /u01/app/oracle/self_signed_cert
   ```

1. Cree una nueva cartera de cliente de Oracle AWS DMS para usarla.

   ```
   orapki wallet create -wallet ./ -auto_login_only
   ```

1. Añada el certificado raíz autofirmado al wallet de Oracle.

   ```
   orapki wallet add -wallet ./ -trusted_cert -cert self-rootCA.pem -auto_login_only
   ```

1. Enumere el contenido de la cartera de Oracle AWS DMS para su uso. La lista debe incluir el certificado raíz autofirmado.

   ```
   orapki wallet display -wallet ./
   ```

   Esto tiene una salida similar a la siguiente.

   ```
   Trusted Certificates:
   Subject:        CN=aws,OU=DBeng,O=AmazonWebService,L=Sydney,ST=NSW,C=AU
   ```

1. Cargue la cartera de Oracle que acaba de crear AWS DMS.

## Métodos de cifrado compatibles para utilizar Oracle como fuente de AWS DMS
<a name="CHAP_Source.Oracle.Encryption"></a>

En la siguiente tabla, encontrará los métodos de cifrado de datos transparente (TDE) que se AWS DMS admiten cuando se trabaja con una base de datos fuente de Oracle. 


| Método de acceso a registros REDO | Espacio de tabla de TDE | Columna de TDE | 
| --- | --- | --- | 
| Oracle LogMiner | Sí | Sí | 
| Binary Reader | Sí | Sí | 

AWS DMS admite Oracle TDE cuando se utiliza Binary Reader, tanto a nivel de columna como a nivel de espacio de tabla. Para utilizar el cifrado TDE AWS DMS, identifique primero la ubicación de la cartera de Oracle en la que se almacenan la clave de cifrado TDE y la contraseña de TDE. A continuación, identifique la clave de cifrado de TDE y la contraseña correctas para el punto de conexión de origen de Oracle.

**Identificación y especificación de la clave y la contraseña de cifrado para el cifrado de TDE**

1. Ejecute la siguiente consulta para encontrar el wallet de cifrado de Oracle en el host de la base de datos de Oracle.

   ```
   SQL> SELECT WRL_PARAMETER FROM V$ENCRYPTION_WALLET;
   
   WRL_PARAMETER
   --------------------------------------------------------------------------------
   /u01/oracle/product/12.2.0/dbhome_1/data/wallet/
   ```

   Aquí, `/u01/oracle/product/12.2.0/dbhome_1/data/wallet/` es la ubicación del wallet.

1. Para obtener el ID de clave maestra de un origen CDB o un origen que no sea CDB, haga lo siguiente:

   1. Para un origen que no sea CDB, ejecute la siguiente consulta para obtener el ID de la clave de cifrado maestra:

      ```
      SQL>  select rownum, key_id, activation_time from v$encryption_keys;
      
      ROWNUM KEY_ID                                                 ACTIVATION_TIME
      ------ ------------------------------------------------------ ---------------
           1 AeKask0XZU+NvysflCYBEVwAAAAAAAAAAAAAAAAAAAAAAAAAAAAA   04-SEP-24 10.20.56.605200 PM +00:00
           2 AV7WU9uhoU8rv8daE/HNnSwAAAAAAAAAAAAAAAAAAAAAAAAAAAAA   10-AUG-21 07.52.03.966362 PM +00:00
           3 AckpoJ/f+k8xvzJ+gSuoVH4AAAAAAAAAAAAAAAAAAAAAAAAAAAAA   14-SEP-20 09.26.29.048870 PM +00:00
      ```

      El tiempo de activación es útil si tiene previsto iniciar la CDC desde un punto del pasado. Por ejemplo, con los resultados anteriores, puede iniciar la CDC en algún momento entre el 10 de agosto de 2021 a las 19:52:03 y el 14 de septiembre de 2020 a las 21:26:29 con la clave maestra de ROWNUM 2. Cuando la tarea alcance la repetición generada el 14 de septiembre de 2020 a las 21:26:29, o después de esa fecha, se genera un error, deberá modificar el punto de conexión de origen, proporcionar el identificador de clave maestra en ROWNUM 3 y, a continuación, reanudar la tarea.

   1. En el caso del origen de CDB, DMS exige la clave de cifrado maestra CDB\$1ROOT. Conéctese a CDB\$1ROOT y ejecute la siguiente consulta:

      ```
      SQL> select rownum, key_id, activation_time from v$encryption_keys where con_id = 1;
      
      ROWNUM KEY_ID                                               ACTIVATION_TIME
      ------ ---------------------------------------------------- -----------------------------------
           1 Aa2E/Vwb5U+zv5hCncS5ErMAAAAAAAAAAAAAAAAAAAAAAAAAAAAA 29-AUG-24 12.51.19.699060 AM +00:00
      ```

1. Desde la línea de comandos, muestre las entradas del wallet de cifrado en el host de la base de datos de Oracle de origen.

   ```
   $ mkstore -wrl /u01/oracle/product/12.2.0/dbhome_1/data/wallet/ -list
   Oracle Secret Store entries:
   ORACLE.SECURITY.DB.ENCRYPTION.AWGDC9glSk8Xv+3bVveiVSgAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
   ORACLE.SECURITY.DB.ENCRYPTION.AY1mRA8OXU9Qvzo3idU4OH4AAAAAAAAAAAAAAAAAAAAAAAAAAAAA
   ORACLE.SECURITY.DB.ENCRYPTION.MASTERKEY
   ORACLE.SECURITY.ID.ENCRYPTION.
   ORACLE.SECURITY.KB.ENCRYPTION.
   ORACLE.SECURITY.KM.ENCRYPTION.AY1mRA8OXU9Qvzo3idU4OH4AAAAAAAAAAAAAAAAAAAAAAAAAAAAA
   ```

   Busque la entrada que contiene el ID de clave principal que encontró en el paso 2 (`AWGDC9glSk8Xv+3bVveiVSg`). Esta entrada es el nombre de la clave de cifrado de TDE.

1. Consulte los detalles de la entrada que encontró en el paso anterior.

   ```
   $ mkstore -wrl /u01/oracle/product/12.2.0/dbhome_1/data/wallet/ -viewEntry ORACLE.SECURITY.DB.ENCRYPTION.AWGDC9glSk8Xv+3bVveiVSgAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
   Oracle Secret Store Tool : Version 12.2.0.1.0
   Copyright (c) 2004, 2016, Oracle and/or its affiliates. All rights reserved.
   Enter wallet password:
   ORACLE.SECURITY.DB.ENCRYPTION.AWGDC9glSk8Xv+3bVveiVSgAAAAAAAAAAAAAAAAAAAAAAAAAAAAA = AEMAASAASGYs0phWHfNt9J5mEMkkegGFiD4LLfQszDojgDzbfoYDEACv0x3pJC+UGD/PdtE2jLIcBQcAeHgJChQGLA==
   ```

   Ingrese la contraseña del wallet para ver el resultado.

   Aquí, el valor a la derecha de `'='` es la contraseña de TDE.

1. Especifique el nombre de la clave de cifrado de TDE para el punto de conexión de origen de Oracle configurando el atributo de conexión `securityDbEncryptionName` adicional.

   ```
   securityDbEncryptionName=ORACLE.SECURITY.DB.ENCRYPTION.AWGDC9glSk8Xv+3bVveiVSgAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
   ```

1. Proporcione la contraseña de TDE asociada a esta clave en la consola como parte del valor de la **contraseña** del origen de Oracle. Utilice el siguiente orden para formatear los valores de contraseña separados por comas y terminados por el valor de la contraseña de TDE.

   ```
   Oracle_db_password,ASM_Password,AEMAASAASGYs0phWHfNt9J5mEMkkegGFiD4LLfQszDojgDzbfoYDEACv0x3pJC+UGD/PdtE2jLIcBQcAeHgJChQGLA==
   ```

   Especifique los valores de contraseña en este orden independientemente de la configuración de la base de datos de Oracle. Por ejemplo, si utiliza TDE pero la base de datos de Oracle no utiliza ASM, especifique los valores de contraseña en el orden siguiente, separados por comas.

   ```
   Oracle_db_password,,AEMAASAASGYs0phWHfNt9J5mEMkkegGFiD4LLfQszDojgDzbfoYDEACv0x3pJC+UGD/PdtE2jLIcBQcAeHgJChQGLA==
   ```

Si las credenciales de TDE que especifique son incorrectas, la tarea de AWS DMS migración no fallará. Sin embargo, la tarea tampoco lee ni aplica los cambios de replicación en curso a la base de datos de destino. Tras iniciar la tarea, monitoree las **estadísticas de la tabla** en la página de tareas de migración de la consola para asegurarse de que los cambios se replican.

Si DBA cambia los valores de las credenciales de TDE de la base de datos de Oracle mientras la tarea está en ejecución, la tarea produce un error. El mensaje de error contiene el nombre de la nueva clave de cifrado de TDE. Para especificar nuevos valores y reiniciar la tarea, utilice el procedimiento anterior.

**importante**  
No puede manipular un wallet de TDE creado en una ubicación de Automatic Storage Management (ASM) de Oracle porque los comandos del nivel del sistema operativo como `cp`, `mv`, `orapki` y `mkstore` corrompen los archivos del wallet almacenados en una ubicación de ASM. Esta restricción es específica de los archivos del wallet de TDE almacenados solo en una ubicación de ASM, pero no de los archivos del wallet de TDE almacenados en un directorio local del sistema operativo.  
Para manipular un wallet de TDE almacenado en ASM con comandos de nivel de sistema operativo, cree un almacén de claves local y combine el almacén de claves de ASM con el almacén de claves local de la siguiente manera:   
Cree un almacén de claves local.  

   ```
   ADMINISTER KEY MANAGEMENT create keystore file system wallet location identified by wallet password;
   ```
Combine el almacén de claves de ASM con el almacén de claves local.  

   ```
   ADMINISTER KEY MANAGEMENT merge keystore ASM wallet location identified by wallet password into existing keystore file system wallet location identified by wallet password with backup;
   ```
A continuación, para mostrar las entradas de wallet de cifrado y la contraseña de TDE, ejecute los pasos 3 y 4 en el almacén de claves local.

## Métodos de compresión compatibles para utilizar Oracle como fuente de AWS DMS
<a name="CHAP_Source.Oracle.Compression"></a>

En la siguiente tabla, puede encontrar los métodos de compresión AWS DMS compatibles cuando se trabaja con una base de datos fuente de Oracle. Como se muestra en la tabla, el soporte de compresión depende tanto de la versión de la base de datos de Oracle como de si el DMS está configurado para utilizar Oracle LogMiner para acceder a los redo logs.


| Versión | Basic | OLTP |  HCC (de Oracle 11g R2 o más reciente)  | Otros | 
| --- | --- | --- | --- | --- | 
| Oracle 10 | No | N/A | N/A | No | 
| Oracle 11 o más reciente: Oracle LogMiner | Sí | Sí | Sí  | Sí, cualquier método de compresión compatible con Oracle LogMiner. | 
| Oracle 11 o más reciente: Binary Reader | Sí | Sí | Sí: para obtener más información, consulte la siguiente nota. | Sí | 

**nota**  
Cuando el punto de enlace de origen de Oracle está configurado para utilizar Binary Reader, el nivel de consulta bajo del método de compresión HCC tan solo se admite para las tareas de carga completa.

## Replicación de tablas anidadas utilizando Oracle como fuente de AWS DMS
<a name="CHAP_Source.Oracle.NestedTables"></a>

AWS DMS admite la replicación de tablas de Oracle que contienen columnas que son tablas anidadas o de tipos definidos. Para habilitar esta funcionalidad, agregue el valor de atributo de conexión adicional siguiente al punto de conexión de origen de Oracle.

```
allowSelectNestedTables=true;
```

AWS DMS crea las tablas de destino a partir de las tablas anidadas de Oracle como tablas principales y secundarias normales en el destino sin una restricción única. Para acceder a los datos correctos en el destino, una las tablas principal y secundaria. Para ello, primero cree manualmente un índice no único en la columna `NESTED_TABLE_ID` de la tabla secundaria de destino. A continuación, puede utilizar la columna `NESTED_TABLE_ID` de la cláusula de unión `ON` junto con la columna principal que corresponde al nombre de la tabla secundaria. Además, la creación de un índice de este tipo mejora el rendimiento cuando se actualizan o eliminan los datos de la tabla secundaria de destino. AWS DMS Para ver un ejemplo, consulta [Ejemplo de unión para tablas principal y secundaria en el destino](#CHAP_Source.Oracle.NestedTables.JoinExample).

Se recomienda configurar la tarea de modo que se detenga después de finalizar una carga completa. A continuación, cree estos índices no únicos para todas las tablas secundarias replicadas en el destino y reanude la tarea.

Si una tabla anidada capturada se añade a una tabla principal existente (capturada o no capturada), la AWS DMS gestiona correctamente. Sin embargo, no se crea el índice no único de la tabla de destino correspondiente. En este caso, si la tabla secundaria de destino se vuelve extremadamente grande, el rendimiento puede verse afectado. Si esto sucede, le recomendamos que detenga la tarea, cree el índice y, a continuación, reanude la tarea.

Después de replicar las tablas anidadas en el destino, haga que el DBA ejecute una unión en las tablas principal y secundaria correspondientes para aplanar los datos.

### Requisitos previos para la replicación de tablas anidadas de Oracle como origen
<a name="CHAP_Source.Oracle.NestedTables.Prerequisites"></a>

Asegúrese de replicar las tablas principales para todas las tablas anidadas replicadas. Incluya tanto las tablas principales (las tablas que contienen la columna de la tabla anidada) como las tablas secundarias (es decir, anidadas) en las AWS DMS asignaciones de tablas.

### Tipos de tablas anidadas de Oracle admitidos como origen
<a name="CHAP_Source.Oracle.NestedTables.Types"></a>

AWS DMS admite los siguientes tipos de tablas anidadas de Oracle como fuente:
+ Tipo de datos:
+ Objeto definido por el usuario

### Limitaciones del AWS DMS soporte de tablas anidadas de Oracle como fuente
<a name="CHAP_Source.Oracle.NestedTables.Limitations"></a>

AWS DMS tiene las siguientes limitaciones a la hora de admitir tablas anidadas de Oracle como fuente:
+ AWS DMS solo admite un nivel de anidación de tablas.
+ AWS DMS el mapeo de tablas no comprueba que la tabla o tablas principales y secundarias estén seleccionadas para la replicación. Es decir, es posible seleccionar una tabla principal sin una tabla secundaria y viceversa.

### ¿Cómo AWS DMS se replican las tablas anidadas de Oracle como fuente
<a name="CHAP_Source.Oracle.NestedTables.HowReplicated"></a>

AWS DMS replica las tablas principales y anidadas en el destino de la siguiente manera:
+ AWS DMS crea la tabla principal idéntica a la fuente. A continuación, define la columna anidada en la principal como `RAW(16)` e incluye una referencia a las tablas anidadas de la principal en la columna `NESTED_TABLE_ID`.
+ AWS DMS crea la tabla secundaria idéntica a la fuente anidada, pero con una columna adicional denominada`NESTED_TABLE_ID`. Esta columna tiene el mismo tipo y valor que la columna anidada principal correspondiente y tiene el mismo significado.

### Ejemplo de unión para tablas principal y secundaria en el destino
<a name="CHAP_Source.Oracle.NestedTables.JoinExample"></a>

Para aplanar la tabla principal, ejecute una unión de las tablas principal y secundaria, como se muestra en el siguiente ejemplo:

1. Cree la tabla de `Type`.

   ```
   CREATE OR REPLACE TYPE NESTED_TEST_T AS TABLE OF VARCHAR(50);
   ```

1. Cree la tabla principal con una columna de tipo `NESTED_TEST_T`, tal y como se ha definido antes.

   ```
   CREATE TABLE NESTED_PARENT_TEST (ID NUMBER(10,0) PRIMARY KEY, NAME NESTED_TEST_T) NESTED TABLE NAME STORE AS NAME_KEY;
   ```

1. Aplane la tabla `NESTED_PARENT_TEST` mediante una unión con la tabla secundaria `NAME_KEY`, donde `CHILD.NESTED_TABLE_ID` coincide con `PARENT.NAME`.

   ```
   SELECT … FROM NESTED_PARENT_TEST PARENT, NAME_KEY CHILD WHERE CHILD.NESTED_
   TABLE_ID = PARENT.NAME;
   ```

## Almacenar REDO en Oracle ASM cuando se utiliza Oracle como fuente de AWS DMS
<a name="CHAP_Source.Oracle.REDOonASM"></a>

Para orígenes de Oracle con una alta generación de REDO, almacenar REDO en Oracle ASM puede beneficiar el rendimiento, especialmente en una configuración de RAC, ya que se puede configurar DMS para distribuir las lecturas de ASM REDO en todos los nodos de ASM.

Para utilizar esta configuración, utilice el atributo de conexión `asmServer`. Por ejemplo, la siguiente cadena de conexión distribuye las lecturas DMS REDO entre 3 nodos de ASM:

```
asmServer=(DESCRIPTION=(CONNECT_TIMEOUT=8)(ENABLE=BROKEN)(LOAD_BALANCE=ON)(FAILOVER=ON)
(ADDRESS_LIST=
(ADDRESS=(PROTOCOL=tcp)(HOST=asm_node1_ip_address)(PORT=asm_node1_port_number))
(ADDRESS=(PROTOCOL=tcp)(HOST=asm_node2_ip_address)(PORT=asm_node2_port_number))
(ADDRESS=(PROTOCOL=tcp)(HOST=asm_node3_ip_address)(PORT=asm_node3_port_number)))
(CONNECT_DATA=(SERVICE_NAME=+ASM)))
```

Al utilizar NFS para almacenar Oracle REDO, es importante asegurarse de que se han aplicado los parches de cliente de DNFS (Direct NFS) aplicables, específicamente cualquier parche que aborde el error 25224242 de Oracle. Para obtener más información, consulte la siguiente publicación de Oracle sobre los parches relacionados con el cliente Direct NFS, [parches recomendados para el cliente Direct NFS](https://support.oracle.com/knowledge/Oracle Cloud/1495104_1.html). 

Además, para mejorar el rendimiento de lectura de NFS, le recomendamos que aumente el valor de `rsize` y `wsize` en `fstab`, para el volumen de NFS, como se muestra en el siguiente ejemplo.

```
NAS_name_here:/ora_DATA1_archive /u09/oradata/DATA1 nfs rw,bg,hard,nointr,tcp,nfsvers=3,_netdev,
timeo=600,rsize=262144,wsize=262144
```

Además, ajuste el valor `tcp-max-xfer-size` de la siguiente manera:

```
vserver nfs modify -vserver vserver -tcp-max-xfer-size 262144
```

## Configuración del punto final cuando se utiliza Oracle como fuente de AWS DMS
<a name="CHAP_Source.Oracle.ConnectionAttrib"></a>

Puede utilizar la configuración de punto de conexión para configurar la base de datos de origen de Oracle de forma similar al uso de atributos de conexión adicionales. Los ajustes se especifican al crear el punto final de origen mediante la AWS DMS consola o mediante el `create-endpoint` [AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/dms/index.html)comando de la sintaxis `--oracle-settings '{"EndpointSetting": "value", ...}'` JSON.

La siguiente tabla muestra la configuración de punto de conexión que puede utilizar con Oracle como origen.


| Name | Description (Descripción) | 
| --- | --- | 
| AccessAlternateDirectly |  Establezca este atributo en falso para utilizar Binary Reader y capturar los datos de cambios de Amazon RDS para Oracle como origen. Esto indica a la instancia de DMS que no obtenga acceso a los registros REDO a través de ninguno de los prefijos de ruta sustitutos especificados mediante el acceso directo a los archivos. Para obtener más información, consulte [Configurar una tarea de CDC para utilizar Binary Reader con una fuente de RDS para Oracle para AWS DMS](#CHAP_Source.Oracle.Amazon-Managed.CDC). Valor predeterminado: verdadero  Valores válidos: true/false Ejemplo: `--oracle-settings '{"AccessAlternateDirectly": false}'`  | 
|  `AdditionalArchivedLogDestId`  |  Establezca este atributo con `ArchivedLogDestId` en una configuración principal o en espera. Este atributo es útil en una transición cuando se utiliza una base de datos de Oracle Data Guard como origen. En este caso, AWS DMS necesita saber desde qué destino se van a archivar los redo logs para leer los cambios. Esto es porque la instancia principal anterior es ahora una instancia en espera después de una transición. Aunque AWS DMS admite el uso de la `RESETLOGS` opción Oracle para abrir la base de datos, nunca la utilice `RESETLOGS` a menos que sea necesario. Para obtener información adicional acerca de `RESETLOGS`, consulte [Conceptos de reparación de datos RMAN](https://docs.oracle.com/en/database/oracle/oracle-database/19/bradv/rman-data-repair-concepts.html#GUID-1805CCF7-4AF2-482D-B65A-998192F89C2B) en la *Guía de usuario sobre copias de seguridad y recuperación de bases de datos de Oracle®*. Valores válidos: ID de destino de archivo Ejemplo: `--oracle-settings '{"AdditionalArchivedLogDestId": 2}'`  | 
|  `AddSupplementalLogging`  |  Establezca este atributo para configurar un registro suplementario para la base de datos de Oracle. Este atributo habilita una de las siguientes opciones en todas las tablas seleccionadas para una tarea de migración, en función de los metadatos de la tabla: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/dms/latest/userguide/CHAP_Source.Oracle.html) Valor predeterminado: false  Valores válidos: true/false  Ejemplo: `--oracle-settings '{"AddSupplementalLogging": false}'`  Si utiliza esta opción, tiene que habilitar igualmente el registro suplementario en el nivel de la base de datos tal y como hemos mencionado con anterioridad.    | 
|  `AllowSelectNestedTables`  |  Establezca este atributo en «true» para habilitar la replicación de tablas de Oracle que contienen columnas que son tablas anidadas o tipos definidos. Para obtener más información, consulte [Replicación de tablas anidadas utilizando Oracle como fuente de AWS DMS](#CHAP_Source.Oracle.NestedTables). Valor predeterminado: false  Valores válidos: true/false Ejemplo: `--oracle-settings '{"AllowSelectNestedTables": true}'`  | 
|  `ArchivedLogDestId`  |  Especifica el ID de los registros REDO archivados. Este valor debe ser el mismo que un número en la columna dest\$1id de la vista v\$1archived\$1log. Si trabaja con un destino de registro REDO adicional, le recomendamos que utilice el atributo `AdditionalArchivedLogDestId` para especificar el ID de destino adicional. De esta forma se mejora el desempeño garantizando que se obtiene acceso a los registros correctos desde el principio.  Valor predeterminado: 1 Valores válidos: Number  Ejemplo: `--oracle-settings '{"ArchivedLogDestId": 1}'`  | 
|  `ArchivedLogsOnly`  |  Si este campo está establecido en Y, AWS DMS solo se accede a los redo logs archivados. Si los redo logs archivados se almacenan únicamente en Oracle ASM, se deben conceder privilegios de ASM a la cuenta de AWS DMS usuario.  Valor predeterminado: N  Valores válidos: Y/N  Ejemplo: `--oracle-settings '{"ArchivedLogsOnly": Y}'`  | 
|  `asmUsePLSQLArray` (Solo ECA)  |  Utilice este atributo de conexión adicional (ECA) al capturar los cambios de origen con BinaryReader. Esta configuración permite a DMS almacenar en búfer 50 lecturas en el nivel de ASM por cada subproceso de lectura y, al mismo tiempo, controlar el número de subprocesos mediante el atributo `parallelASMReadThreads`. Al establecer este atributo, el lector AWS DMS binario utiliza un PL/SQL bloque anónimo para capturar los datos rehechos y enviarlos de vuelta a la instancia de replicación como un búfer grande. Esto reduce el número de viajes de ida y vuelta al origen. Esto puede mejorar considerablemente el rendimiento de captura del origen, pero se traduce en un mayor consumo de memoria PGA en la instancia de ASM. Pueden surgir problemas de estabilidad si el destino de memoria no es suficiente. Puede utilizar la siguiente fórmula para estimar el uso total de memoria PGA de una instancia de ASM mediante una sola tarea de DMS: `number_of_redo_threads * parallelASMReadThreads * 7 MB` Valor predeterminado: false Valores válidos: true/false Ejemplo de ECA: `asmUsePLSQLArray=true;`  | 
|  `ConvertTimestampWithZoneToUTC`  |  Establezca este atributo en `true` para convertir el valor de la marca temporal de las columnas “TIMESTAMP WITH TIME ZONE” y “TIMESTAMP WITH LOCAL TIME ZONE” a UTC. De forma predeterminada, el valor de este atributo es “falso” y los datos se replicarán con la zona horaria de la base de datos de origen. Valor predeterminado: false Valores válidos: true/false Ejemplo: `--oracle-settings '{"ConvertTimestampWithZoneToUTC": true}'`  | 
|  `EnableHomogenousPartitionOps`  |  Establezca este atributo en `true` para habilitar la replicación de las operaciones de DDL de Oracle Partition y subPartition para la migración *homogénea* de Oracle. Tenga en cuenta que esta función y esta mejora se introdujeron en la AWS DMS versión 3.4.7. Valor predeterminado: false Valores válidos: true/false Ejemplo: `--oracle-settings '{"EnableHomogenousPartitionOps": true}'`  | 
|  `EnableHomogenousTablespace`  |  Establecer este atributo para habilitar la replicación homogénea de espacio de tabla y crear tablas o índices existentes bajo el mismo espacio de tabla en el destino. Valor predeterminado: false Valores válidos: true/false Ejemplo: `--oracle-settings '{"EnableHomogenousTablespace": true}'`  | 
|  `EscapeCharacter`  |  Establezca este atributo en un carácter de escape. Este carácter de escape le permite hacer que un único carácter comodín se comporte como un carácter normal en las expresiones de asignación de tablas. Para obtener más información, consulte [Comodines en la asignación de tablas](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Wildcards.md). Valor predeterminado: nulo  Valores válidos: cualquier carácter que no sea un carácter comodín Ejemplo: `--oracle-settings '{"EscapeCharacter": "#"}'` Solo puede utilizarse `escapeCharacter` para nombres de tabla. No escapa a los caracteres de los nombres de los esquemas o de las columnas.  | 
|  `ExposeViews`  |  Utilice este atributo para extraer los datos una vez desde una vista; no puede utilizarlos para la replicación continua. Al extraer los datos de una vista, la vista se muestra como una tabla en el esquema de destino. Valor predeterminado: false Valores válidos: true/false Ejemplo: `--oracle-settings '{"ExposeViews": true}'`  | 
|  `ExtraArchivedLogDestIds`  |  Especifica IDs uno o más destinos para uno o más redo logs archivados. Estos IDs son los valores de la columna dest\$1id de la vista v\$1archived\$1log. Use esta configuración con el atributo de conexión ArchivedLogDestId adicional en una configuración o configuración. primary-to-single primary-to-multiple-standby Este ajuste es útil en una conmutación cuando se utiliza una base de datos de Oracle Data Guard como origen. En este caso, AWS DMS necesita información sobre el destino desde el que se van a archivar los redo logs para leer los cambios. AWS DMS lo necesita porque, tras la conmutación, la instancia principal anterior es una instancia en espera. Valores válidos: ID de destino de archivo Ejemplo: `--oracle-settings '{"ExtraArchivedLogDestIds": 1}'`  | 
|  `FailTasksOnLobTruncation`  |  Cuando se establece en `true`, este atributo provocar un error en una tarea si el tamaño real de una columna de LOB es superior al `LobMaxSize` especificado. Si una tarea está establecida en el modo LOB limitado y esta opción está establecida en `true`, la tarea genera un error en vez de truncar los datos de LOB. Valor predeterminado: false  Valores válidos: booleano  Ejemplo: `--oracle-settings '{"FailTasksOnLobTruncation": true}'`  | 
|  `filterTransactionsOfUser` (Solo ECA)  |  Utilice este atributo de conexión adicional (ECA) para permitir que DMS ignore las transacciones de un usuario específico al replicar datos de Oracle cuando los utilice. LogMiner Puede pasar valores de nombre de usuario separados por comas, pero deben estar todos en MAYÚSCULAS. Ejemplo de ECA: `filterTransactionsOfUser=USERNAME;`  | 
|  `NumberDataTypeScale`  |  Especifica la escala de números. Puede seleccionar una escala vertical hasta 38 o puede seleccionar -1 para FLOAT o -2 para VARCHAR. De forma predeterminada, el tipo de datos NUMBER se convierte a precisión 38, escala 10. Valor predeterminado: 10  Valores válidos: -2 a 38 (-2 para VARCHAR, -1 para FLOAT) Ejemplo: `--oracle-settings '{"NumberDataTypeScale": 12}'`  Seleccione una combinación de escalas de precisión, -1 (FLOAT) o -2 (VARCHAR). DMS admite cualquier combinación de escalas de precisión admitida por Oracle. Si la precisión es 39 o superior, seleccione -2 (VARCHAR). La NumberDataTypeScale configuración de la base de datos Oracle se utiliza únicamente para el tipo de datos NUMBER (sin la definición explícita de precisión y escala). Debe tener en cuenta que puede perderse precisión si esta configuración no se configura correctamente.   | 
|  `OpenTransactionWindow`  |   Proporciona el tiempo en minutos para comprobar si hay transacciones abiertas para una tarea exclusiva de CDC. Cuando se establece `OpenTransactionWindow` en 1 o más, DMS utiliza `SCN_TO_TIMESTAMP` para convertir los valores de número de cambio del sistema en valores de marca de tiempo. Debido a las limitaciones de la base de datos Oracle, si especifica un número de cambio del sistema demasiado antiguo como punto de partida de CDC, SCN\$1TO\$1TIMESTAMP generará un error `ORA-08181` y no podrá iniciar tareas exclusivas de CDC. Valor predeterminado: 0  Valores válidos: un número entero de 0 a 240 Ejemplo: `openTransactionWindow=15;`  | 
| OraclePathPrefix | Establezca este atributo de cadena en el valor necesario para utilizar Binary Reader para capturar los datos de cambios de Amazon RDS para Oracle como origen. Este valor especifica la raíz de Oracle predeterminada usada para obtener acceso a los registros REDO. Para obtener más información, consulte [Configurar una tarea de CDC para utilizar Binary Reader con una fuente de RDS para Oracle para AWS DMS](#CHAP_Source.Oracle.Amazon-Managed.CDC).Valor predeterminado: ninguno Valor válido:/rdsdbdata/db/ORCL\$1A/ Ejemplo: `--oracle-settings '{"OraclePathPrefix": "/rdsdbdata/db/ORCL_A/"}'`  | 
| ParallelASMReadThreads |  Establezca este atributo para cambiar el número de subprocesos que DMS configura para realizar una captura de datos de cambios (CDC) con Oracle Automatic Storage Management (ASM). Puede especificar un valor entero entre 2 (el valor predeterminado) y 8 (el máximo). Utilice este atributo junto con el atributo `ReadAheadBlocks`. Para obtener más información, consulte [Configurar una tarea de CDC para utilizar Binary Reader con una fuente de RDS para Oracle para AWS DMS](#CHAP_Source.Oracle.Amazon-Managed.CDC). Valor predeterminado: 2  Valores válidos: Un número entero de 2 a 8 Ejemplo: `--oracle-settings '{"ParallelASMReadThreads": 6;}'`  | 
| ReadAheadBlocks |  Establezca este atributo para cambiar el número de bloques de lectura anticipada que DMS configura para realizar CDC con Oracle Automatic Storage Management (ASM) y almacenamiento NAS que no es ASM. Puede especificar un valor entero entre 1000 (el valor predeterminado) y 2 000 000 (el máximo). Utilice este atributo junto con el atributo `ParallelASMReadThreads`. Para obtener más información, consulte [Configurar una tarea de CDC para utilizar Binary Reader con una fuente de RDS para Oracle para AWS DMS](#CHAP_Source.Oracle.Amazon-Managed.CDC). Valor predeterminado: 1000  Valores válidos: un entero comprendido entre 1000 y 2 000 000 Ejemplo: `--oracle-settings '{"ReadAheadBlocks": 150000}'`  | 
|  `ReadTableSpaceName`  |  Cuando se establece en `true`, este atributo admite la replicación del espacio de tabla. Valor predeterminado: false  Valores válidos: booleano  Ejemplo: `--oracle-settings '{"ReadTableSpaceName": true}'`  | 
| ReplacePathPrefix | Establezca este atributo en true para utilizar Binary Reader para capturar los datos de Amazon RDS para Oracle como origen. Este valor indica a la instancia de DMS que reemplace la raíz de Oracle predeterminada por el valor de UsePathPrefix especificado para obtener acceso a los registros REDO. Para obtener más información, consulte [Configurar una tarea de CDC para utilizar Binary Reader con una fuente de RDS para Oracle para AWS DMS](#CHAP_Source.Oracle.Amazon-Managed.CDC).Valor predeterminado: false Valores válidos: true/false Ejemplo: `--oracle-settings '{"ReplacePathPrefix": true}'`  | 
|  `RetryInterval`  |  Especifica el número de segundos que espera el sistema antes de reenviar una consulta.  Valor predeterminado: 5  Valores válidos: números a partir de 1  Ejemplo: `--oracle-settings '{"RetryInterval": 6}'`  | 
|  `SecurityDbEncryptionName`  |  Especifica el nombre de una clave utilizada para el cifrado de datos transparente (TDE) de las columnas y del espacio de tabla de la base de datos de origen de Oracle. Para obtener más información sobre la configuración de este atributo y su contraseña asociada en el punto de enlace de origen de Oracle, consulte [Métodos de cifrado compatibles para utilizar Oracle como fuente de AWS DMS](#CHAP_Source.Oracle.Encryption). Valor predeterminado: ""  Valores válidos: string  Ejemplo: `--oracle-settings '{"SecurityDbEncryptionName": "ORACLE.SECURITY.DB.ENCRYPTION.Adg8m2dhkU/0v/m5QUaaNJEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"}'`  | 
|  `SpatialSdo2GeoJsonFunctionName`  |  Para orígenes de Oracle versión 12.1 o anteriores que se migran a destinos de PostgreSQL, utilice este atributo para convertir SDO\$1GEOMETRY al formato GEOJSON. De forma predeterminada, AWS DMS llama a la función `SDO2GEOJSON` personalizada, que debe estar presente y accesible para el AWS DMS usuario. O puede crear su propia función personalizada que imita la operación de `SDOGEOJSON` y establecer `SpatialSdo2GeoJsonFunctionName` para llamarla.  Valor predeterminado: SDO2 GEOJSON Valores válidos: string  Ejemplo: `--oracle-settings '{"SpatialSdo2GeoJsonFunctionName": "myCustomSDO2GEOJSONFunction"}'`  | 
|  `StandbyDelayTime`  |  Utilice este atributo para especificar una hora en minutos que indique el retraso en la sincronización de la base de datos en espera. Si el origen es una base de datos en espera de Active Data Guard, utilice este atributo para especificar el intervalo de tiempo entre las bases de datos principal y en espera. En AWS DMS, puede crear una tarea de Oracle CDC que utilice una instancia en espera de Active Data Guard como fuente para replicar los cambios en curso. Esto elimina la necesidad de establecer conexión con una base de datos activa que podría estar en la fase de producción. Valor predeterminado: 0  Valores válidos: Number  Ejemplo: `--oracle-settings '{"StandbyDelayTime": 1}'` **Nota: **Cuando se utiliza DMS 3.4.6, 3.4.7 y versiones superiores, el uso de esta configuración de conexión es opcional. En las versiones más recientes de DMS 3.4.6 y 3.4.7, `dms_user` debe tener el permiso `select` en `V_$DATAGUARD_STATS`, lo que permite a DMS calcular el tiempo de retraso en espera.  | 
| UseAlternateFolderForOnline | Establezca este atributo en true para utilizar Binary Reader para capturar los datos de Amazon RDS para Oracle como origen. Esto indica a la instancia de DMS que use cualquier prefijo sustituto especificado para obtener acceso a todos los registros REDO online. Para obtener más información, consulte [Configurar una tarea de CDC para utilizar Binary Reader con una fuente de RDS para Oracle para AWS DMS](#CHAP_Source.Oracle.Amazon-Managed.CDC).Valor predeterminado: false Valores válidos: true/false Ejemplo: `--oracle-settings '{"UseAlternateFolderForOnline": true}'`  | 
| UseBfile |  Establezca este atributo en Y para capturar los datos de cambios mediante la utilidad Binary Reader. Establezca `UseLogminerReader` en N para establecer este atributo en S. Para utilizar Binary Reader con Amazon RDS para Oracle como origen, establezca atributos adicionales. Para obtener más información acerca de esta configuración y el uso de Oracle Automatic Storage Management (ASM), consulte [Uso de Oracle LogMiner o AWS DMS Binary Reader para CDC](#CHAP_Source.Oracle.CDC). Nota: Al establecer este valor como un atributo de conexión adicional (ECA), los valores válidos son “S” y “N”. Al establecer este valor como configuración de punto de conexión, los valores válidos son `true` y `false`. Valor predeterminado: N  Valores válidos: Y/N (cuando se establece este valor como ECA); true/false (cuando se establece este valor como una configuración de punto final). Ejemplo: `--oracle-settings '{"UseBfile": Y}'`  | 
|  `UseLogminerReader`  |  Establezca este atributo en Y para capturar los datos de cambios mediante la LogMiner utilidad (la opción predeterminada). Establezca esta opción en N si desea que AWS DMS obtenga acceso a los registros REDO como un archivo binario. Al establecer esta opción en N, agregue también el ajuste useBfile=Y. Para obtener más información sobre esta configuración y el uso de Oracle Automatic Storage Management (ASM), consulte [Uso de Oracle LogMiner o AWS DMS Binary Reader para CDC](#CHAP_Source.Oracle.CDC). Nota: Al establecer este valor como un atributo de conexión adicional (ECA), los valores válidos son “S” y “N”. Al establecer este valor como configuración de punto de conexión, los valores válidos son `true` y `false`. Valor predeterminado: Y  Valores válidos: Y/N (cuando se establece este valor como ECA); true/false (cuando se establece este valor como una configuración de punto final). Ejemplo: `--oracle-settings '{"UseLogminerReader": Y}'`  | 
| UsePathPrefix | Establezca este atributo de cadena en el valor necesario para utilizar Binary Reader para capturar los datos de cambios de Amazon RDS para Oracle como origen. Este valor especifica el prefijo de ruta utilizado para reemplazar la raíz de Oracle predeterminada empleada para obtener acceso a los registros REDO. Para obtener más información, consulte [Configurar una tarea de CDC para utilizar Binary Reader con una fuente de RDS para Oracle para AWS DMS](#CHAP_Source.Oracle.Amazon-Managed.CDC).Valor predeterminado: ninguno Valor válido: /rdsdbdata/log/ Ejemplo: `--oracle-settings '{"UsePathPrefix": "/rdsdbdata/log/"}'`  | 

## Tipos de datos de origen para Oracle
<a name="CHAP_Source.Oracle.DataTypes"></a>

El punto final de Oracle AWS DMS es compatible con la mayoría de los tipos de datos de Oracle. La siguiente tabla muestra los tipos de datos de origen de Oracle que se admiten cuando se utilizan AWS DMS y la asignación predeterminada a AWS DMS los tipos de datos.

**nota**  
Con la excepción de los tipos de datos LONG y LONG RAW, al replicar desde un origen de Oracle a un destino de Oracle (una *replicación homogénea*), todos los tipos de datos de origen y destino serán idénticos. Sin embargo, el tipo de datos LONG se asignará a CLOB y el tipo de datos LONG RAW se asignará a BLOB. 

Para obtener más información sobre cómo ver el tipo de datos que se asigna en el destino, consulte la sección del punto de enlace de destino que esté utilizando.

Para obtener información adicional sobre AWS DMS los tipos de datos, consulte[Tipos de datos de AWS Database Migration Service](CHAP_Reference.DataTypes.md).


|  Tipos de datos de Oracle  |  AWS DMS tipo de datos  | 
| --- | --- | 
|  BINARY\$1FLOAT  |  REAL4  | 
|  BINARY\$1DOUBLE  |  REAL8  | 
|  BINARIO  |  BYTES  | 
|  FLOAT (P)  |  Si la precisión es menor o igual a 24, utilice REAL4. Si la precisión es superior a 24, utilice REAL8.  | 
|  NUMBER (P,S)  |  Si la escala es mayor que 0, utilice NUMERIC. Cuando la escala sea 0: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/dms/latest/userguide/CHAP_Source.Oracle.html) Cuando la escala sea inferior a 0, utilice REAL8. | 
|  DATE  |  DATETIME  | 
|  INTERVAL\$1YEAR TO MONTH  |  STRING (con indicación year\$1to\$1month del intervalo)  | 
|  INTERVAL\$1DAY TO SECOND  |  STRING (con indicación day\$1to\$1second del intervalo)  | 
|  TIMESTAMP  |  DATETIME  | 
|  MARCA DE TIEMPO CON ZONA HORARIA  |  STRING (con indicación timestamp\$1with\$1timezone)  | 
|  TIMESTAMP CON ZONA HORARIA LOCAL  |  STRING (con indicación timestamp\$1with\$1local\$1 timezone)  | 
|  CHAR  |  STRING  | 
|  VARCHAR2  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/dms/latest/userguide/CHAP_Source.Oracle.html)  | 
|  NCHAR  |  WSTRING  | 
|  NVARCHAR2  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/dms/latest/userguide/CHAP_Source.Oracle.html)  | 
|  RAW  |  BYTES  | 
|  REAL  |  REAL8  | 
|  BLOB  |  BLOB Para usar este tipo de datos con AWS DMS, debe habilitar el uso de tipos de datos BLOB para una tarea específica. AWS DMS solo admite los tipos de datos BLOB en las tablas que incluyen una clave principal.  | 
|  CLOB  |  CLOB Para usar este tipo de datos con AWS DMS, debe habilitar el uso de tipos de datos CLOB para una tarea específica. Durante los CDC, solo AWS DMS admite los tipos de datos CLOB en las tablas que incluyen una clave principal.  | 
|  NCLOB  |  NCLOB Para usar este tipo de datos con AWS DMS, debe habilitar el uso de los tipos de datos NCLOB para una tarea específica. Durante los CDC, solo AWS DMS admite los tipos de datos NCLOB en las tablas que incluyen una clave principal.  | 
|  LONG  |  CLOB El tipo de datos LONG no se admite en el modo de aplicación optimizada por lotes (modo CDC)TurboStream . Para usar este tipo de datos con AWS DMS, habilite el uso de LOBs para una tarea específica. Durante la fase CDC o a plena carga, solo AWS DMS admite los tipos de datos LOB en las tablas que tienen una clave principal. Además, AWS DMS no admite el modo LOB completo para cargar columnas largas. En su lugar, puede utilizar el modo de LOB limitado para migrar columnas LONG a un destino de Oracle. En el modo LOB limitado, AWS DMS trunca los datos a 64 KB que establezca en columnas LARGAS de más de 64 KB. Para obtener más información sobre la compatibilidad con LOB, consulte AWS DMS[Configurar la compatibilidad con LOB para las bases de datos de origen de una tarea AWS DMS](CHAP_Tasks.LOBSupport.md)  | 
|  LONG RAW  |  BLOB El tipo de datos LONG RAW no se admite en el modo de aplicación optimizado por lotes (modo TurboStream CDC). Para usar este tipo de datos con AWS DMS, habilite el uso de LOBs para una tarea específica. Durante la fase CDC o a plena carga, solo AWS DMS admite los tipos de datos LOB en las tablas que tienen una clave principal. Además, AWS DMS no admite el modo LOB completo para cargar columnas RAW LARGAS. En su lugar, puede utilizar el modo de LOB limitado para migrar columnas LONG RAW a un destino de Oracle. En el modo de LOB limitado, AWS DMS trunca los datos a 64 KB que haya establecido en columnas LONG RAW de más de 64 KB. Para obtener más información sobre la compatibilidad con LOB, consulte AWS DMS[Configurar la compatibilidad con LOB para las bases de datos de origen de una tarea AWS DMS](CHAP_Tasks.LOBSupport.md)  | 
|  XMLTYPE  |  CLOB  | 
| SDO\$1GEOMETRY | BLOB (en una migración de Oracle a Oracle)CLOB (en una migración de Oracle a PostgreSQL) | 

No se admiten las tablas de Oracle que se utilizan como origen con columnas de los siguientes tipos de datos y no se pueden replicar. Si se replican las columnas con estos tipos de datos se obtendrán una columna con el valor NULL.
+ BFILE
+ ROWID
+ REF
+ UROWID
+ Tipos de datos definidos por el usuario
+ ANYDATA
+ VARRAY

**nota**  
No se admiten las columnas virtuales.

### Migración de tipos de datos espaciales de Oracle
<a name="CHAP_Source.Oracle.DataTypes.Spatial"></a>

Los *datos espaciales* identifican la información de geometría de un objeto o ubicación en el espacio. En una base de datos de Oracle, la descripción geométrica de un objeto espacial se almacena en un objeto de tipo SDO\$1GEOMETRY. Dentro de este objeto, la descripción geométrica se almacena en una sola fila de una sola columna de una tabla definida por el usuario. 

AWS DMS admite la migración del tipo SDO\$1GEOMETRY de Oracle desde un origen de Oracle a un destino de Oracle o PostgreSQL.

Al migrar los tipos de datos espaciales de Oracle mediante AWS DMS, tenga en cuenta las siguientes consideraciones:
+ Al migrar a un destino de Oracle, asegúrese de transferir manualmente las entradas USER\$1SDO\$1GEOM\$1METADATA que incluyan información de tipos. 
+ Al migrar desde un punto final de origen de Oracle a un punto final de destino de PostgreSQL, crea columnas de destino. AWS DMS Estas columnas contienen información de la geometría y el tipo de geografía predeterminados con una dimensión en 2D y un identificador de referencia espacial (SRID) igual a cero (0). Un ejemplo es `GEOMETRY, 2, 0`.
+ Para los orígenes de Oracle versión 12.1 o anteriores que se migran a destinos de PostgreSQL, convierta los objetos `SDO_GEOMETRY` al formato `GEOJSON` mediante la función `SDO2GEOJSON` o el atributo de conexión adicional `spatialSdo2GeoJsonFunctionName`. Para obtener más información, consulte [Configuración del punto final cuando se utiliza Oracle como fuente de AWS DMS](#CHAP_Source.Oracle.ConnectionAttrib).
+ AWS DMS solo admite las migraciones de columnas espaciales de Oracle para el modo LOB completo. AWS DMS no admite los modos LOB limitado o LOB en línea. Para obtener más información sobre el modo de LOB, consulte [Configurar la compatibilidad con LOB para las bases de datos de origen de una tarea AWS DMS](CHAP_Tasks.LOBSupport.md).
+ Como AWS DMS solo admite el modo LOB completo para migrar Oracle Spatial Columns, la tabla de columnas necesita una clave principal y una clave única. Si la tabla no tiene una clave principal y una clave única, la tabla se omite de la migración.

# Uso de una base de datos de Microsoft SQL Server como fuente para AWS DMS
<a name="CHAP_Source.SQLServer"></a>

Migre datos de una o varias bases de datos de Microsoft SQL Server mediante AWS DMS. Con una base de datos de SQL Server como origen, puede migrar los datos a otra base de datos de SQL Server o a una de las otras bases de datos AWS DMS compatibles. 

Para obtener información sobre las versiones de SQL Server que se AWS DMS admiten como fuente, consulte[Fuentes de AWS DMS](CHAP_Introduction.Sources.md).

La base de datos de origen de SQL Server se puede instalar en cualquier equipo de la red. También se necesita una cuenta de SQL Server con los privilegios de acceso adecuados a la base de datos de origen para el tipo de tarea elegido, con el fin de utilizarla con AWS DMS. Para obtener más información, consulte [Permisos para las tareas de SQL Server](#CHAP_Source.SQLServer.Permissions).

AWS DMS admite la migración de datos desde instancias nombradas de SQL Server. Puede utilizar las siguientes notaciones en el nombre del servidor al crear el punto de enlace de origen.

```
IPAddress\InstanceName
```

Por ejemplo, el siguiente es un nombre de servidor de punto de enlace de origen correcto. En este caso, la primera parte del nombre es la dirección IP del servidor y la segunda parte es el nombre de la instancia de SQL Server (en este ejemplo, SQLTest).

```
10.0.0.25\SQLTest
```

Además, obtenga el número de puerto en el que escucha la instancia designada de SQL Server y utilícelo para configurar el punto final de AWS DMS origen. 

**nota**  
El puerto 1433 es el predeterminado para Microsoft SQL Server. Pero también es habitual usar puertos dinámicos que cambian cada vez que se inicia SQL Server y números de puerto estáticos específicos utilizados para conectarse a SQL Server a través de un firewall. Por lo tanto, querrá saber el número de puerto real de la instancia designada de SQL Server al crear el punto final de AWS DMS origen.

Puede utilizar SSL para cifrar las conexiones entre el punto de enlace de SQL Server y la instancia de replicación. Para obtener más información sobre cómo utilizar SSL con un punto de enlace de SQL Server, consulte [Uso de SSL con AWS Database Migration Service](CHAP_Security.SSL.md).

Puede usar CDC para la migración continua desde una base de datos de SQL Server. Para obtener más información sobre cómo configurar la base de datos de SQL Server de origen para CDC, consulte [Captura de cambios en los datos para la replicación continua desde SQL Server](CHAP_Source.SQLServer.CDC.md).

Para obtener más información sobre cómo trabajar con las bases de datos de origen de SQL Server AWS DMS, consulte lo siguiente.

**Topics**
+ [Limitaciones del uso de SQL Server como fuente de AWS DMS](#CHAP_Source.SQLServer.Limitations)
+ [Permisos para las tareas de SQL Server](#CHAP_Source.SQLServer.Permissions)
+ [Requisitos previos para el uso de la replicación continua (CDC) desde un origen de SQL Server](#CHAP_Source.SQLServer.Prerequisites)
+ [Métodos de compresión admitidos para SQL Server](#CHAP_Source.SQLServer.Compression)
+ [Trabaja con grupos de disponibilidad de SQL Server autogestionados AlwaysOn](#CHAP_Source.SQLServer.AlwaysOn)
+ [Configuración del punto final cuando se utiliza SQL Server como fuente de AWS DMS](#CHAP_Source.SQLServer.ConnectionAttrib)
+ [Tipos de datos de origen para SQL Server](#CHAP_Source.SQLServer.DataTypes)
+ [Captura de cambios en los datos para la replicación continua desde SQL Server](CHAP_Source.SQLServer.CDC.md)

## Limitaciones del uso de SQL Server como fuente de AWS DMS
<a name="CHAP_Source.SQLServer.Limitations"></a>

Las siguientes restricciones se aplican cuando se utiliza una base de datos de SQL Server como origen para AWS DMS:
+ La propiedad de identidad para una columna no se migra a una columna de la base de datos de destino.
+ El punto de conexión de SQL Server no es compatible con el uso de tablas con columnas dispersas.
+ No se admite la autenticación de Windows.
+ Los cambios en los campos calculados en SQL Server no se replican.
+ No se permite usar tablas temporales.
+ No se admite el cambio de particiones de SQL Server.
+ Al utilizar las utilidades WRITETEXT y UPDATETEXT, AWS DMS no captura los eventos aplicados a la base de datos de origen.
+ No se admite el siguiente patrón de lenguaje de manipulación de datos (DML). 

  ```
  SELECT * INTO new_table FROM existing_table
  ```
+ Cuando se utiliza SQL Server como origen, no se admite el cifrado de nivel de columna.
+ AWS DMS no admite auditorías a nivel de servidor en SQL Server 2008 o SQL Server 2008 R2 como fuentes. Esto se debe a un problema conocido con SQL Server 2008 y 2008 R2. Por ejemplo, si se ejecuta el siguiente comando, se produce AWS DMS un error.

  ```
  USE [master]
  GO 
  ALTER SERVER AUDIT [my_audit_test-20140710] WITH (STATE=on)
  GO
  ```
+ Las columnas de geometría no se admiten en el modo Full LOB cuando se utiliza SQL Server como origen. En su lugar, utilice el modo de LOB limitado o establezca la opción de la tarea `InlineLobMaxSize` para que utilice el modo de LOB insertado.
+ Cuando se utiliza una base de datos de origen de Microsoft SQL Server en una tarea de replicación, las definiciones del publicador de replicación de SQL Server no se eliminan si se elimina la tarea. Estas definiciones de Microsoft SQL Server las debe eliminar un administrador del sistema de Microsoft SQL Server.
+ La migración de datos desde non-schema-bound vistas y vinculadas a un esquema solo se admite para tareas de carga completa. 
+ No se admite el cambio de nombre de las tablas mediante sp\$1rename (por ejemplo, `sp_rename 'Sales.SalesRegion', 'SalesReg;)`
+ No se admite el cambio de nombre de las columnas mediante sp\$1rename (por ejemplo, `sp_rename 'Sales.Sales.Region', 'RegID', 'COLUMN';`)
+ AWS DMS no admite el procesamiento de cambios para establecer y desestablecer los valores predeterminados de las columnas (utilizando la `ALTER COLUMN SET DEFAULT` cláusula con declaraciones). `ALTER TABLE`
+ AWS DMS no admite el procesamiento de cambios para establecer la nulabilidad de las columnas (se usa la `ALTER COLUMN [SET|DROP] NOT NULL` cláusula con `ALTER TABLE` declaraciones).
+ Con SQL Server 2012 y SQL Server 2014, cuando se utiliza la replicación de DMS con grupos de disponibilidad, la base de datos de distribución no se puede colocar en un grupo de disponibilidad. SQL 2016 permite colocar la base de datos de distribución en un grupo de disponibilidad, excepto en el caso de las bases de datos de distribución utilizadas en topologías de fusión, bidireccionales o peer-to-peer de replicación.
+ En el caso de las tablas particionadas, AWS DMS no admite diferentes configuraciones de compresión de datos para cada partición.
+ Al insertar un valor en los tipos de datos espaciales de SQL Server (GEOGRAPHY y GEOMETRY), puede omitir la propiedad del identificador del sistema de referencia espacial (SRID) o especificar un número diferente. Al replicar tablas con tipos de datos espaciales, AWS DMS reemplaza el SRID por el SRID predeterminado (0 para GEOMETRY y 4326 para GEOGRAPHY).
+ Si su base de datos no está configurada para MS-REPLICATION o MS-CDC, puede capturar tablas que no tengan una clave principal, pero solo se capturan los eventos de DML. INSERT/DELETE Los eventos UPDATE y TRUNCATE TABLE se omiten.
+ No se admiten los índices de Columnstore.
+ Las tablas con optimización de la memoria (usando OLTP en memoria) no son compatibles.
+ Al replicar una tabla con una clave principal que consta de varias columnas, no se admite la actualización de las columnas de clave principal durante la carga completa.
+ No se admite la durabilidad retardada.
+ La configuración de punto de conexión `readBackupOnly=true` (atributo de conexión adicional) no funciona en las instancias de origen de RDS para SQL Server debido a la forma en que RDS realiza las copias de seguridad.
+ `EXCLUSIVE_AUTOMATIC_TRUNCATION` no funciona en las instancias de origen de SQL Server de Amazon RDS porque los usuarios de RDS no tienen acceso para ejecutar el procedimiento almacenado de SQL Server, `sp_repldone`.
+ AWS DMS no captura los comandos de truncamiento.
+ AWS DMS no admite la replicación desde bases de datos con la recuperación acelerada de bases de datos (ADR) activada.
+ AWS DMS no admite la captura de sentencias del lenguaje de definición de datos (DDL) y del lenguaje de manipulación de datos (DML) en una sola transacción.
+ AWS DMS no admite la replicación de paquetes de aplicaciones de nivel de datos (DACPAC).
+ Las instrucciones UPDATE que incluyen claves principales o índices únicos y actualizan varias filas de datos pueden provocar conflictos al aplicar cambios en la base de datos de destino. Esto puede suceder, por ejemplo, cuando la base de datos de destino aplica las actualizaciones como instrucciones INSERT y DELETE en lugar de aplicar una sola instrucción UPDATE. Con el modo de aplicación optimizado por lotes, es posible que se ignore la tabla. Con el modo de aplicación transaccional, es posible que la operación UPDATE provoque infracciones de las restricciones. Para evitar este problema, vuelva a cargar la tabla correspondiente. Como alternativa, localice los registros problemáticos en la tabla de control de aplicación de excepciones (`dmslogs.awsdms_apply_exceptions`) y edítelos manualmente en la base de datos de destino. Para obtener más información, consulte [Configuración de ajuste del procesamiento de cambios](CHAP_Tasks.CustomizingTasks.TaskSettings.ChangeProcessingTuning.md).
+ AWS DMS no admite la replicación de tablas y esquemas, donde el nombre incluye un carácter especial del siguiente conjunto.

  `\\ -- \n \" \b \r ' \t ;` 
+ No se admite el enmascaramiento de datos. AWS DMS migra los datos enmascarados sin enmascararlos.
+ AWS DMS replica hasta 32 767 tablas con claves principales y hasta 1000 columnas para cada tabla. Esto se debe a que AWS DMS crea un artículo de replicación de SQL Server para cada tabla replicada, y los artículos de replicación de SQL Server tienen estas limitaciones.
+ Al utilizar Captura de datos de cambios (CDC), debe definir todas las columnas que componen un índice único como `NOT NULL`. Si no se cumple este requisito, se generará el error 22838 del sistema de SQL Server. 
+ Puede perder eventos si SQL Server los archiva del registro de transacciones activo al registro de copia de seguridad o los trunca del registro de transacciones activo.

Se aplican las siguientes limitaciones al acceder a los registros de transacciones de copia de seguridad:
+ Las copias de seguridad cifradas no son compatibles.
+ Las copias de seguridad almacenadas en una dirección URL o en Windows Azure no son compatibles.
+ AWS DMS no admite el procesamiento directo de las copias de seguridad del registro de transacciones a nivel de archivo desde carpetas compartidas alternativas.
+ En el caso de fuentes de Cloud SQL Server distintas de Amazon RDS para Microsoft SQL Server AWS DMS , admite la replicación continua (CDC) únicamente con el registro de transacciones activo. No puede usar el registro de copia de seguridad con CDC. Puede perder eventos si SQL Server los archiva del registro de transacciones activo al registro de copia de seguridad o los trunca del registro de transacciones activo antes de que DMS pueda leerlo. 
+ En el caso de las fuentes de Amazon RDS para Microsoft SQL Server AWS DMS , la versión 3.5.2 y versiones anteriores admiten la replicación continua (CDC) únicamente con el registro de transacciones activo, ya que DMS no puede acceder al registro de copias de seguridad con CDC. Puede perder eventos si RDS para SQL Server los archiva del registro de transacciones activo al registro de copia de seguridad o los trunca del registro de transacciones activo antes de que DMS pueda leerlo. Esta limitación no se aplica a las AWS DMS versiones 3.5.3 y posteriores.
+ AWS DMS no admite CDC for Amazon RDS Proxy for SQL Server como fuente.
+ Si el origen de SQL Server deja de estar disponible durante una tarea de carga completa, AWS DMS podría marcar la tarea como completada tras varios intentos de reconexión, aunque la migración de datos siga incompleta. En este escenario, las tablas de destino solo contienen los registros migrados antes de la pérdida de conexión, lo que podría crear incoherencias de datos entre los sistemas de origen y de destino. Para garantizar la integridad de los datos, debe reiniciar completamente la tarea de carga completa o volver a cargar las tablas específicas afectadas por la interrupción de la conexión.

## Permisos para las tareas de SQL Server
<a name="CHAP_Source.SQLServer.Permissions"></a>

**Topics**
+ [Permisos para tareas que son solo de carga completa](#CHAP_Source.SQLServer.Permissions.FullLoad)
+ [Permisos para tareas con replicación continua](#CHAP_Source.SQLServer.Permissions.Ongoing)

### Permisos para tareas que son solo de carga completa
<a name="CHAP_Source.SQLServer.Permissions.FullLoad"></a>

Los siguientes permisos son necesarios para realizar tareas que son solo de carga completa. Tenga en cuenta que AWS DMS no crea el inicio de sesión de `dms_user`. Para obtener más información sobre cómo crear un inicio de sesión para SQL Server, consulte el tema [Crear un usuario de base de datos](https://learn.microsoft.com/en-us/sql/relational-databases/security/authentication-access/create-a-database-user?view=sql-server-ver16) en la *documentación de Microsoft*.

```
USE db_name;
                
                CREATE USER dms_user FOR LOGIN dms_user; 
                ALTER ROLE [db_datareader] ADD MEMBER dms_user; 
                GRANT VIEW DATABASE STATE to dms_user;
                GRANT VIEW DEFINITION to dms_user;
                
                USE master;
                
                GRANT VIEW SERVER STATE TO dms_user;
```

### Permisos para tareas con replicación continua
<a name="CHAP_Source.SQLServer.Permissions.Ongoing"></a>

Las instancias autoadministradas de SQL Server se pueden configurar para la replicación continua mediante DMS con o sin usar el rol `sysadmin`. En el caso de las instancias de SQL Server, en las que no puede conceder el rol `sysadmin`, asegúrese de que el usuario de DMS tenga los privilegios que se describen a continuación.

**Configuración de permisos para la replicación continua desde una base de datos de SQL Server autoadministrada**

1. Cree una cuenta de SQL Server con autenticación mediante contraseña a través de SQL Server Management Studio (SSMS) o como se describe anteriormente en [Permisos para tareas que son solo de carga completa](#CHAP_Source.SQLServer.Permissions.FullLoad), por ejemplo `self_managed_user`.

1. Ejecute los siguientes comandos `GRANT`: 

   ```
   GRANT VIEW SERVER STATE TO self_managed_user;
   
   USE msdb;
       GRANT SELECT ON msdb.dbo.backupset TO self_managed_user;
       GRANT SELECT ON msdb.dbo.backupmediafamily TO self_managed_user;
       GRANT SELECT ON msdb.dbo.backupfile TO self_managed_user;
       
   USE db_name;
       CREATE USER self_managed_user FOR LOGIN self_managed_user;
       ALTER ROLE [db_owner] ADD MEMBER self_managed_user;
       GRANT VIEW DEFINITION to self_managed_user;
   ```

1. Además de los permisos anteriores, el usuario debe cumplir uno de los siguientes requisitos:
   + El usuario debe ser miembro del rol de servidor fijo `sysadmin`.
   + Deben establecerse las configuraciones y permisos que se describen en [Configuración de la replicación continua en un SQL Server en un entorno de grupos de disponibilidad: sin el rol de sysadmin](CHAP_Source.SQLServer.CDC.md#CHAP_SupportScripts.SQLServer.ag) o [Configuración de la replicación continua en un SQL Server independiente: sin el rol de sysadmin](CHAP_Source.SQLServer.CDC.md#CHAP_SupportScripts.SQLServer.standalone), en función de la configuración de origen.

#### Configuración de permisos para la replicación continua desde una base de datos de SQL Server en la nube
<a name="CHAP_Source.SQLServer.Permissions.Cloud"></a>

Una instancia de SQL Server alojada en la nube es una instancia que se ejecuta en Amazon RDS para Microsoft SQL Server, una instancia administrada por Azure SQL o cualquier otra instancia de SQL Server administrada en la nube compatible con DMS.

Cree una cuenta de SQL Server con autenticación mediante contraseña a través de SQL Server Management Studio (SSMS) o como se describe anteriormente en [Permisos para tareas que son solo de carga completa](#CHAP_Source.SQLServer.Permissions.FullLoad), por ejemplo `rds_user`.

Ejecute los siguientes comandos Grant.

```
GRANT VIEW SERVER STATE TO rds_user;
```

En el caso de los orígenes de Amazon RDS para Microsoft SQL Server, DMS 3.5.3 y las versiones posteriores admiten la lectura de copias de seguridad del registro de transacciones. Para garantizar que DMS pueda acceder a las copias de seguridad de los registros, además de lo anterior, conceda privilegios de usuario `master` o bien los siguientes privilegios en un origen SQL Server de RDS:

```
USE msdb;
    GRANT EXEC ON msdb.dbo.rds_dms_tlog_download TO rds_user;
    GRANT EXEC ON msdb.dbo.rds_dms_tlog_read TO rds_user;
    GRANT EXEC ON msdb.dbo.rds_dms_tlog_list_current_lsn TO rds_user;
    GRANT EXEC ON msdb.dbo.rds_task_status TO rds_user;
    
USE db_name;
    CREATE USER rds_user FOR LOGIN rds_user;
    ALTER ROLE [db_owner] ADD MEMBER rds_user;
    GRANT VIEW DEFINITION to rds_user;
```

En el caso de las instancias administradas de Amazon Azure SQL, conceda los siguientes privilegios:

```
GRANT SELECT ON msdb.dbo.backupset TO rds_user;
GRANT SELECT ON msdb.dbo.backupmediafamily TO rds_user;
GRANT SELECT ON msdb.dbo.backupfile TO rds_user;
```

## Requisitos previos para el uso de la replicación continua (CDC) desde un origen de SQL Server
<a name="CHAP_Source.SQLServer.Prerequisites"></a>

Puede utilizar la replicación continua (captura de datos de cambios o CDC) para una base de datos de SQL Server autoadministrada en las instalaciones o en Amazon EC2, una base de datos de la nube como Amazon RDS o una instancia administrada por Microsoft Azure SQL.

Los requisitos siguientes se aplican específicamente cuando se utiliza la replicación continua con una base de datos de SQL Server como origen para AWS DMS:
+ Es preciso configurar SQL Server para backups completas y debe realizar una backup antes de empezar a replicar los datos.
+ El modelo de recuperación debe establecerse en **Bulk logged** o **Full**.
+ No se admite el backup de SQL Server en varios discos. Si la copia de seguridad está definida para grabar la copia de seguridad de la base de datos en varios archivos en discos diferentes, no AWS DMS se pueden leer los datos y la AWS DMS tarea falla.
+ Para orígenes autoadministrados de SQL Server, las definiciones del publicador de replicación de SQL Server para el origen que se utiliza en una tarea de CDC de DMS no se eliminan cuando se elimina la tarea. Estas definiciones de SQL Server para orígenes autoadministrados las debe eliminar un administrador del sistema de SQL Server.
+ Durante la CDC, AWS DMS debe buscar las copias de seguridad del registro de transacciones de SQL Server para leer los cambios. AWS DMS no admite las copias de seguridad del registro de transacciones de SQL Server creadas con software de copia de seguridad de terceros que *no* esté en formato nativo. Para admitir las copias de seguridad del registro de transacciones que *están* en formato nativo y creadas con software de copia de seguridad de terceros, agregue el atributo de conexión `use3rdPartyBackupDevice=Y` al punto de conexión de origen.
+ Para orígenes autoadministrados de SQL Server, tenga en cuenta que SQL Server no captura los cambios en las tablas creadas recientemente hasta que se han publicado. Cuando se agregan tablas a una fuente de SQL Server, AWS DMS gestiona la creación de la publicación. Sin embargo, este proceso puede prolongarse algunos minutos. Las operaciones efectuadas en tablas de nueva creación durante este intervalo no se capturan ni replican en el destino. 
+ AWS DMS La captura de datos de cambios requiere que el registro completo de transacciones esté activado en SQL Server. Para activar el registro completo de transacciones en SQL Server, habilite MS-REPLICATION o CHANGE DATA CAPTURE (CDC).
+ Las entradas del *tlog* de SQL Server no se marcarán para su reutilización hasta que el trabajo de captura de MS CDC procese esos cambios.
+ Las operaciones de CDC no se admiten en las tablas con optimización para memoria. Esta restricción se aplica a SQL Server 2014 (cuando se ingresó por vez primera la característica) y a versiones superiores.
+ AWS DMS la captura de datos de cambios requiere una base de datos de distribución de forma predeterminada en Amazon EC2 o en un servidor SQL local como fuente. Por lo tanto, asegúrese de haber activado el distribuidor al configurar la replicación de MS para tablas con claves principales.

## Métodos de compresión admitidos para SQL Server
<a name="CHAP_Source.SQLServer.Compression"></a>

Tenga en cuenta lo siguiente acerca de la compatibilidad con los métodos de compresión de SQL Server en AWS DMS:
+ AWS DMS admite Row/Page la compresión en la versión 2008 y posteriores de SQL Server.
+ AWS DMS no admite el formato de almacenamiento Vardecimal.
+ AWS DMS no admite la compresión de columnas dispersas ni de estructuras columnares.

## Trabaja con grupos de disponibilidad de SQL Server autogestionados AlwaysOn
<a name="CHAP_Source.SQLServer.AlwaysOn"></a>

Los grupos de disponibilidad AlwaysOn de SQL Server proporcionan alta disponibilidad y recuperación de desastres que representa una alternativa a nivel empresarial a la duplicación de bases de datos. 

En AWS DMS, puede migrar los cambios desde una única réplica de un grupo de disponibilidad principal o secundario.

### Trabajo con la réplica del grupo de disponibilidad principal
<a name="CHAP_Source.SQLServer.AlwaysOn.Primary"></a>

 

**Para usar el grupo de disponibilidad principal como fuente de entrada AWS DMS, haga lo siguiente:**

1. Active la opción de distribución para todas las instancias de SQL Server en las réplicas de disponibilidad. Para obtener más información, consulte [Configurar la replicación continua en un SQL Server autoadministrado](CHAP_Source.SQLServer.CDC.md#CHAP_Source.SQLServer.CDC.MSCDC).

1. En la AWS DMS consola, abra la configuración de la base de datos de origen de SQL Server. Para **Nombre de servidor** especifique el nombre del servicio de nombres de dominio (DNS) o la dirección IP que se configuró para el oyente del grupo de disponibilidad. 

Al iniciar una AWS DMS tarea por primera vez, es posible que tarde más de lo habitual en iniciarse. Esta lentitud se produce porque el servidor de grupos de disponibilidad duplica la creación de los artículos de la tabla. 

### Trabajo con una réplica del grupo de disponibilidad secundario
<a name="CHAP_Source.SQLServer.AlwaysOn.Secondary"></a>

**Para usar un grupo de disponibilidad secundario como fuente de entrada AWS DMS, haga lo siguiente:**

1. Use las mismas credenciales para conectarse a réplicas individuales que usa el usuario del punto final AWS DMS de origen.

1. Asegúrese de que su instancia de AWS DMS replicación pueda resolver los nombres de DNS de todas las réplicas existentes y conéctese a ellas. Puede usar la siguiente consulta SQL para obtener los nombres de DNS de todas las réplicas.

   ```
   select ar.replica_server_name, ar.endpoint_url from sys.availability_replicas ar
   JOIN sys.availability_databases_cluster adc
   ON adc.group_id = ar.group_id AND adc.database_name = '<source_database_name>';
   ```

1. Al crear el punto de conexión de origen, especifique el nombre de DNS del oyente del grupo de disponibilidad para el **nombre del servidor** del punto de conexión o para la **dirección del servidor** secreto del punto de conexión. Para obtener más información sobre los oyentes de grupos de disponibilidad, consulte [¿Qué es un oyente de grupos de disponibilidad?](https://docs.microsoft.com/en-us/sql/database-engine/availability-groups/windows/availability-group-listener-overview?view=sql-server-ver15) en la documentación de SQL Server.

   Puede usar un servidor DNS público o un servidor DNS en las instalaciones para resolver el oyente del grupo de disponibilidad, la réplica principal y las réplicas secundarias. Para usar un servidor DNS en las instalaciones, configure Amazon Route 53 Resolver. Para obtener más información, consulte [Uso de su propio servidor de nombres en las instalaciones](CHAP_BestPractices.md#CHAP_BestPractices.Rte53DNSResolver).

1. Agregue los siguientes atributos de conexión adicionales al punto de conexión de origen.    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/dms/latest/userguide/CHAP_Source.SQLServer.html)

1. Habilite la opción de distribución en todas las réplicas del grupo de disponibilidad. Agregue todos los nodos a la lista de distribuidores. Para obtener más información, consulte [Configuración de la distribución](CHAP_Source.SQLServer.CDC.md#CHAP_Source.SQLServer.CDC.MSCDC.Setup).

1. Ejecute la siguiente consulta en la réplica de lectura y escritura principal para habilitar la publicación de la base de datos. Se ejecuta esta consulta solo una vez para la base de datos. 

   ```
   sp_replicationdboption @dbname = N'<source DB name>', @optname = N'publish', @value = N'true';
   ```



#### Limitaciones
<a name="CHAP_Source.SQLServer.AlwaysOn.Secondary.limitations"></a>

A continuación, se indican las limitaciones para trabajar con una réplica de grupo de disponibilidad secundario:
+ AWS DMS no es compatible con Safeguard cuando utiliza una réplica de un grupo de disponibilidad de solo lectura como fuente. Para obtener más información, consulte [Configuración del punto final cuando se utiliza SQL Server como fuente de AWS DMS](#CHAP_Source.SQLServer.ConnectionAttrib).
+ AWS DMS no admite el atributo de conexión `setUpMsCdcForTables` adicional cuando se utiliza una réplica de un grupo de disponibilidad de solo lectura como fuente. Para obtener más información, consulte [Configuración del punto final cuando se utiliza SQL Server como fuente de AWS DMS](#CHAP_Source.SQLServer.ConnectionAttrib).
+ AWS DMS puede utilizar una réplica autogestionada de un grupo de disponibilidad secundario como base de datos de origen para la replicación continua (captura de datos de cambios o CDC) a partir de la versión 3.4.7. No se admiten réplicas de lectura Multi-AZ de SQL Server en la nube. Si usa versiones anteriores de AWS DMS, asegúrese de usar la réplica del grupo de disponibilidad principal como base de datos de origen para los CDC.

#### Conmutación por error a otros nodos
<a name="CHAP_Source.SQLServer.AlwaysOn.Secondary.failover"></a>

Si establece el atributo de conexión `ApplicationIntent` adicional para su terminal en`ReadOnly`, la AWS DMS tarea se conecta al nodo de solo lectura con la prioridad de enrutamiento de solo lectura más alta. A continuación, se conmuta por error a otros nodos de solo lectura en el grupo de disponibilidad cuando el nodo de solo lectura de mayor prioridad no está disponible. Si no lo estableces`ApplicationIntent`, la AWS DMS tarea solo se conecta al nodo principal (lectura/escritura) de tu grupo de disponibilidad.

## Configuración del punto final cuando se utiliza SQL Server como fuente de AWS DMS
<a name="CHAP_Source.SQLServer.ConnectionAttrib"></a>

Puede utilizar la configuración de punto de conexión para configurar la base de datos de origen de SQL Server de forma similar al uso de atributos de conexión adicionales. Los ajustes se especifican al crear el punto final de origen mediante la AWS DMS consola o mediante el `create-endpoint` comando del [AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/dms/index.html), con la sintaxis `--microsoft-sql-server-settings '{"EndpointSetting": "value", ...}'` JSON.

La siguiente tabla muestra la configuración de punto de conexión que puede utilizar con SQL Server como origen.

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/dms/latest/userguide/CHAP_Source.SQLServer.html)

## Tipos de datos de origen para SQL Server
<a name="CHAP_Source.SQLServer.DataTypes"></a>

La migración de datos que utiliza SQL Server como fuente AWS DMS es compatible con la mayoría de los tipos de datos de SQL Server. La siguiente tabla muestra los tipos de datos de origen de SQL Server que se admiten cuando se utilizan AWS DMS y la asignación predeterminada a partir de AWS DMS los tipos de datos.

Para obtener más información sobre cómo ver el tipo de datos que se asigna en el destino, consulte la sección del punto de enlace de destino que esté utilizando.

Para obtener información adicional sobre AWS DMS los tipos de datos, consulte[Tipos de datos de AWS Database Migration Service](CHAP_Reference.DataTypes.md).


|  Tipos de datos de SQL Server  |  AWS DMS tipos de datos  | 
| --- | --- | 
|  BIGINT  |  INT8  | 
|  BIT  |  BOOLEANO  | 
|  DECIMAL  |  NUMERIC  | 
|  INT  |  INT4  | 
|  MONEY  |  NUMERIC  | 
|  NUMERIC (p,s)  |  NUMERIC   | 
|  SMALLINT  |  INT2  | 
|  SMALLMONEY  |  NUMERIC  | 
|  TINYINT  |  UINT1  | 
|  REAL  |  REAL4  | 
|  FLOAT  |  REAL8  | 
|  DATETIME  |  DATETIME  | 
|  DATETIME2 (SQL Server 2008 y versiones posteriores)  |  DATETIME  | 
|  SMALLDATETIME  |  DATETIME  | 
|  DATE  |  DATE  | 
|  TIME  |  TIME  | 
|  DATETIMEOFFSET  |  WSTRING  | 
|  CHAR  |  STRING  | 
|  VARCHAR  |  STRING  | 
|  VARCHAR (máx.)  |  CLOB TEXT Para usar este tipo de datos con AWS DMS, debe habilitar el uso de tipos de datos CLOB para una tarea específica. En el caso de las tablas de SQL Server, AWS DMS actualiza las columnas LOB del destino incluso para las instrucciones UPDATE que no cambian el valor de la columna LOB en SQL Server. Durante la CDC, solo AWS DMS admite los tipos de datos CLOB en las tablas que incluyen una clave principal.  | 
|  NCHAR  |  WSTRING  | 
|  NVARCHAR (longitud)  |  WSTRING  | 
|  NVARCHAR (máx.)  |  NCLOB NTEXT Para usar este tipo de datos con AWS DMS, debe habilitar el uso de SupportLobs para una tarea específica. Para obtener más información acerca de cómo habilitar la compatibilidad con LOB, consulte [Configurar la compatibilidad con LOB para las bases de datos de origen de una tarea AWS DMS](CHAP_Tasks.LOBSupport.md).  En el caso de las tablas de SQL Server, AWS DMS actualiza las columnas LOB del destino, incluso para las instrucciones UPDATE que no cambian el valor de la columna LOB de SQL Server. Durante la CDC, solo AWS DMS admite los tipos de datos CLOB en las tablas que incluyen una clave principal.  | 
|  BINARIO  |  BYTES  | 
|  VARBINARY  |  BYTES  | 
|  VARBINARY (máx.)  |  BLOB IMAGE En el caso de las tablas de SQL Server, AWS DMS actualiza las columnas LOB del destino, incluso para las instrucciones UPDATE que no cambian el valor de la columna LOB en SQL Server. Para usar este tipo de datos con AWS DMS, debe habilitar el uso de tipos de datos BLOB para una tarea específica. AWS DMS solo admite los tipos de datos BLOB en las tablas que incluyen una clave principal.  | 
|  TIMESTAMP  |  BYTES  | 
|  UNIQUEIDENTIFIER  |  STRING  | 
|  HIERARCHYID   |  Utilice HIERARCHYID cuando realice replicaciones en un punto de enlace de destino de SQL Server. Utilice WSTRING (250) para realizar replicaciones en el resto de puntos de enlace.  | 
|  XML  |  NCLOB En el caso de las tablas de SQL Server, AWS DMS actualiza las columnas LOB del destino incluso para las instrucciones UPDATE que no cambian el valor de la columna LOB en SQL Server. Para usar este tipo de datos con AWS DMS, debe habilitar el uso de los tipos de datos NCLOB para una tarea específica. Durante los CDC, solo AWS DMS admite los tipos de datos NCLOB en las tablas que incluyen una clave principal.  | 
|  GEOMETRY  |  Utilice GEOMETRY cuando realice replicaciones en puntos de enlace de destino que admitan este tipo de datos. Utilice CLOB cuando realice replicaciones en puntos de enlace de destino que no admitan este tipo de datos.  | 
|  GEOGRAPHY  |  Utilice GEOGRAPHY cuando realice replicaciones en puntos de enlace de destino que admitan este tipo de datos. Utilice CLOB cuando realice replicaciones en puntos de enlace de destino que no admitan este tipo de datos.  | 

AWS DMS no admite tablas que incluyan campos con los siguientes tipos de datos. 
+ CURSOR
+ SQL\$1VARIANT
+ TABLE

**nota**  
Se admiten tipos de datos definidos por el usuario en función de su tipo base. Por ejemplo, un tipo de datos definido por el usuario basado en DATETIME se gestiona como un tipo de datos DATETIME.

# Captura de cambios en los datos para la replicación continua desde SQL Server
<a name="CHAP_Source.SQLServer.CDC"></a>

Este tema describe cómo configurar la replicación de CDC en un origen de SQL Server.

**Topics**
+ [Captura de cambios de datos para SQL Server autoadministrado en las instalaciones o en Amazon EC2](#CHAP_Source.SQLServer.CDC.Selfmanaged)
+ [Configuración de la replicación continua en una instancia de base de datos de SQL Server de la nube](#CHAP_Source.SQLServer.Configuration)

## Captura de cambios de datos para SQL Server autoadministrado en las instalaciones o en Amazon EC2
<a name="CHAP_Source.SQLServer.CDC.Selfmanaged"></a>

Para capturar los cambios de una base de datos de origen de Microsoft SQL Server, asegúrese de que la base de datos esté configurada para realizar copias de seguridad completas. Configure la base de datos en modo de recuperación total o en modo de registro masivo.

Para una fuente de SQL Server autogestionada, AWS DMS utiliza lo siguiente:

**Replicación de MS**  
Para capturar cambios para las tablas con las claves principales. Puede configurarlo automáticamente otorgando privilegios de administrador del sistema al usuario de AWS DMS punto final en la instancia de SQL Server de origen. O bien, puede seguir los pasos de esta sección para preparar la fuente y utilizar un usuario que no tenga privilegios de administrador de sistemas para el punto final. AWS DMS 

**MS-CDC**  
Para capturar cambios para las tablas sin las claves principales. Habilite MS-CDC en el nivel de base de datos y para todas las tablas de forma individual.

Al configurar una base de datos de SQL Server para replicación continua (CDC), puede elegir una de las siguientes opciones:
+ Configurar la replicación continua con el rol sysadmin.
+ Configurar la replicación continua para que no se utilice el rol sysadmin.

**nota**  
Puede usar el siguiente script para buscar todas las tablas sin una clave principal o única:  

```
USE [DBname]
SELECT SCHEMA_NAME(schema_id) AS schema_name, name AS table_name
FROM sys.tables
WHERE OBJECTPROPERTY(object_id, 'TableHasPrimaryKey') = 0
        AND  OBJECTPROPERTY(object_id, 'TableHasUniqueCnst') = 0
ORDER BY schema_name, table_name;
```

### Configurar la replicación continua en un SQL Server autoadministrado
<a name="CHAP_Source.SQLServer.CDC.MSCDC"></a>

Esta sección contiene información sobre cómo configurar la replicación continua en un SQL Server autoadministrado con o sin el rol sysadmin.

**Topics**
+ [Configuración de la replicación continua en un SQL Server autoadministrado: uso del rol sysadmin](#CHAP_Source.SQLServer.CDC.MSCDC.Sysadmin)
+ [Configuración de la replicación continua en un SQL Server independiente: sin el rol de sysadmin](#CHAP_SupportScripts.SQLServer.standalone)
+ [Configuración de la replicación continua en un SQL Server en un entorno de grupos de disponibilidad: sin el rol de sysadmin](#CHAP_SupportScripts.SQLServer.ag)

#### Configuración de la replicación continua en un SQL Server autoadministrado: uso del rol sysadmin
<a name="CHAP_Source.SQLServer.CDC.MSCDC.Sysadmin"></a>

AWS DMS la replicación continua para SQL Server utiliza la replicación nativa de SQL Server para las tablas con claves principales y la captura de datos de cambios (CDC) para las tablas sin claves principales.

Antes de configurar la replicación continua, consulte [Requisitos previos para el uso de la replicación continua (CDC) desde un origen de SQL Server](CHAP_Source.SQLServer.md#CHAP_Source.SQLServer.Prerequisites). 

En el caso de las tablas con claves principales, generalmente se AWS DMS pueden configurar los artefactos necesarios en la fuente. Sin embargo, para las instancias de origen de SQL Server autoadministradas, asegúrese de configurar primero la distribución de SQL Server de forma manual. Una vez hecho esto, los usuarios de AWS DMS origen con permisos de administrador del sistema pueden crear automáticamente la publicación para las tablas con claves principales.

Para comprobar si la distribución ya se ha configurado, ejecute el siguiente comando.

```
sp_get_distributor
```

Si el resultado es `NULL` para la distribución de columnas, la distribución no se ha configurado. Puede usar el siguiente procedimiento para configurar la distribución.<a name="CHAP_Source.SQLServer.CDC.MSCDC.Setup"></a>

**Configuración de la distribución**

1. Conéctese a la base de datos de origen de SQL Server mediante la herramienta SQL Server Management Studio (SSMS).

1. Abra el menú contextual (haga clic con el botón derecho) para la carpeta **Replicación** y elija **Configurar distribución**. Aparecerá el asistente para configurar la distribución. 

1. Siga el asistente para especificar los valores predeterminados y crear la distribución.<a name="CHAP_Source.SQLServer.CDC.MSCDC.Setup.CDC"></a>

**Configuración de CDC**

AWS DMS La versión 3.4.7 y las versiones posteriores permiten configurar MS CDC para su base de datos y todas sus tablas automáticamente si no utiliza una réplica de solo lectura. Para utilizar esta característica, establezca ECA `SetUpMsCdcForTables` como verdadero. Para obtener información al respecto, consulte ECAs. [Configuración del punto de conexión](CHAP_Source.SQLServer.md#CHAP_Source.SQLServer.ConnectionAttrib)

Para versiones AWS DMS anteriores a la 3.4.7 o para una réplica de solo lectura como fuente, lleve a cabo los siguientes pasos:

1. Para las tablas sin claves principales, configure MS-CDC para la base de datos. Para ello, utilice una cuenta que tenga asignado el rol sysadmin y ejecute el siguiente comando.

   ```
   use [DBname]
   EXEC sys.sp_cdc_enable_db
   ```

1. A continuación, configure MS-CDC para cada una de las tablas de origen. Para cada tabla con claves únicas pero sin clave principal, ejecute la siguiente consulta para la que desee configurar MS-CDC.

   ```
   exec sys.sp_cdc_enable_table
   @source_schema = N'schema_name',
   @source_name = N'table_name',
   @index_name = N'unique_index_name',
   @role_name = NULL,
   @supports_net_changes = 1
   GO
   ```

1. Para cada tabla sin claves principales ni claves únicas, ejecute la siguiente consulta para la que desee configurar MS-CDC.

   ```
   exec sys.sp_cdc_enable_table
   @source_schema = N'schema_name',
   @source_name = N'table_name',
   @role_name = NULL
   GO
   ```

Para obtener más información sobre cómo configurar MS-CDC para tablas específicas, consulte la documentación de [SQL Server](https://msdn.microsoft.com/en-us/library/cc627369.aspx). 

#### Configuración de la replicación continua en un SQL Server independiente: sin el rol de sysadmin
<a name="CHAP_SupportScripts.SQLServer.standalone"></a>

Esta sección describe cómo configurar la replicación continua para un origen de base de datos de SQL Server independiente que no requiera que la cuenta de usuario tenga privilegios de sysadmin.

**nota**  
Tras ejecutar los pasos de esta sección, el usuario de DMS que no sea administrador de sistemas tendrá permisos para hacer lo siguiente:  
Lea los cambios del archivo de registro de transacciones en línea
Acceso al disco para leer los cambios de los archivos de copia de seguridad del registro transaccional
Añadir o modificar la publicación que utiliza DMS
Añadir artículos a la publicación

1. Configure Microsoft SQL Server para la replicación como se describe en [Captura de cambios en los datos para la replicación continua desde SQL Server](#CHAP_Source.SQLServer.CDC).

1. Habilite MS-REPLICATION en la base de datos de origen. Esto se puede hacer manualmente o ejecutando la tarea una vez como usuario sysadmin.

1. Cree el esquema de `awsdms` en la base de datos de origen mediante el siguiente script:

   ```
   use master
   go
   create schema awsdms
   go
   
   
   -- Create the table valued function [awsdms].[split_partition_list] on the Master database, as follows:
   USE [master]
   GO
   
   set ansi_nulls on
   go
   
   set quoted_identifier on
   go
   
   if (object_id('[awsdms].[split_partition_list]','TF')) is not null
   
   drop function [awsdms].[split_partition_list];
   
   go
   
   create function [awsdms].[split_partition_list]
   
   (
   
   @plist varchar(8000), --A delimited list of partitions
   
   @dlm nvarchar(1) --Delimiting character
   
   )
   
   returns @partitionsTable table --Table holding the BIGINT values of the string fragments
   
   (
   
   pid bigint primary key
   
   )   
   
   as
   
   begin
   
   declare @partition_id bigint;
   
   declare @dlm_pos integer;
   
   declare @dlm_len integer;
   
   set @dlm_len = len(@dlm);
   
   while (charindex(@dlm,@plist)>0)
   
   begin
   
   set @dlm_pos = charindex(@dlm,@plist);
   
   set @partition_id = cast( ltrim(rtrim(substring(@plist,1,@dlm_pos-1))) as bigint);
   
   insert into @partitionsTable (pid) values (@partition_id)
   
   set @plist = substring(@plist,@dlm_pos+@dlm_len,len(@plist));
   
   end
   
   set @partition_id = cast (ltrim(rtrim(@plist)) as bigint);
   
   insert into @partitionsTable (pid) values ( @partition_id );
   
   return
   
   end
   
   GO
   ```

1. Cree el procedimiento `[awsdms].[rtm_dump_dblog]` en la base de datos maestra mediante el siguiente script:

   ```
   use [MASTER]
   
   go
   
   if (object_id('[awsdms].[rtm_dump_dblog]','P')) is not null drop procedure [awsdms].[rtm_dump_dblog];
   go
   
   
   set ansi_nulls on
   go
   
   set quoted_identifier on
   GO
   
   
   
   CREATE procedure [awsdms].[rtm_dump_dblog]
   
   (
   
   @start_lsn varchar(32),
   
   @seqno integer,
   
   @filename varchar(260),
   
   @partition_list varchar(8000), -- A comma delimited list: P1,P2,... Pn
   
   @programmed_filtering integer,
   
   @minPartition bigint,
   
   @maxPartition bigint
   
   )
   
   as begin
   
   declare @start_lsn_cmp varchar(32); -- Stands against the GT comparator
   
   SET NOCOUNT ON -- – Disable "rows affected display"
   
   set @start_lsn_cmp = @start_lsn;
   
   if (@start_lsn_cmp) is null
   
   set @start_lsn_cmp = '00000000:00000000:0000';
   
   if (@partition_list is null)
   
   begin
   
   RAISERROR ('Null partition list waspassed',16,1);
   
   return
   
   end
   
   if (@start_lsn) is not null
   
   set @start_lsn = '0x'+@start_lsn;
   
   if (@programmed_filtering=0)
   
   
   
   SELECT
   
   [Current LSN],
   
   [operation],
   
   [Context],
   
   [Transaction ID],
   
   [Transaction Name],
   
   [Begin Time],
   
   [End Time],
   
   [Flag Bits],
   
   [PartitionID],
   
   [Page ID],
   
   [Slot ID],
   
   [RowLog Contents 0],
   
   [Log Record],
   
   [RowLog Contents 1]
   
   FROM
   
   fn_dump_dblog (
   
   @start_lsn, NULL, N'DISK', @seqno, @filename,
   
   default, default, default, default, default, default, default,
   
   default, default, default, default, default, default, default,
   
   default, default, default, default, default, default, default,
   
   default, default, default, default, default, default, default,
   
   default, default, default, default, default, default, default,
   
   default, default, default, default, default, default, default,
   
   default, default, default, default, default, default, default,
   
   default, default, default, default, default, default, default,
   
   default, default, default, default, default, default, default)
   
   where [Current LSN] collate SQL_Latin1_General_CP1_CI_AS > @start_lsn_cmp collate SQL_Latin1_General_CP1_CI_AS
   
   and
   
   (
   
   ( [operation] in ('LOP_BEGIN_XACT','LOP_COMMIT_XACT','LOP_ABORT_XACT') )
   
   or
   
   ( [operation] in ('LOP_INSERT_ROWS','LOP_DELETE_ROWS','LOP_MODIFY_ROW')
   
   and
   
   ( ( [context] in ('LCX_HEAP','LCX_CLUSTERED','LCX_MARK_AS_GHOST') ) or ([context] = 'LCX_TEXT_MIX' and (datalength([RowLog Contents 0]) in (0,1))))
   
   and [PartitionID] in ( select * from master.awsdms.split_partition_list (@partition_list,','))
   
   )
   
   or
   
   ([operation] = 'LOP_HOBT_DDL')
   
   )
   
   
   else
   
   
   SELECT
   
   [Current LSN],
   
   [operation],
   
   [Context],
   
   [Transaction ID],
   
   [Transaction Name],
   
   [Begin Time],
   
   [End Time],
   
   [Flag Bits],
   
   [PartitionID],
   
   [Page ID],
   
   [Slot ID],
   
   [RowLog Contents 0],
   
   [Log Record],
   
   [RowLog Contents 1] -- After Image
   
   FROM
   
   fn_dump_dblog (
   
   @start_lsn, NULL, N'DISK', @seqno, @filename,
   
   default, default, default, default, default, default, default,
   
   default, default, default, default, default, default, default,
   
   default, default, default, default, default, default, default,
   
   default, default, default, default, default, default, default,
   
   default, default, default, default, default, default, default,
   
   default, default, default, default, default, default, default,
   
   default, default, default, default, default, default, default,
   
   default, default, default, default, default, default, default,
   
   default, default, default, default, default, default, default)
   
   where [Current LSN] collate SQL_Latin1_General_CP1_CI_AS > @start_lsn_cmp collate SQL_Latin1_General_CP1_CI_AS
   
   and
   
   (
   
   ( [operation] in ('LOP_BEGIN_XACT','LOP_COMMIT_XACT','LOP_ABORT_XACT') )
   
   or
   
   ( [operation] in ('LOP_INSERT_ROWS','LOP_DELETE_ROWS','LOP_MODIFY_ROW')
   
   and
   
   ( ( [context] in ('LCX_HEAP','LCX_CLUSTERED','LCX_MARK_AS_GHOST') ) or ([context] = 'LCX_TEXT_MIX' and (datalength([RowLog Contents 0]) in (0,1))))
   
   and ([PartitionID] is not null) and ([PartitionID] >= @minPartition and [PartitionID]<=@maxPartition)
   
   )
   
   or
   
   ([operation] = 'LOP_HOBT_DDL')
   
   )
   
   
   
   SET NOCOUNT OFF -- Re-enable "rows affected display"
   
   end
   
   GO
   ```

1. Cree el certificado en la base de datos maestra mediante el siguiente script:

   ```
   Use [master]
   Go
   
   CREATE CERTIFICATE [awsdms_rtm_dump_dblog_cert] ENCRYPTION BY PASSWORD = N'@5trongpassword'
   
   WITH SUBJECT = N'Certificate for FN_DUMP_DBLOG Permissions';
   ```

1. Cree el inicio de sesión del certificado mediante el siguiente script: 

   ```
   Use [master]
   Go
   
   CREATE LOGIN awsdms_rtm_dump_dblog_login FROM CERTIFICATE [awsdms_rtm_dump_dblog_cert];
   ```

1. Agregue el inicio de sesión al rol del servidor de sysadmin mediante el siguiente script:

   ```
   ALTER SERVER ROLE [sysadmin] ADD MEMBER [awsdms_rtm_dump_dblog_login];
   ```

1. Agregue la firma a [master].[awsdms].[rtm\$1dump\$1dblog] con el certificado, mediante el siguiente script: 

   ```
   Use [master]
   GO
   ADD SIGNATURE
   TO [master].[awsdms].[rtm_dump_dblog] BY CERTIFICATE [awsdms_rtm_dump_dblog_cert] WITH PASSWORD = '@5trongpassword';
   ```
**nota**  
Si vuelve a crear el procedimiento almacenado, tendrá que volver a agregar la firma.

1. Cree [awsdms]. [rtm\$1position\$11st\$1timestamp] en la base de datos maestra mediante el siguiente script:

   ```
   use [master]
       if object_id('[awsdms].[rtm_position_1st_timestamp]','P') is not null
       DROP PROCEDURE [awsdms].[rtm_position_1st_timestamp];
       go
       create procedure [awsdms].[rtm_position_1st_timestamp]
       (
       @dbname                sysname,      -- Database name
       @seqno                 integer,      -- Backup set sequence/position number within file
       @filename              varchar(260), -- The backup filename
       @1stTimeStamp          varchar(40)   -- The timestamp to position by
       ) 
       as begin
   
       SET NOCOUNT ON       -- Disable "rows affected display"
   
       declare @firstMatching table
       (
       cLsn varchar(32),
       bTim datetime
       )
   
       declare @sql nvarchar(4000)
       declare @nl                       char(2)
       declare @tb                       char(2)
       declare @fnameVar                 nvarchar(254) = 'NULL'
   
       set @nl  = char(10); -- New line
       set @tb  = char(9)   -- Tab separator
   
       if (@filename is not null)
       set @fnameVar = ''''+@filename +''''
   
       set @sql='use ['+@dbname+'];'+@nl+
       'select top 1 [Current LSN],[Begin Time]'+@nl+
       'FROM fn_dump_dblog (NULL, NULL, NULL, '+ cast(@seqno as varchar(10))+','+ @fnameVar+','+@nl+
       @tb+'default, default, default, default, default, default, default,'+@nl+
       @tb+'default, default, default, default, default, default, default,'+@nl+
       @tb+'default, default, default, default, default, default, default,'+@nl+
       @tb+'default, default, default, default, default, default, default,'+@nl+
       @tb+'default, default, default, default, default, default, default,'+@nl+
       @tb+'default, default, default, default, default, default, default,'+@nl+
       @tb+'default, default, default, default, default, default, default,'+@nl+
       @tb+'default, default, default, default, default, default, default,'+@nl+
       @tb+'default, default, default, default, default, default, default)'+@nl+
       'where operation=''LOP_BEGIN_XACT''' +@nl+
       'and [Begin Time]>= cast('+''''+@1stTimeStamp+''''+' as datetime)'+@nl
   
       --print @sql
       delete from  @firstMatching 
       insert into @firstMatching  exec sp_executesql @sql    -- Get them all
   
       select top 1 cLsn as [matching LSN],convert(varchar,bTim,121) as [matching Timestamp] from @firstMatching;
   
       SET NOCOUNT OFF      -- Re-enable "rows affected display"
   
       end
       GO
   ```

1. Cree el certificado en la base de datos maestra mediante el siguiente script:

   ```
   Use [master]
   Go
   CREATE CERTIFICATE [awsdms_rtm_position_1st_timestamp_cert]
   ENCRYPTION BY PASSWORD = '@5trongpassword'
   WITH SUBJECT = N'Certificate for FN_POSITION_1st_TIMESTAMP Permissions';
   ```

1. Cree el inicio de sesión del certificado mediante el siguiente script:

   ```
   Use [master]
   Go
   CREATE LOGIN awsdms_rtm_position_1st_timestamp_login FROM CERTIFICATE [awsdms_rtm_position_1st_timestamp_cert];
   ```

1. Agregue el inicio de sesión al rol de sysadmin mediante el siguiente script:

   ```
   ALTER SERVER ROLE [sysadmin] ADD MEMBER [awsdms_rtm_position_1st_timestamp_login];
   ```

1. Agregue la firma a [master].[awsdms].[rtm\$1position\$11st\$1timestamp] con el certificado, mediante el siguiente script:

   ```
   Use [master]
       GO
       ADD SIGNATURE
       TO [master].[awsdms].[rtm_position_1st_timestamp]
       BY CERTIFICATE [awsdms_rtm_position_1st_timestamp_cert]
       WITH PASSWORD = '@5trongpassword';
   ```

1. Conceda al usuario de DMS acceso de ejecución al nuevo procedimiento almacenado mediante el siguiente script:

   ```
   use master
   go
   GRANT execute on [awsdms].[rtm_position_1st_timestamp] to dms_user;
   ```

1. Cree un usuario con los siguientes permisos y roles en cada una de las siguientes bases de datos:
**nota**  
Debe crear la cuenta de usuario dmsnosysadmin con el mismo SID en cada réplica. La siguiente consulta SQL puede ayudar a comprobar el valor del SID de la cuenta dmsnosysadmin en cada réplica. Para obtener más información sobre la creación de un usuario, consulte [CREATE USER (Transact-SQL)](https://learn.microsoft.com/en-us/sql/t-sql/statements/create-user-transact-sql) en la [documentación de Microsoft SQL Server](https://learn.microsoft.com/en-us/sql/). Para obtener más información sobre la creación de cuentas de usuario de SQL para la base de datos de Azure SQL, consulte [Replicación geográfica activa](https://learn.microsoft.com/en-us/azure/azure-sql/database/active-geo-replication-overview).

   ```
   use master
   go
   grant select on sys.fn_dblog to [DMS_user]
   grant view any definition to [DMS_user]
   grant view server state to [DMS_user]--(should be granted to the login).
   grant execute on sp_repldone to [DMS_user]
   grant execute on sp_replincrementlsn to [DMS_user]
   grant execute on sp_addpublication to [DMS_user]
   grant execute on sp_addarticle to [DMS_user]
   grant execute on sp_articlefilter to [DMS_user]
   grant select on [awsdms].[split_partition_list] to [DMS_user]
   grant execute on [awsdms].[rtm_dump_dblog] to [DMS_user]
   ```

   ```
   use msdb
   go
   grant select on msdb.dbo.backupset to self_managed_user
   grant select on msdb.dbo.backupmediafamily to self_managed_user
   grant select on msdb.dbo.backupfile to self_managed_user
   ```

   Ejecute el siguiente script en la base de datos de origen:

   ```
   use Source_DB
       Go
       EXEC sp_addrolemember N'db_owner', N'DMS_user'
   ```

1. Por último, agregue un atributo de conexión adicional (ECA) al punto de conexión de SQL Server de origen:

   ```
   enableNonSysadminWrapper=true;
   ```

#### Configuración de la replicación continua en un SQL Server en un entorno de grupos de disponibilidad: sin el rol de sysadmin
<a name="CHAP_SupportScripts.SQLServer.ag"></a>

En esta sección se describe cómo configurar la replicación continua para un origen de base de datos de SQL Server en un entorno de grupo de disponibilidad que no requiera que la cuenta de usuario tenga privilegios de sysadmin.

**nota**  
Tras ejecutar los pasos de esta sección, el usuario de DMS que no sea administrador de sistemas tendrá permisos para hacer lo siguiente:  
Lea los cambios del archivo de registro de transacciones en línea
Acceso al disco para leer los cambios de los archivos de copia de seguridad del registro transaccional
Añadir o modificar la publicación que utiliza DMS
Añadir artículos a la publicación

**Configuración de la replicación continua sin usar el usuario sysadmin en un entorno de grupos de disponibilidad**

1. Configure Microsoft SQL Server para la replicación como se describe en [Captura de cambios en los datos para la replicación continua desde SQL Server](#CHAP_Source.SQLServer.CDC).

1. Habilite MS-REPLICATION en la base de datos de origen. Esto se puede hacer manualmente o ejecutando la tarea una vez mediante un usuario sysadmin.
**nota**  
Debe configurar el distribuidor de MS-REPLICATION como local o de forma que permita el acceso a los usuarios que no sean sysadmin a través del servidor vinculado asociado.

1. Si la opción de punto de conexión **Usar exclusivamente sp\$1repldone en una tarea única** está habilitada, detenga el trabajo del lector de registros de MS-REPLICATION.

1. Realice los siguientes pasos en cada réplica:

   1. Cree el esquema `[awsdms]`[awsdms] en la base de datos maestra:

      ```
      CREATE SCHEMA [awsdms]
      ```

   1. Cree la función con valor de tabla `[awsdms].[split_partition_list]` en la base de datos maestra:

      ```
      USE [master]
      GO
      
      SET ansi_nulls on
      GO
        
      SET quoted_identifier on
      GO
      
      IF (object_id('[awsdms].[split_partition_list]','TF')) is not null
        DROP FUNCTION [awsdms].[split_partition_list];
      GO
      
      CREATE FUNCTION [awsdms].[split_partition_list] 
      ( 
        @plist varchar(8000),    --A delimited list of partitions    
        @dlm nvarchar(1)    --Delimiting character
      ) 
      RETURNS @partitionsTable table --Table holding the BIGINT values of the string fragments
      (
        pid bigint primary key
      ) 
      AS 
      BEGIN
        DECLARE @partition_id bigint;
        DECLARE @dlm_pos integer;
        DECLARE @dlm_len integer;  
        SET @dlm_len = len(@dlm);
        WHILE (charindex(@dlm,@plist)>0)
        BEGIN 
          SET @dlm_pos = charindex(@dlm,@plist);
          SET @partition_id = cast( ltrim(rtrim(substring(@plist,1,@dlm_pos-1))) as bigint);
          INSERT into @partitionsTable (pid) values (@partition_id)
          SET @plist = substring(@plist,@dlm_pos+@dlm_len,len(@plist));
        END 
        SET @partition_id = cast (ltrim(rtrim(@plist)) as bigint);
        INSERT into @partitionsTable (pid) values (  @partition_id  );
        RETURN
      END
      GO
      ```

   1. Cree el procedimiento `[awsdms].[rtm_dump_dblog]` en la base de datos maestra:

      ```
      USE [MASTER] 
      GO
      
      IF (object_id('[awsdms].[rtm_dump_dblog]','P')) is not null
        DROP PROCEDURE [awsdms].[rtm_dump_dblog]; 
      GO
      
      SET ansi_nulls on
      GO 
      
      SET quoted_identifier on 
      GO
                                          
      CREATE PROCEDURE [awsdms].[rtm_dump_dblog]
      (
        @start_lsn            varchar(32),
        @seqno                integer,
        @filename             varchar(260),
        @partition_list       varchar(8000), -- A comma delimited list: P1,P2,... Pn
        @programmed_filtering integer,
        @minPartition         bigint,
        @maxPartition         bigint
      ) 
      AS 
      BEGIN
      
        DECLARE @start_lsn_cmp varchar(32); -- Stands against the GT comparator
      
        SET NOCOUNT ON  -- Disable "rows affected display"
      
        SET @start_lsn_cmp = @start_lsn;
        IF (@start_lsn_cmp) is null
          SET @start_lsn_cmp = '00000000:00000000:0000';
      
        IF (@partition_list is null)
          BEGIN
            RAISERROR ('Null partition list was passed',16,1);
            return
            --set @partition_list = '0,';    -- A dummy which is never matched
          END
      
        IF (@start_lsn) is not null
          SET @start_lsn = '0x'+@start_lsn;
      
        IF (@programmed_filtering=0)
          SELECT
            [Current LSN],
            [operation],
            [Context],
            [Transaction ID],
            [Transaction Name],
            [Begin Time],
            [End Time],
            [Flag Bits],
            [PartitionID],
            [Page ID],
            [Slot ID],
            [RowLog Contents 0],
            [Log Record],
            [RowLog Contents 1] -- After Image
          FROM
            fn_dump_dblog (
              @start_lsn, NULL, N'DISK', @seqno, @filename,
              default, default, default, default, default, default, default,
              default, default, default, default, default, default, default,
              default, default, default, default, default, default, default,
              default, default, default, default, default, default, default,
              default, default, default, default, default, default, default,
              default, default, default, default, default, default, default,
              default, default, default, default, default, default, default,
              default, default, default, default, default, default, default,
              default, default, default, default, default, default, default)
          WHERE 
            [Current LSN] collate SQL_Latin1_General_CP1_CI_AS > @start_lsn_cmp collate SQL_Latin1_General_CP1_CI_AS -- This aims for implementing FN_DBLOG based on GT comparator.
            AND
            (
              (  [operation] in ('LOP_BEGIN_XACT','LOP_COMMIT_XACT','LOP_ABORT_XACT') )
              OR
              (  [operation] in ('LOP_INSERT_ROWS','LOP_DELETE_ROWS','LOP_MODIFY_ROW')
                AND
                ( ( [context]   in ('LCX_HEAP','LCX_CLUSTERED','LCX_MARK_AS_GHOST') ) or ([context] = 'LCX_TEXT_MIX') )
                AND       
                [PartitionID] in ( select * from master.awsdms.split_partition_list (@partition_list,','))
              )
            OR
            ([operation] = 'LOP_HOBT_DDL')
          )
          ELSE
            SELECT
              [Current LSN],
              [operation],
              [Context],
              [Transaction ID],
              [Transaction Name],
              [Begin Time],
              [End Time],
              [Flag Bits],
              [PartitionID],
              [Page ID],
              [Slot ID],
              [RowLog Contents 0],
              [Log Record],
              [RowLog Contents 1] -- After Image
            FROM
              fn_dump_dblog (
                @start_lsn, NULL, N'DISK', @seqno, @filename,
                default, default, default, default, default, default, default,
                default, default, default, default, default, default, default,
                default, default, default, default, default, default, default,
                default, default, default, default, default, default, default,
                default, default, default, default, default, default, default,
                default, default, default, default, default, default, default,
                default, default, default, default, default, default, default,
                default, default, default, default, default, default, default,
                default, default, default, default, default, default, default)
            WHERE [Current LSN] collate SQL_Latin1_General_CP1_CI_AS > @start_lsn_cmp collate SQL_Latin1_General_CP1_CI_AS -- This aims for implementing FN_DBLOG based on GT comparator.
            AND
            (
              (  [operation] in ('LOP_BEGIN_XACT','LOP_COMMIT_XACT','LOP_ABORT_XACT') )
              OR
              (  [operation] in ('LOP_INSERT_ROWS','LOP_DELETE_ROWS','LOP_MODIFY_ROW')
                AND
                ( ( [context]   in ('LCX_HEAP','LCX_CLUSTERED','LCX_MARK_AS_GHOST') ) or ([context] = 'LCX_TEXT_MIX') )
                AND ([PartitionID] is not null) and ([PartitionID] >= @minPartition and [PartitionID]<=@maxPartition)
              )
              OR
              ([operation] = 'LOP_HOBT_DDL')
            )
            SET NOCOUNT OFF -- Re-enable "rows affected display"
      END
      GO
      ```

   1. Cree un certificado en la base de datos maestra:

      ```
      USE [master]
      GO
      CREATE CERTIFICATE [awsdms_rtm_dump_dblog_cert]
        ENCRYPTION BY PASSWORD = N'@hardpassword1'
        WITH SUBJECT = N'Certificate for FN_DUMP_DBLOG Permissions'
      ```

   1. Cree un inicio de sesión desde el certificado:

      ```
      USE [master]
      GO
      CREATE LOGIN awsdms_rtm_dump_dblog_login FROM CERTIFICATE
        [awsdms_rtm_dump_dblog_cert];
      ```

   1. Agregue el inicio de sesión al rol del servidor sysadmin:

      ```
      ALTER SERVER ROLE [sysadmin] ADD MEMBER [awsdms_rtm_dump_dblog_login];
      ```

   1. Agregue la firma al procedimiento [master].[awsdms].[rtm\$1dump\$1dblog] con el certificado:

      ```
      USE [master]
      GO
      
      ADD SIGNATURE
        TO [master].[awsdms].[rtm_dump_dblog]
        BY CERTIFICATE [awsdms_rtm_dump_dblog_cert]
        WITH PASSWORD = '@hardpassword1';
      ```
**nota**  
Si vuelve a crear el procedimiento almacenado, tendrá que volver a agregar la firma.

   1. Cree el procedimiento `[awsdms].[rtm_position_1st_timestamp]` en la base de datos maestra:

      ```
      USE [master]
      IF object_id('[awsdms].[rtm_position_1st_timestamp]','P') is not null
        DROP PROCEDURE [awsdms].[rtm_position_1st_timestamp];
      GO
      CREATE PROCEDURE [awsdms].[rtm_position_1st_timestamp]
      (
        @dbname                sysname,      -- Database name
        @seqno                 integer,      -- Backup set sequence/position number within file
        @filename              varchar(260), -- The backup filename
        @1stTimeStamp          varchar(40)   -- The timestamp to position by
      ) 
      AS 
      BEGIN
        SET NOCOUNT ON       -- Disable "rows affected display"
      
        DECLARE @firstMatching table
        (
          cLsn varchar(32),
          bTim datetime
        )
        DECLARE @sql nvarchar(4000)
        DECLARE @nl                       char(2)
        DECLARE @tb                       char(2)
        DECLARE @fnameVar                 sysname = 'NULL'
      
        SET @nl  = char(10); -- New line
        SET @tb  = char(9)   -- Tab separator
      
        IF (@filename is not null)
          SET @fnameVar = ''''+@filename +''''
        SET @filename = ''''+@filename +''''
        SET @sql='use ['+@dbname+'];'+@nl+
          'SELECT TOP 1 [Current LSN],[Begin Time]'+@nl+
          'FROM fn_dump_dblog (NULL, NULL, NULL, '+ cast(@seqno as varchar(10))+','+ @filename +','+@nl+
          @tb+'default, default, default, default, default, default, default,'+@nl+
          @tb+'default, default, default, default, default, default, default,'+@nl+
          @tb+'default, default, default, default, default, default, default,'+@nl+
          @tb+'default, default, default, default, default, default, default,'+@nl+
          @tb+'default, default, default, default, default, default, default,'+@nl+
          @tb+'default, default, default, default, default, default, default,'+@nl+
          @tb+'default, default, default, default, default, default, default,'+@nl+
          @tb+'default, default, default, default, default, default, default,'+@nl+
          @tb+'default, default, default, default, default, default, default)'+@nl+
          'WHERE operation=''LOP_BEGIN_XACT''' +@nl+
          'AND [Begin Time]>= cast('+''''+@1stTimeStamp+''''+' as datetime)'+@nl
      
          --print @sql
          DELETE FROM @firstMatching 
          INSERT INTO @firstMatching  exec sp_executesql @sql    -- Get them all
          SELECT TOP 1 cLsn as [matching LSN],convert(varchar,bTim,121) AS[matching Timestamp] FROM @firstMatching;
      
          SET NOCOUNT OFF      -- Re-enable "rows affected display"
      
      END
      GO
      ```

   1. Cree un certificado en la base de datos maestra:

      ```
      USE [master]
      GO
      CREATE CERTIFICATE [awsdms_rtm_position_1st_timestamp_cert]
        ENCRYPTION BY PASSWORD = N'@hardpassword1'
        WITH SUBJECT = N'Certificate for FN_POSITION_1st_TIMESTAMP Permissions';
      ```

   1. Cree un inicio de sesión desde el certificado:

      ```
      USE [master]
      GO
      CREATE LOGIN awsdms_rtm_position_1st_timestamp_login FROM CERTIFICATE
        [awsdms_rtm_position_1st_timestamp_cert];
      ```

   1. Agregue el inicio de sesión al rol del servidor sysadmin:

      ```
      ALTER SERVER ROLE [sysadmin] ADD MEMBER [awsdms_rtm_position_1st_timestamp_login];
      ```

   1. Agregue la firma al procedimiento `[master].[awsdms].[rtm_position_1st_timestamp]` mediante el certificado:

      ```
      USE [master]
      GO
      ADD SIGNATURE
        TO [master].[awsdms].[rtm_position_1st_timestamp]
        BY CERTIFICATE [awsdms_rtm_position_1st_timestamp_cert]
        WITH PASSWORD = '@hardpassword1';
      ```
**nota**  
Si vuelve a crear el procedimiento almacenado, tendrá que volver a agregar la firma.

   1. Cree un usuario con lo siguiente permissions/roles en cada una de las siguientes bases de datos:
**nota**  
Debe crear la cuenta de usuario dmsnosysadmin con el mismo SID en cada réplica. La siguiente consulta SQL puede ayudar a comprobar el valor del SID de la cuenta dmsnosysadmin en cada réplica. Para obtener más información sobre la creación de un usuario, consulte [CREATE USER (Transact-SQL)](https://learn.microsoft.com/en-us/sql/t-sql/statements/create-user-transact-sql) en la [documentación de Microsoft SQL Server](https://learn.microsoft.com/en-us/sql/). Para obtener más información sobre la creación de cuentas de usuario de SQL para la base de datos de Azure SQL, consulte [Replicación geográfica activa](https://learn.microsoft.com/en-us/azure/azure-sql/database/active-geo-replication-overview).

      ```
      SELECT @@servername servername, name, sid, create_date, modify_date
        FROM sys.server_principals
        WHERE name = 'dmsnosysadmin';
      ```

   1. Conceda permisos en la base de datos maestra en cada réplica:

      ```
      USE master
      GO 
      
      GRANT select on sys.fn_dblog to dmsnosysadmin;
      GRANT view any definition to dmsnosysadmin;
      GRANT view server state to dmsnosysadmin -- (should be granted to the login).
      GRANT execute on sp_repldone to dmsnosysadmin;
      GRANT execute on sp_replincrementlsn to dmsnosysadmin;
      GRANT execute on sp_addpublication to dmsnosysadmin;
      GRANT execute on sp_addarticle to dmsnosysadmin;
      GRANT execute on sp_articlefilter to dmsnosysadmin;
      GRANT select on [awsdms].[split_partition_list] to dmsnosysadmin;
      GRANT execute on [awsdms].[rtm_dump_dblog] to dmsnosysadmin;
      GRANT execute on [awsdms].[rtm_position_1st_timestamp] to dmsnosysadmin;
      ```

   1. Conceda permisos en la base de datos msdb en cada réplica:

      ```
      USE msdb
      GO
      GRANT select on msdb.dbo.backupset TO self_managed_user
      GRANT select on msdb.dbo.backupmediafamily TO self_managed_user
      GRANT select on msdb.dbo.backupfile TO self_managed_user
      ```

   1. Agregue el rol `db_owner` a `dmsnosysadmin` en la base de datos de origen. Como la base de datos está sincronizada, solo puede agregar el rol en la réplica principal.

      ```
      use <source DB>
      GO 
      EXEC sp_addrolemember N'db_owner', N'dmsnosysadmin'
      ```

## Configuración de la replicación continua en una instancia de base de datos de SQL Server de la nube
<a name="CHAP_Source.SQLServer.Configuration"></a>

En esta sección se describe cómo configurar CDC en una instancia de base de datos de SQL Server alojada en la nube. Una instancia de SQL Server alojada en la nube es una instancia que se ejecuta en Amazon RDS para SQL Server, una instancia administrada por Azure SQL o cualquier otra instancia de SQL Server administrada en la nube. Para obtener información sobre las limitaciones de la replicación continua para cada tipo de base de datos, consulte [Limitaciones del uso de SQL Server como fuente de AWS DMS](CHAP_Source.SQLServer.md#CHAP_Source.SQLServer.Limitations). 

Antes de configurar la replicación continua, consulte [Requisitos previos para el uso de la replicación continua (CDC) desde un origen de SQL Server](CHAP_Source.SQLServer.md#CHAP_Source.SQLServer.Prerequisites). 

A diferencia de los orígenes autoadministrados de Microsoft SQL Server, Amazon RDS para SQL Server no es compatible con MS-Replication. Por lo tanto, AWS DMS necesita usar MS-CDC para tablas con o sin claves principales.

Amazon RDS no concede privilegios de administrador del sistema para configurar artefactos de replicación que se AWS DMS utilizan para los cambios continuos en una instancia de SQL Server de origen. Asegúrese de activar MS-CDC para la instancia de Amazon RDS (mediante privilegios de usuario principal) como se explica en el procedimiento siguiente.

**Activación de MS-CDC para una instancia de base de datos de SQL Server de la nube**

1. Ejecute una de las siguientes consultas en el nivel de base de datos.

   Para una instancia de base de datos de RDS para SQL Server, utilice esta consulta.

   ```
   exec msdb.dbo.rds_cdc_enable_db 'DB_name'
   ```

   Para una instancia de base de datos administrada por Azure SQL, utilice esta consulta.

   ```
   USE DB_name 
   GO 
   EXEC sys.sp_cdc_enable_db 
   GO
   ```

1. Para cada tabla con una clave principal, ejecute la siguiente consulta para la que desee activar MS-CDC.

   ```
   exec sys.sp_cdc_enable_table
   @source_schema = N'schema_name',
   @source_name = N'table_name',
   @role_name = NULL,
   @supports_net_changes = 1
   GO
   ```

   Para cada tabla con claves únicas pero sin clave principal, ejecute la siguiente consulta para la que desee activar MS-CDC.

   ```
   exec sys.sp_cdc_enable_table
   @source_schema = N'schema_name',
   @source_name = N'table_name',
   @index_name = N'unique_index_name',
   @role_name = NULL,
   @supports_net_changes = 1
   GO
   ```

    Para cada tabla sin claves principales ni claves únicas, ejecute la siguiente consulta para la que desee activar MS-CDC.

   ```
   exec sys.sp_cdc_enable_table
   @source_schema = N'schema_name',
   @source_name = N'table_name',
   @role_name = NULL
   GO
   ```

1. Establezca el periodo de retención:
   + En el caso de las instancias de RDS para SQL Server que se replican con DMS versión 3.5.3 o posteriores, asegúrese de que el periodo de retención esté establecido en el valor predeterminado de cinco segundos. Si va a actualizar o a pasar de DMS 3.5.2 y versiones anteriores a DMS 3.5.3 y versiones posteriores, cambie el valor del intervalo de sondeo una vez que las tareas se estén ejecutando en la instancia nueva o actualizada. En el siguiente script se define el periodo de retención en cinco segundos:

     ```
     use dbname
     EXEC sys.sp_cdc_change_job @job_type = 'capture' ,@pollinginterval = 5
     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 durante 86 399 segundos (un día) cuando `@pollinginterval = 86399`. El procedimiento `exec sp_cdc_start_job 'capture'` inicia la configuración.
**nota**  
En algunas versiones de SQL Server, si el valor de `pollinginterval` está establecido en más de 3599 segundos, se restablece a los cinco segundos predeterminados. Cuando esto ocurre, las entradas de T-Log se purgan antes de que pueda leerlas. AWS DMS Para determinar qué versiones de SQL Server se ven afectadas por este problema conocido, consulte [este artículo de Microsoft KB](https://support.microsoft.com/en-us/topic/kb4459220-fix-incorrect-results-occur-when-you-convert-pollinginterval-parameter-from-seconds-to-hours-in-sys-sp-cdc-scan-in-sql-server-dac8aefe-b60b-7745-f987-582dda2cfa78).

     Si utiliza Amazon RDS con Multi-AZ, asegúrese de configurar también la secundaria para que tenga los valores correctos en caso de conmutación por error.

     ```
     exec rdsadmin..rds_set_configuration 'cdc_capture_pollinginterval' , <5 or preferred value>
     ```

**Para mantener el período de retención cuando una tarea de AWS DMS replicación se detiene durante más de una hora**
**nota**  
Los siguientes pasos no son necesarios para un origen de RDS para SQL Server que replique con DMS 3.5.3 y versiones posteriores.

1. Detenga el trabajo truncando los registros de transacciones mediante el uso del siguiente comando. 

   ```
   exec sp_cdc_stop_job 'capture'
   ```

1. Busque la tarea en la AWS DMS consola y reanude la tarea.

1. Elija la pestaña **Monitoreo** y compruebe la métrica `CDCLatencySource`. 

1. Una vez que la métrica `CDCLatencySource` sea igual a 0 (cero) y permanezca sin cambios, vuelva a iniciar el trabajo truncando los registros de transacción mediante el siguiente comando.

   ```
   exec sp_cdc_start_job 'capture'
   ```

Recuerde iniciar el trabajo que trunca los registros de transacciones de SQL Server. De lo contrario, es posible que el almacenamiento de la instancia de SQL Server se llene.

### Configuración recomendada cuando se utiliza RDS para SQL Server como fuente de AWS DMS
<a name="CHAP_Source.SQLServer.Configuration.Settings"></a>

#### Para la versión AWS DMS 3.5.3 y versiones posteriores
<a name="CHAP_Source.SQLServer.Configuration.Settings.353"></a>

**nota**  
La versión inicial de la característica de copia de seguridad de registros de RDS para SQL Server está habilitada de forma predeterminada para los puntos de conexión que haya creado o modificado después del lanzamiento de la versión 3.5.3 de DMS. Para utilizar esta característica con los puntos de conexión existentes, modifique el punto de conexión sin realizar ningún cambio.

AWS DMS La versión 3.5.3 introduce la compatibilidad con la lectura de copias de seguridad de registros. DMS se basa principalmente en la lectura de los registros de transacciones activos para replicar eventos. Si se hace una copia de seguridad de una transacción antes de que DMS pueda leerla desde el registro activo, la tarea accede a las copias de seguridad de RDS bajo demanda y lee los registros de copias de seguridad posteriores hasta que se pone al día con el registro de transacciones activo. Para garantizar que DMS tenga acceso a las copias de seguridad del registro, establezca el periodo de retención de las copias de seguridad automatizadas de RDS en al menos un día. Para obtener información sobre cómo configurar el periodo de retención de copias de seguridad automatizadas, consulte [Periodo de retención de copia de seguridad](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ManagingAutomatedBackups.html#USER_WorkingWithAutomatedBackups.BackupRetention) en la *Guía del usuario de Amazon RDS*.

Una tarea de DMS que accede a las copias de seguridad del registro utiliza el almacenamiento en la instancia de RDS. Tenga en cuenta que la tarea solo accede a las copias de seguridad del registro necesarias para la replicación. Amazon RDS elimina estas copias de seguridad descargadas en un par de horas. Esta eliminación no afecta a las copias de seguridad de Amazon RDS retenidas en Amazon S3 ni a la funcionalidad `RESTORE DATABASE` de Amazon RDS. Se recomienda asignar almacenamiento adicional al origen de RDS para SQL Server si tiene intención de replicar con DMS. Una forma de calcular la cantidad de almacenamiento necesario es identificar la copia de seguridad a partir de la cual DMS iniciará o reanudará la replicación y sumar los tamaños de archivo de todas las copias de seguridad posteriores mediante la función de metadatos `tlog backup` de RDS. Para obtener más información sobre la función `tlog backup`, consulte [Publicación de las copias de seguridad del registro de transacciones disponibles](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER.SQLServer.AddlFeat.TransactionLogAccess.html#USER.SQLServer.AddlFeat.TransactionLogAccess.Listing) en la *Guía del usuario de Amazon RDS*. 

Como alternativa, puede optar por habilitar el escalado automático del almacenamiento o activar el escalado del almacenamiento en función de la CloudWatch `FreeStorageSpace` métrica de su instancia de Amazon RDS.

Se recomienda encarecidamente que no inicie ni reanude desde un punto demasiado remoto en las copias de seguridad del registro de transacciones, ya que esto puede provocar que se llene el espacio de almacenamiento de la instancia de SQL Server. En estos casos, se recomienda iniciar una carga completa. La replicación desde la copia de seguridad del registro de transacciones es más lenta que leer de los registros de transacciones activos. Para obtener más información, consulte [Procesamiento de copias de seguridad del registro de transacciones en RDS para SQL Server](CHAP_Troubleshooting_Latency_Source_SQLServer.md#CHAP_Troubleshooting_Latency_Source_SQLServer_backup).

Tenga en cuenta que el acceso a las copias de seguridad del registro requiere privilegios adicionales. Para obtener más información, consulte los detalles en [Configuración de permisos para la replicación continua desde una base de datos de SQL Server en la nube](CHAP_Source.SQLServer.md#CHAP_Source.SQLServer.Permissions.Cloud). Asegúrese de conceder estos privilegios antes de que la tarea comience a replicarse.

#### Para la versión 3.5.2 y versiones anteriores AWS DMS
<a name="CHAP_Source.SQLServer.Configuration.Settings.352"></a>

Cuando trabaja con Amazon RDS para SQL Server como origen, el trabajo de captura de MS-CDC se basa en los parámetros `maxscans` y `maxtrans`. Estos parámetros rigen el número máximo de escaneos que la captura de MS-CDC realiza en el registro de transacciones y el número de transacciones que se procesan para cada escaneo.

En el caso de las bases de datos, en las que el número de transacciones es superior a `maxtrans*maxscans`, el aumento del valor `polling_interval` puede provocar una acumulación de registros de transacciones activos. A su vez, esta acumulación puede provocar un aumento del tamaño del registro de transacciones.

Tenga en cuenta que AWS DMS no se basa en el trabajo de captura de MS-CDC. El trabajo de captura de MS-CDC marca las entradas del registro de transacciones como procesadas. Esto permite que el trabajo de copia de seguridad del registro de transacciones elimine las entradas del registro de transacciones.

Le recomendamos que monitoree el tamaño del registro de transacciones y el éxito de los trabajos de MS-CDC. Si las tareas de MS-CDC fallan, el registro de transacciones podría crecer excesivamente y provocar errores de replicación. AWS DMS Puede monitorear los errores de los trabajos de captura de MS-CDC mediante la vista de administración dinámica `sys.dm_cdc_errors` de la base de datos de origen. Puede monitorear el tamaño del registro de transacciones mediante el comando de gestión `DBCC SQLPERF(LOGSPACE)`.

**Solución al aumento del registro de transacciones provocado por MS-CDC**

1. Compruebe la base `Log Space Used %` de datos desde la AWS DMS que se está replicando y compruebe que aumenta continuamente.

   ```
   DBCC SQLPERF(LOGSPACE)
   ```

1. Identifique qué es lo que bloquea el proceso de copia de seguridad del registro de transacciones.

   ```
   Select log_reuse_wait, log_reuse_wait_desc, name from sys.databases where name = db_name();
   ```

   Si el valor `log_reuse_wait_desc` es igual a `REPLICATION`, la retención de la copia de seguridad del registro se debe a la latencia en MS-CDC.

1. Aumente el número de eventos procesados por el trabajo de captura aumentando los valores de los parámetros `maxtrans` y `maxscans`.

   ```
   EXEC sys.sp_cdc_change_job @job_type = 'capture' ,@maxtrans = 5000, @maxscans = 20 
   exec sp_cdc_stop_job 'capture'
   exec sp_cdc_start_job 'capture'
   ```

Para solucionar este problema, defina los valores de `maxscans` y de `maxtrans` forma que sean iguales al número medio de eventos generados en las tablas que `maxtrans*maxscans` se AWS DMS replican desde la base de datos de origen cada día.

Si establece estos parámetros por encima del valor recomendado, los trabajos de captura procesan todos los eventos de los registros de transacciones. Si establece estos parámetros por debajo del valor recomendado, la latencia de MS-CDC aumenta y el registro de transacciones crece.

Puede resultar difícil identificar los valores adecuados para `maxscans` y `maxtrans`, ya que los cambios en la carga de trabajo producen un número variable de eventos. En este caso, le recomendamos que configure el monitoreo de la latencia de MS-CDC. Para obtener más información, consulte [Monitorear el proceso](https://docs.microsoft.com/en-us/sql/relational-databases/track-changes/administer-and-monitor-change-data-capture-sql-server?view=sql-server-ver15#Monitor) en la documentación de SQL Server. A continuación, configure `maxtrans` y `maxscans` de forma dinámica en función de los resultados del monitoreo.

Si la AWS DMS tarea no encuentra los números de secuencia de registro (LSNs) necesarios para reanudar o continuar la tarea, es posible que se produzca un error en la tarea y que sea necesario volver a cargarla por completo.

**nota**  
Cuando se utiliza AWS DMS para replicar datos desde una fuente de RDS para SQL Server, es posible que se produzcan errores al intentar reanudar la replicación tras un evento de parada e inicio de la instancia de Amazon RDS. Esto se debe a que el proceso del agente de SQL Server reinicia el proceso del trabajo de captura cuando se reinicia después del evento de parada e inicio. Esto evita el intervalo de sondeo de MS-CDC.  
Por este motivo, en las bases de datos con volúmenes de transacciones inferiores al procesamiento de los trabajos de captura de MS-CDC, esto puede provocar que los datos se procesen o se marquen como replicados y respaldados antes de que AWS DMS puedan reanudarse desde donde se detuvieron, lo que provoca el siguiente error:  

```
[SOURCE_CAPTURE ]E: Failed to access LSN '0000dbd9:0006f9ad:0003' in the backup log sets since BACKUP/LOG-s are not available. [1020465] (sqlserver_endpoint_capture.c:764)
```
Para mitigar este problema, defina los valores `maxtrans` y `maxscans` tal como se recomendó anteriormente.

# Uso de la base de datos SQL de Microsoft Azure como fuente para AWS DMS
<a name="CHAP_Source.AzureSQL"></a>

Con AWS DMS, puede usar Microsoft Azure SQL Database como fuente de la misma manera que lo hace con SQL Server. AWS DMS admite, como fuente, la misma lista de versiones de bases de datos compatibles con SQL Server que se ejecuta de forma local o en una instancia de Amazon EC2. 

Para obtener más información, consulte [Uso de una base de datos de Microsoft SQL Server como fuente para AWS DMS](CHAP_Source.SQLServer.md).

**nota**  
AWS DMS no admite las operaciones de cambio de captura de datos (CDC) con Azure SQL Database.

# Uso de Microsoft Azure SQL Managed Instance como fuente para AWS DMS
<a name="CHAP_Source.AzureMgd"></a>

Con AWS DMS, puede usar Microsoft Azure SQL Managed Instance como fuente de la misma manera que lo hace con SQL Server. AWS DMS admite, como fuente, la misma lista de versiones de bases de datos compatibles con SQL Server que se ejecuta de forma local o en una instancia de Amazon EC2. 

Para obtener más información, consulte [Uso de una base de datos de Microsoft SQL Server como fuente para AWS DMS](CHAP_Source.SQLServer.md).

# Uso del servidor flexible Microsoft Azure Database para PostgreSQL como fuente para AWS DMS
<a name="CHAP_Source.AzureDBPostgreSQL"></a>

Con AWS DMS, puede utilizar el servidor flexible de Microsoft Azure Database para PostgreSQL como fuente de forma muy parecida a como lo hace con PostgreSQL.

Para obtener información sobre las versiones del servidor flexible de Microsoft Azure Database para PostgreSQL AWS DMS que admite como fuente, consulte. [Fuentes de AWS DMS](CHAP_Introduction.Sources.md)

## Configuración del servidor flexible de Microsoft Azure para PostgreSQL para la replicación lógica y la decodificación
<a name="CHAP_Source.AzureDBPostgreSQL.setup"></a>

Puede utilizar las características de replicación lógica y decodificación del servidor flexible de Microsoft Azure Database para PostgreSQL durante la migración de la base de datos.

Para la decodificación lógica, DMS utiliza el complemento `test_decoding` o `pglogical`. Si el complemento `pglogical` está disponible en una base de datos de PostgreSQL de origen, DMS crea una ranura de replicación con `pglogical`, de lo contrario se utiliza el complemento `test_decoding`. 

Para configurar el servidor flexible de Microsoft Azure para PostgreSQL como punto de conexión de origen para DMS, realice los siguientes pasos: 

1. Abra la página de parámetros del servidor en el portal.

1. Establezca el parámetro del servidor `wal_level` en `LOGICAL`.

1. Si desea utilizar la extensión `pglogical`, establezca los parámetros `shared_preload_libraries` y `azure.extensions` en `pglogical`.

1. Establezca el parámetro `max_replication_slots` en el número máximo de tareas de DMS que planea ejecutar simultáneamente. En Microsoft Azure, el valor predeterminado para este parámetro es 10. El valor máximo de este parámetro depende de la memoria disponible de la instancia de PostgreSQL, lo que permite entre 2 y 8 ranuras de replicación por GB de memoria.

1. Establezca el parámetro `max_wal_senders` en un valor mayor de 1. El parámetro `max_wal_senders` establece el número de tareas simultáneas que pueden ejecutarse. El valor predeterminado es 10.

1. Establezca el valor del parámetro `max_worker_processes` en al menos 16. De lo contrario, es posible que aparezcan errores como los siguientes:

   ```
   WARNING: out of background worker slots.
   ```

1. Guarde los cambios. Reinicie el servidor para aplicar los cambios.

1. Confirme que la instancia de PostgreSQL permite el tráfico de red desde el recurso de conexión.

1. Conceda permisos de replicación a un usuario existente o cree un nuevo usuario con permisos de replicación mediante los siguientes comandos. 
   + Conceda a un usuario existente permisos de replicación con el siguiente comando:

     ```
     ALTER USER <existing_user> WITH REPLICATION;
     ```
   + Cree un nuevo usuario con permisos de replicación mediante el siguiente comando: 

     ```
     CREATE USER aws_dms_user PASSWORD 'aws_dms_user_password';
     GRANT azure_pg_admin to aws_dms_user;
     ALTER ROLE aws_dms_user REPLICATION LOGIN;
     ```

Para obtener más información acerca de la replicación lógica con PostgreSQL, consulte los siguientes temas:
+ [Habilitación de la captura de datos de cambios (CDC) mediante replicación lógica](CHAP_Source.PostgreSQL.md#CHAP_Source.PostgreSQL.Security)
+ [Uso de puntos de inicio de CDC nativo para configurar una carga de CDC de un origen de PostgreSQL](CHAP_Source.PostgreSQL.md#CHAP_Source.PostgreSQL.v10)
+ [Replicación lógica y decodificación lógica en Azure Database para PostgreSQL: servidor flexible](https://learn.microsoft.com/en-us/azure/postgresql/flexible-server/concepts-logical) en la [documentación de Azure Database para PostgreSQL](https://learn.microsoft.com/en-us/azure/postgresql/).

# Uso del servidor flexible Microsoft Azure Database for MySQL como fuente para AWS DMS
<a name="CHAP_Source.AzureDBMySQL"></a>

Con AWS DMS, puede utilizar el servidor flexible Microsoft Azure Database for MySQL como fuente de la misma manera que lo hace con MySQL.

Para obtener información sobre las versiones del servidor flexible Microsoft Azure Database for MySQL que AWS DMS admite como fuente, consulte[Fuentes de AWS DMS](CHAP_Introduction.Sources.md). 

Para obtener más información sobre el uso de una base de datos compatible con MySQL administrada por el cliente con, consulte. AWS DMS[Uso de una base de datos autogestionada compatible con MySQL como fuente para AWS DMS](CHAP_Source.MySQL.md#CHAP_Source.MySQL.CustomerManaged)

## Limitaciones al usar Azure MySQL como fuente de AWS Database Migration Service
<a name="CHAP_Source.AzureDBMySQL.limitations"></a>
+ El valor predeterminado de la variable de sistema del servidor flexible de Azure MySQL `sql_generate_invisible_primary_key` es `ON` y el servidor agrega automáticamente una clave principal invisible (GIPK) generada a cualquier tabla que se cree sin una clave principal explícita. AWS DMS no admite la replicación continua de tablas MySQL con restricciones GIPK.

# Uso de OCI MySQL Heatwave como fuente para AWS DMS
<a name="CHAP_Source.heatwave"></a>

Con AWS DMS, puede utilizar OCI MySQL Heatwave como fuente de la misma manera que lo hace con MySQL. El uso de OCI MySQL Heatwave como origen requiere algunos cambios de configuración adicionales.

Para obtener información sobre las versiones de OCI MySQL Heatwave AWS DMS compatibles como fuente, consulte. [Fuentes de AWS DMS](CHAP_Introduction.Sources.md)

## Configuración de OCI MySQL Heatwave para la replicación lógica
<a name="CHAP_Source.heatwave.setup"></a>

Para configurar la instancia de OCI MySQL Heatwave como punto de conexión de origen para DMS, haga lo siguiente:

1. Inicie sesión en la consola de OCI y abra el menú hamburguesa principal (≡) en la esquina superior izquierda.

1. Elija **Bases de datos**, **sistemas de bases de datos**.

1. Abra el menú de **configuraciones**.

1. Seleccione **Crear configuración**.

1. Escriba un nombre de configuración, por ejemplo **dms\$1configuration**.

1. Elija la forma de la instancia de OCI MySQL Heatwave actual. Puede encontrar la forma en la pestaña de propiedades de **configuración del sistema de base de datos** de la instancia en la sección **Configuración del sistema de base de datos: Forma**.

1. En la sección **Variables de usuario**, elija la variable del sistema `binlog_row_value_options`. El valor predeterminado es `PARTIAL_JSON`. Borre el valor.

1. Elija el botón **Crear**.

1. **Abra su SQLHeatwave instancia OCI My y pulse el botón Editar.**

1. En la sección **Configuración**, elija el botón **Cambiar configuración** y elija la configuración de forma que creó en el paso 4.

1. Una vez que los cambios surtan efecto, la instancia estará lista para la replicación lógica.

# Uso de Google Cloud para MySQL como fuente de AWS DMS
<a name="CHAP_Source.GC"></a>

Con AWS DMS, puedes usar Google Cloud para MySQL como fuente de la misma manera que lo haces con MySQL. 

Para obtener información sobre las versiones de GCP MySQL AWS DMS compatibles como fuente, consulta[Fuentes de AWS DMS](CHAP_Introduction.Sources.md). 

Para obtener más información, consulte [Uso de una base de datos compatible con MySQL como fuente para AWS DMS](CHAP_Source.MySQL.md).

**nota**  
Support para GCP MySQL 8.0 como fuente está disponible en la AWS DMS versión 3.4.6.  
AWS DMS no admite el modo SSL `verify-full` para las instancias de GCP for MySQL.  
`Allow only SSL connections`No se admite la configuración de seguridad de GCP MySQL porque requiere la verificación del certificado del servidor y del cliente. AWS DMS solo admite la verificación de certificados de servidor.  
AWS DMS admite el valor predeterminado de CloudSQL para MySQL de GCP para el `binlog_checksum` indicador de `CRC32` base de datos.

# Uso de Google Cloud para PostgreSQL como fuente para AWS DMS
<a name="CHAP_Source.GCPostgres"></a>

Con AWS DMS, puedes usar Google Cloud para PostgreSQL como fuente de la misma manera que lo haces con las bases de datos PostgreSQL autogestionadas.

Para obtener información sobre las versiones de PostgreSQL de GCP AWS DMS compatibles como fuente, consulte. [Fuentes de AWS DMS](CHAP_Introduction.Sources.md) 

Para obtener más información, consulte [Uso de una base de datos PostgreSQL como fuente AWS DMS](CHAP_Source.PostgreSQL.md).

## Configuración de Google Cloud para PostgreSQL para la replicación lógica y la decodificación
<a name="CHAP_Source.GCPostgres.setup"></a>

Puede utilizar las características de replicación lógica y decodificación en Google Cloud SQL para PostgreSQL durante la migración de la base de datos.

Para la decodificación lógica, DMS usa uno de los siguientes complementos:
+ `test_decoding`
+ `pglogical`

Si el complemento `pglogical` está disponible en una base de datos de PostgreSQL de origen, DMS crea una ranura de replicación con `pglogical`, de lo contrario se utiliza el complemento `test_decoding`. 

Tenga en cuenta lo siguiente acerca del uso de la decodificación lógica con: AWS DMS

1. Con Google Cloud SQL para PostgreSQL, habilite la decodificación lógica configurando el indicador `cloudsql.logical_decoding` en `on`.

1. Para habilitar `pglogical`, establezca el indicador `cloudsql.enable_pglogical` en `on` y reinicie la base de datos.

1. Para utilizar las características de decodificación lógica, debe crear un usuario de PostgreSQL con el atributo `REPLICATION`. Cuando utiliza la extensión `pglogical`, el usuario debe tener el rol `cloudsqlsuperuser`. Para crear un usuario con el rol de `cloudsqlsuperuser`, haga lo siguiente:

   ```
   CREATE USER new_aws_dms_user WITH REPLICATION
   IN ROLE cloudsqlsuperuser LOGIN PASSWORD 'new_aws_dms_user_password';
   ```

   Para establecer este atributo en un usuario existente, haga lo siguiente:

   ```
   ALTER USER existing_user WITH REPLICATION;
   ```

1. Establezca el parámetro `max_replication_slots` en el número máximo de tareas de DMS que planea ejecutar simultáneamente. En Google Cloud SQL, el valor predeterminado de este parámetro es 10. El valor máximo de este parámetro depende de la memoria disponible de la instancia de PostgreSQL, lo que permite entre 2 y 8 ranuras de replicación por GB de memoria.

Para obtener más información acerca de la replicación lógica con PostgreSQL, consulte los siguientes temas:
+ [Habilitación de la captura de datos de cambios (CDC) mediante replicación lógica](CHAP_Source.PostgreSQL.md#CHAP_Source.PostgreSQL.Security)
+ [Uso de puntos de inicio de CDC nativo para configurar una carga de CDC de un origen de PostgreSQL](CHAP_Source.PostgreSQL.md#CHAP_Source.PostgreSQL.v10)
+ [Configure la replicación y la decodificación lógicas](https://cloud.google.com/sql/docs/postgres/replication/configure-logical-replication) en la [documentación de Cloud SQL para PostgreSQL](https://cloud.google.com/sql/docs/postgres).

# Uso de una base de datos PostgreSQL como fuente AWS DMS
<a name="CHAP_Source.PostgreSQL"></a>

Puede migrar datos de una o varias bases de datos PostgreSQL mediante. AWS DMS Con una base de datos de PostgreSQL como origen, podrá migrar datos a otra base de datos de PostgreSQL o a una de las bases de datos compatibles. 

Para obtener información sobre las versiones de PostgreSQL AWS DMS compatibles como fuente, consulte. [Fuentes de AWS DMS](CHAP_Introduction.Sources.md) 

AWS DMS admite PostgreSQL para estos tipos de bases de datos: 
+  Bases de datos en las instalaciones
+ Bases de datos en una instancia de Amazon EC2
+ Bases de datos en una instancia de base de datos de Amazon RDS
+ Bases de datos de una instancia de base de datos basada en Amazon Aurora PostgreSQL-Compatible Edition
+ Bases de datos de una instancia de base de datos basada en Amazon Aurora PostgreSQL-Compatible Serverless Edition

**nota**  
DMS es compatible con Amazon Aurora PostgreSQL - Serverless V1 como origen solo para carga completa. Sin embargo, puede usar Amazon Aurora PostgreSQL - Serverless V2 como origen para tareas de carga completa, carga completa \$1 CDC y solo CDC.

Puede utilizar las capas de conexión segura (SSL) para cifrar las conexiones entre el punto de conexión de PostgreSQL y la instancia de replicación. Para obtener más información sobre el uso de SSL con un punto de enlace de PostgreSQL, consulte [Uso de SSL con AWS Database Migration Service](CHAP_Security.SSL.md).

Como requisito de seguridad adicional cuando se utiliza PostgreSQL como origen, la cuenta de usuario especificada debe ser un usuario registrado en la base de datos de PostgreSQL.

Para configurar una base de datos PostgreSQL como AWS DMS punto final de origen, haga lo siguiente:
+ Cree un usuario de PostgreSQL con los permisos adecuados para AWS DMS proporcionar acceso a la base de datos de origen de PostgreSQL.
**nota**  
Si la base de datos de origen de PostgreSQL es autoadministrada, consulte [Trabajar con bases de datos PostgreSQL autogestionadas como fuente en AWS DMS](#CHAP_Source.PostgreSQL.Prerequisites) para obtener más información.
Si la base de datos de origen de PostgreSQL la administra Amazon RDS, consulte [Trabajar con bases AWS de datos PostgreSQL gestionadas como fuente de DMS](#CHAP_Source.PostgreSQL.RDSPostgreSQL) para obtener más información.
+ Cree un punto de conexión de origen de PostgreSQL que se ajuste a la configuración de base de datos de PostgreSQL que haya elegido.
+ Cree una tarea o un conjunto de tareas para migrar las tablas.

  Para crear una full-load-only tarea, no es necesaria ninguna otra configuración de punto final.

  Antes de crear una tarea para la captura de datos de cambios (una tarea exclusiva de CDC o de carga completa de CDC y de CDC), consulte [Permitir a los CDC utilizar una base de datos PostgreSQL autogestionada como fuente AWS DMS](#CHAP_Source.PostgreSQL.Prerequisites.CDC) o [Habilitar CDC con una instancia de base AWS de datos PostgreSQL administrada con AWS DMS](#CHAP_Source.PostgreSQL.RDSPostgreSQL.CDC).

**Topics**
+ [Trabajar con bases de datos PostgreSQL autogestionadas como fuente en AWS DMS](#CHAP_Source.PostgreSQL.Prerequisites)
+ [Trabajar con bases AWS de datos PostgreSQL gestionadas como fuente de DMS](#CHAP_Source.PostgreSQL.RDSPostgreSQL)
+ [Habilitación de la captura de datos de cambios (CDC) mediante replicación lógica](#CHAP_Source.PostgreSQL.Security)
+ [Uso de puntos de inicio de CDC nativo para configurar una carga de CDC de un origen de PostgreSQL](#CHAP_Source.PostgreSQL.v10)
+ [Migración de PostgreSQL a PostgreSQL mediante AWS DMS](#CHAP_Source.PostgreSQL.Homogeneous)
+ [Migración de Babelfish a Amazon Aurora PostgreSQL mediante AWS DMS](#CHAP_Source.PostgreSQL.Babelfish)
+ [Eliminar AWS DMS artefactos de una base de datos fuente de PostgreSQL](#CHAP_Source.PostgreSQL.CleanUp)
+ [Ajustes de configuración adicionales al utilizar una base de datos de PostgreSQL como origen de DMS](#CHAP_Source.PostgreSQL.Advanced)
+ [Réplica de lectura como origen para PostgreSQL](#CHAP_Source.PostgreSQL.ReadReplica)
+ [Uso de la configuración del punto de conexión `MapBooleanAsBoolean` de PostgreSQL](#CHAP_Source.PostgreSQL.ConnectionAttrib.Endpointsetting)
+ [Configuración de punto final y atributos de conexión adicionales (ECAs) cuando se utiliza PostgreSQL como fuente de DMS](#CHAP_Source.PostgreSQL.ConnectionAttrib)
+ [Restricciones en el uso de una base de datos de PostgreSQL como origen de DMS](#CHAP_Source.PostgreSQL.Limitations)
+ [Tipos de datos de origen para PostgreSQL](#CHAP_Source-PostgreSQL-DataTypes)

## Trabajar con bases de datos PostgreSQL autogestionadas como fuente en AWS DMS
<a name="CHAP_Source.PostgreSQL.Prerequisites"></a>

Con una base de datos PostgreSQL autogestionada como fuente, puede migrar los datos a otra base de datos de PostgreSQL o a una de las otras bases de datos de destino compatibles con. AWS DMS El origen de la base de datos puede estar en una base de datos en las instalaciones o un motor autoadministrado en ejecución en una instancia de Amazon EC2. Puede utilizar una instancia de base de datos tanto para tareas de carga completa como para la captura de datos de cambios (CDC).

### Requisitos previos para utilizar una base de datos PostgreSQL autogestionada como fuente AWS DMS
<a name="CHAP_Source.PostgreSQL.Prerequisites.SelfManaged"></a>

Antes de migrar datos desde una base de datos de origen de PostgreSQL autoadministrada, haga lo siguiente: 
+ Asegúrese de utilizar una base de datos de PostgreSQL versión 9.4.x o superiores.
+ Para las tareas de carga completa más CDC o tareas exclusivas de CDC, debe conceder permisos de superusuario para la cuenta de usuario especificada para la base de datos de origen de PostgreSQL. La cuenta de usuario necesita permisos de superusuario para acceder a funciones específicas de replicación en el origen. La cuenta de usuario de DMS necesita permisos SELECT en todas las columnas para migrar las tablas correctamente. En el caso de que falten permisos en las columnas, DMS crea la tabla de destino con las asignaciones de tipos de datos habituales de DMS, lo que genera diferencias en los metadatos y errores en las tareas.
+ Agregue la dirección IP del servidor de AWS DMS replicación al archivo de `pg_hba.conf` configuración y habilite la replicación y las conexiones de socket. Ejemplo:

  ```
              # Replication Instance
              host all all 12.3.4.56/00 md5
              # Allow replication connections from localhost, by a user with the
              # replication privilege.
              host replication dms 12.3.4.56/00 md5
  ```

  El archivo de configuración de PostgreSQL `pg_hba.conf` controla la autenticación del cliente. (HBA significa autenticación basada en host). El archivo se almacena tradicionalmente en el directorio de datos del clúster de bases de datos. 
+ Si va a configurar una base de datos como fuente para la replicación lógica AWS DMS mediante [Permitir a los CDC utilizar una base de datos PostgreSQL autogestionada como fuente AWS DMS](#CHAP_Source.PostgreSQL.Prerequisites.CDC)

**nota**  
Algunas AWS DMS transacciones permanecen inactivas durante algún tiempo antes de que el motor del DMS las vuelva a utilizar. Al usar el parámetro `idle_in_transaction_session_timeout` en PostgreSQL versiones 9.6 y superiores, puede provocar transacciones inactivas en el tiempo de espera y que se devuelva un error. No finalice las transacciones inactivas cuando utilice AWS DMS. 

### Permitir a los CDC utilizar una base de datos PostgreSQL autogestionada como fuente AWS DMS
<a name="CHAP_Source.PostgreSQL.Prerequisites.CDC"></a>

AWS DMS admite la captura de datos de cambios (CDC) mediante la replicación lógica. Para habilitar la replicación lógica en una base de datos de origen de PostgreSQL autoadministrada, establezca los siguientes parámetros y valores en el archivo de configuración `postgresql.conf`:
+ Configurar `wal_level = logical`.
+ Defina `max_replication_slots` en un valor mayor de 1.

  Establezca el valor `max_replication_slots` en función del número de tareas que desea ejecutar. Por ejemplo, para ejecutar cinco tareas debe establecer un mínimo de cinco ranuras. Las ranuras se abrirán automáticamente en cuanto se inicie una tarea y permanecerán abiertas incluso cuando la tarea ya no se esté ejecutando. Asegúrese de eliminar manualmente las ranuras abiertas. Tenga en cuenta que DMS elimina automáticamente las ranuras de replicación cuando se elimina la tarea, si DMS creó la ranura.
+ Defina `max_wal_senders` en un valor mayor de 1.

  El parámetro `max_wal_senders` establece el número de tareas simultáneas que pueden ejecutarse.
+ El parámetro `wal_sender_timeout` termina la replicación de conexiones que están inactivas durante más tiempo de los milisegundos especificados. El valor predeterminado para una base de datos de PostgreSQL en las instalaciones es 60 000 milisegundos (60 segundos). Si se establece el valor en 0 (cero), se desactiva el mecanismo de tiempo de espera y es una configuración válida para la DMS.

  Si se establece `wal_sender_timeout` en un valor distinto de cero, una tarea de DMS con CDC requiere un mínimo de 10 000 milisegundos (10 segundos) y se produce un error si el valor es inferior a 10 000. Mantenga el valor en menos de 5 minutos para evitar retrasos durante una conmutación por error de Multi-AZ de una instancia de replicación de DMS.

Algunos parámetros son estáticos y solo se pueden configurar al iniciar el servidor. Los cambios en las entradas en el archivo de configuración (para una base de datos autoadministrada) o en el grupo de parámetros de base de datos (para una base de datos de RDS para PostgreSQL) se ignoran hasta que se reinicie el servidor. Para obtener más información, consulte la [documentación de PostgreSQL](https://www.postgresql.org/docs/current/intro-whatis.html).

Para obtener más información acerca de la habilitación de CDC, consulte [Habilitación de la captura de datos de cambios (CDC) mediante replicación lógica](#CHAP_Source.PostgreSQL.Security).

## Trabajar con bases AWS de datos PostgreSQL gestionadas como fuente de DMS
<a name="CHAP_Source.PostgreSQL.RDSPostgreSQL"></a>

Puede utilizar una instancia de base AWS de datos PostgreSQL gestionada como fuente para. AWS DMS Puede realizar tanto tareas de carga completa como tareas de captura de datos de cambios (CDC) mediante un origen de PostgreSQL administrado por AWS. 

### Requisitos previos para utilizar una base de datos AWS PostgreSQL gestionada como fuente de DMS
<a name="CHAP_Source.PostgreSQL.RDSPostgreSQL.Prerequisites"></a>

Antes de migrar datos desde una base de datos fuente AWS de PostgreSQL gestionada, haga lo siguiente:
+ Le recomendamos que utilice una cuenta de AWS usuario con los permisos mínimos necesarios para la instancia de base de datos de PostgreSQL como cuenta de usuario para el punto final de origen de PostgreSQL. AWS DMS No se recomienda el uso de la cuenta principal. La cuenta debe tener el rol `rds_superuser` y el rol `rds_replication`. El rol de `rds_replication` concede permisos para administrar ranuras lógicas y para transmitir datos mediante ranuras lógicas.

  Asegúrese de crear varios objetos a partir de la cuenta de usuario principal para la cuenta que utilice. Para obtener información sobre la creación de estos, consulte [Migración de una base de datos de Amazon RDS para PostgreSQL sin usar la cuenta de usuario principal](#CHAP_Source.PostgreSQL.RDSPostgreSQL.NonMasterUser).
+ Si la base de datos de origen está en una nube privada virtual (VPC), elija el grupo de seguridad de la VPC que proporciona acceso a la instancia de base de datos donde reside la base de datos. Esto es necesario para que la instancia de replicación de DMS se conecte correctamente a la instancia de base de datos de origen. Cuando la base de datos y la instancia de replicación de DMS estén en la misma VPC, agregue el grupo de seguridad adecuado a sus propias reglas de entrada.

**nota**  
Algunas AWS DMS transacciones permanecen inactivas durante algún tiempo antes de que el motor de DMS las vuelva a utilizar. Al usar el parámetro `idle_in_transaction_session_timeout` en PostgreSQL versiones 9.6 y superiores, puede provocar transacciones inactivas en el tiempo de espera y que se devuelva un error. No finalice las transacciones inactivas cuando utilice AWS DMS.

### Habilitar CDC con una instancia de base AWS de datos PostgreSQL administrada con AWS DMS
<a name="CHAP_Source.PostgreSQL.RDSPostgreSQL.CDC"></a>

AWS DMS admite CDC en bases de datos PostgreSQL de Amazon RDS cuando la instancia de base de datos está configurada para usar la replicación lógica. En la siguiente tabla se resume la compatibilidad de la replicación lógica de cada versión de AWS PostgreSQL administrada. 


|  Versión de PostgreSQL  |  AWS DMS soporte de carga completa   |  AWS DMS Soporte de los CDC  | 
| --- | --- | --- | 
|  Aurora PostgreSQL versión 2.1 con compatibilidad de PostgreSQL 10.5 (o inferior)  |  Sí  |  No  | 
|  Aurora PostgreSQL versión 2.2 con compatibilidad de PostgreSQL 10.6 (o superiores)   |  Sí  |  Sí  | 
|  RDS para PostgreSQL compatible con PostgreSQL 10.21 (o superiores)  |  Sí  |  Sí  | 

**Para habilitar la replicación lógica en una instancia de base de datos de RDS para PostgreSQL**

1. Utilice la cuenta de usuario AWS maestra de la instancia de base de datos de PostgreSQL como cuenta de usuario para el punto final de origen de PostgreSQL. La cuenta de usuario principal dispone de los roles necesarios que le permiten configurar la CDC. 

   Si utiliza una cuenta que no sea la cuenta de usuario principal, asegúrese de crear varios objetos desde la cuenta principal para la cuenta que utilice. Para obtener más información, consulte [Migración de una base de datos de Amazon RDS para PostgreSQL sin usar la cuenta de usuario principal](#CHAP_Source.PostgreSQL.RDSPostgreSQL.NonMasterUser).

1. Establezca en 1 el parámetro `rds.logical_replication` en el grupo de parámetros de CLÚSTER de la base de datos. Para que este parámetro estático surta efecto, es necesario reiniciar la instancia de base de datos. Como parte de la aplicación de este parámetro, AWS DMS establece los parámetros `wal_level`, `max_wal_senders`, `max_replication_slots` y `max_connections`. Estos cambios de parámetros pueden aumentar la generación de registros de escritura anticipada (WAL), así que solo debe establecer `rds.logical_replication` cuando utilice ranuras de replicación lógica.

1. El parámetro `wal_sender_timeout` termina la replicación de conexiones que están inactivas durante más tiempo de los milisegundos especificados. El valor predeterminado para una base AWS de datos PostgreSQL gestionada es de 30 000 milisegundos (30 segundos). Si se establece el valor en 0 (cero), se desactiva el mecanismo de tiempo de espera y es una configuración válida para la DMS.

   Si se establece `wal_sender_timeout` en un valor distinto de cero, una tarea de DMS con CDC requiere un mínimo de 10 000 milisegundos (10 segundos) y se produce un error si el valor está entre 0 y 10 000. Mantenga el valor en menos de 5 minutos para evitar retrasos durante una conmutación por error de Multi-AZ de una instancia de replicación de DMS.

1.  Asegúrese de que el valor del parámetro `max_worker_processes` del grupo de parámetros del clúster de base de datos sea igual o superior a los valores totales combinados de `max_logical_replication_workers`, `autovacuum_max_workers` y `max_parallel_workers`. Un número elevado de procesos de trabajo en segundo plano podría afectar a las cargas de trabajo de las aplicaciones en instancias pequeñas. Por lo tanto, monitoree el rendimiento de la base de datos si establece `max_worker_processes` encima del valor predeterminado.

1.  Cuando utilice Aurora PostgreSQL como origen con CDC, establezca `synchronous_commit` en `ON`.

**Cómo utilizar la réplica de lectura del clúster de base de datos multi-AZ de PostgreSQL para la CDC (replicación continua)**

1. Establezca los parámetros `rds.logical_replication` y `sync_replication_slots` del grupo de parámetros CLUSTER de la base de datos en 1. Para que estos parámetros estáticos surtan efecto, es necesario reiniciar la instancia de base de datos.

1. Ejecute el siguiente comando para crear la tabla `awsdms_ddl_audit` en Writer y sustituirla por el `objects_schema` con el nombre del esquema que se va a utilizar:

   ```
   CREATE TABLE objects_schema.awsdms_ddl_audit
   (
     c_key    bigserial primary key,
     c_time   timestamp,    -- Informational
     c_user   varchar(64),  -- Informational: current_user
     c_txn    varchar(16),  -- Informational: current transaction
     c_tag    varchar(24),  -- Either 'CREATE TABLE' or 'ALTER TABLE' or 'DROP TABLE'
     c_oid    integer,      -- For future use - TG_OBJECTID
     c_name   varchar(64),  -- For future use - TG_OBJECTNAME
     c_schema varchar(64),  -- For future use - TG_SCHEMANAME. For now - holds current_schema
     c_ddlqry  text         -- The DDL query associated with the current DDL event
   );
   ```

1. Ejecute el siguiente comando para crear la función `awsdms_intercept_ddl` y sustituirla por el `objects_schema` con el nombre del esquema que se va a utilizar:

   ```
   CREATE OR REPLACE FUNCTION objects_schema.awsdms_intercept_ddl()
     RETURNS event_trigger
   LANGUAGE plpgsql
   SECURITY DEFINER
     AS $$
     declare _qry text;
   BEGIN
     if (tg_tag='CREATE TABLE' or tg_tag='ALTER TABLE' or tg_tag='DROP TABLE' or tg_tag = 'CREATE TABLE AS') then
            SELECT current_query() into _qry;
            insert into objects_schema.awsdms_ddl_audit
            values
            (
            default,current_timestamp,current_user,cast(TXID_CURRENT()as varchar(16)),tg_tag,0,'',current_schema,_qry
            );
            delete from objects_schema.awsdms_ddl_audit;
   end if;
   END;
   $$;
   ```

1. Ejecute el siguiente comando para crear el desencadenador de eventos `awsdms_intercept_ddl`:

   ```
   CREATE EVENT TRIGGER awsdms_intercept_ddl ON ddl_command_end EXECUTE PROCEDURE objects_schema.awsdms_intercept_ddl();
   ```

   Asegúrese de que todos los usuarios y roles que acceden a estos eventos tengan los permisos de DDL necesarios. Por ejemplo:

   ```
   grant all on public.awsdms_ddl_audit to public;
   grant all on public.awsdms_ddl_audit_c_key_seq to public;
   ```

1. Cree una ranura de replicación en Writer:

   ```
   SELECT * FROM pg_create_logical_replication_slot('dms_read_replica_slot', 'test_decoding', false, true);
   ```

1. Asegúrese de que la ranura de replicación esté disponible en Reader:

   ```
   select * from pg_catalog.pg_replication_slots where slot_name = 'dms_read_replica_slot';
   
   slot_name            |plugin       |slot_type|datoid|database|temporary|active|active_pid|xmin|catalog_xmin|restart_lsn|confirmed_flush_lsn|wal_status|safe_wal_size|two_phase|inactive_since               |conflicting|invalidation_reason|failover|synced|
   ---------------------+-------------+---------+------+--------+---------+------+----------+----+------------+-----------+-------------------+----------+-------------+---------+-----------------------------+-----------+-------------------+--------+------+
   dms_read_replica_slot|test_decoding|logical  |     5|postgres|false    |false |          |    |3559        |0/180011B8 |0/180011F0         |reserved  |             |true     |2025-02-10 15:45:04.083 +0100|false      |                   |false   |false |
   ```

1. Cree el punto de conexión de origen de DMS para la réplica de lectura y establezca el nombre de la ranura de replicación lógica mediante el atributo de conexión adicional:

   ```
   slotName=dms_read_replica_slot;
   ```

1. Cree e inicie la tarea CDC/FL\$1CDC.
**nota**  
En el caso de las migraciones CDC/FL\$1CDC, DMS considera la hora de inicio de la tarea como la posición de inicio de la CDC. Se ignoran todas las ranuras LSNs de replicación antiguas.

### Migración de una base de datos de Amazon RDS para PostgreSQL sin usar la cuenta de usuario principal
<a name="CHAP_Source.PostgreSQL.RDSPostgreSQL.NonMasterUser"></a>

En algunos casos, es posible que no utilice la cuenta de usuario principal para la instancia de base de datos de Amazon RDS PostgreSQL que está utilizando como origen. En estos casos, se crean varios objetos para capturar los eventos del lenguaje de definición de datos (DDL). Puede crear estos objetos en una cuenta que no sea la cuenta principal y, a continuación, crear un activador en la cuenta de usuario principal.

**nota**  
Si establece la configuración de punto de conexión de `CaptureDdls` en `false` en el punto de conexión de origen, no tendrá que crear la tabla y el desencadenador siguientes en la base de datos de origen.

Utilice el siguiente procedimiento para crear estos objetos.

**Para crear objetos**

1. Elija el esquema donde deben crearse los objetos. El esquema predeterminado es `public`. Asegúrese de que el esquema exista y que la cuenta `OtherThanMaster` pueda obtener acceso a él. 

1. Inicie sesión en la instancia de base de datos de PostgreSQL con una cuenta de usuario distinta de la cuenta maestra, aquí la cuenta de `OtherThanMaster`.

1. Cree la tabla `awsdms_ddl_audit` mediante la ejecución del siguiente comando, sustituyendo `objects_schema` en el código siguiente por el nombre del esquema que se va a utilizar.

   ```
   CREATE TABLE objects_schema.awsdms_ddl_audit
   (
     c_key    bigserial primary key,
     c_time   timestamp,    -- Informational
     c_user   varchar(64),  -- Informational: current_user
     c_txn    varchar(16),  -- Informational: current transaction
     c_tag    varchar(24),  -- Either 'CREATE TABLE' or 'ALTER TABLE' or 'DROP TABLE'
     c_oid    integer,      -- For future use - TG_OBJECTID
     c_name   varchar(64),  -- For future use - TG_OBJECTNAME
     c_schema varchar(64),  -- For future use - TG_SCHEMANAME. For now - holds current_schema
     c_ddlqry  text         -- The DDL query associated with the current DDL event
   );
   ```

1. Cree la función `awsdms_intercept_ddl`. Para ello, ejecute el siguiente comando y sustituya `objects_schema` en el código siguiente por el nombre del esquema que se va a utilizar.

   ```
   CREATE OR REPLACE FUNCTION objects_schema.awsdms_intercept_ddl()
     RETURNS event_trigger
   LANGUAGE plpgsql
   SECURITY DEFINER
     AS $$
     declare _qry text;
   BEGIN
     if (tg_tag='CREATE TABLE' or tg_tag='ALTER TABLE' or tg_tag='DROP TABLE' or tg_tag = 'CREATE TABLE AS') then
            SELECT current_query() into _qry;
            insert into objects_schema.awsdms_ddl_audit
            values
            (
            default,current_timestamp,current_user,cast(TXID_CURRENT()as varchar(16)),tg_tag,0,'',current_schema,_qry
            );
            delete from objects_schema.awsdms_ddl_audit;
   end if;
   END;
   $$;
   ```

1. Cierre sesión en la cuenta `OtherThanMaster` e inicie sesión con una cuenta que tenga el rol `rds_superuser` asignado.

1. Cree el activador de eventos `awsdms_intercept_ddl`; para ello, ejecute el siguiente comando.

   ```
   CREATE EVENT TRIGGER awsdms_intercept_ddl ON ddl_command_end 
   EXECUTE PROCEDURE objects_schema.awsdms_intercept_ddl();
   ```

1. Asegúrese de que todos los usuarios y roles que acceden a estos eventos tengan los permisos de DDL necesarios. Por ejemplo:

   ```
   grant all on public.awsdms_ddl_audit to public;
   grant all on public.awsdms_ddl_audit_c_key_seq to public;
   ```

Cuando haya completado el procedimiento anterior, puede crear el punto de enlace de origen de AWS DMS utilizando la cuenta `OtherThanMaster`.

**nota**  
Estos eventos se desencadenan mediante instrucciones `CREATE TABLE`, `ALTER TABLE` y `DROP TABLE`.

## Habilitación de la captura de datos de cambios (CDC) mediante replicación lógica
<a name="CHAP_Source.PostgreSQL.Security"></a>

Puede utilizar la característica de replicación lógica nativa de PostgreSQL para habilitar la captura de datos de cambios (CDC) durante la migración de bases de datos para orígenes de PostgreSQL. Puede utilizar esta característica con una instancia de base de datos SQL de PostgreSQL autoadministrada y también con una instancia de base de datos SQL de Amazon RDS para PostgreSQL. Este enfoque reduce el tiempo de inactividad y le ayuda a asegurar que la base de datos de destino esté sincronizada con la base de datos de PostgreSQL de origen.

AWS DMS admite tablas CDC para PostgreSQL con claves principales. Si una tabla no tiene una clave principal, los registros de escritura anticipada (WAL) no incluyen una imagen anterior de la fila de la base de datos. En este caso, DMS no puede actualizar la tabla. En este caso, puede utilizar opciones de configuración adicionales y utilizar la identidad de réplica de la tabla como solución alternativa. Sin embargo, este enfoque puede generar registros adicionales. Le recomendamos que utilice la identidad de réplica de la tabla como solución alternativa solo después de realizar pruebas exhaustivas. Para obtener más información, consulte [Ajustes de configuración adicionales al utilizar una base de datos de PostgreSQL como origen de DMS](#CHAP_Source.PostgreSQL.Advanced).

**nota**  
REPLICA IDENTITY FULL es compatible con un complemento de decodificación lógica, pero no con un complemento pglogical. Para obtener más información, consulte la [documentación de pglogical](https://github.com/2ndQuadrant/pglogical#primary-key-or-replica-identity-required).

Para tareas de carga completa y solo para CDC y CDC, AWS DMS utiliza ranuras de replicación lógica para conservar los registros de WAL para la replicación hasta que se decodifiquen. Cuando se reinicia (no se reanuda) durante una tarea de carga completa y CDC o una tarea de CDC, se vuelve a crear la ranura de replicación.

**nota**  
Para la decodificación lógica, DMS utiliza el complemento test\$1decocoding o pglogical. Si el complemento pglogical está disponible en una base de datos de PostgreSQL de origen, DMS crea una ranura de replicación con pglogical, de lo contrario se utiliza un complemento test\$1decoding. Para obtener más información acerca del complemento test\$1decoding, consulte la [documentación de PostgreSQL](https://www.postgresql.org/docs/9.4/test-decoding.html).  
Si el parámetro de la base de datos `max_slot_wal_keep_size` está establecido en un valor que no es el predeterminado y el tamaño `restart_lsn` de la ranura de replicación es inferior al LSN actual, la tarea de DMS no se realizará correctamente debido a la eliminación de los archivos WAL necesarios.

### Configuración del complemento pglogical
<a name="CHAP_Source.PostgreSQL.Security.Pglogical"></a>

Implementado como una extensión de PostgreSQL, el complemento pglogical es un sistema y modelo de replicación lógica para la replicación selectiva de datos. La siguiente tabla identifica las versiones de base de datos PostgreSQL de origen que admiten el complemento pglogical.


|  Origen de PostgreSQL   |  Admite pglogical  | 
| --- | --- | 
|  PostgreSQL 9.4 o superiores autoadministrado  |  Sí  | 
|  Amazon RDS PostgreSQL 9.5 o versiones anteriores  |  No  | 
|  Amazon RDS PostgreSQL 9.6 o versiones superiores  |  Sí  | 
|  Aurora PostgreSQL 1.x hasta 2.5.x  |  No  | 
|  Aurora PostgreSQL 2.6.x o versiones superiores  |  Sí  | 
|  Aurora PostgreSQL 3.3.x o versiones superiores  |  Sí  | 

Antes de configurar pglogical para su uso con AWS DMS, active primero la replicación lógica para la captura de datos de cambios (CDC) en la base de datos de origen de PostgreSQL. 
+ Para obtener información sobre cómo habilitar la replicación lógica para CDC en bases de datos de origen PostgreSQL *autoadministradas*, consulte [Permitir a los CDC utilizar una base de datos PostgreSQL autogestionada como fuente AWS DMS](#CHAP_Source.PostgreSQL.Prerequisites.CDC)
+ Para obtener información sobre cómo habilitar la replicación lógica para CDC en bases de datos de origen PostgreSQL *administradas por AWS*, consulte [Habilitar CDC con una instancia de base AWS de datos PostgreSQL administrada con AWS DMS](#CHAP_Source.PostgreSQL.RDSPostgreSQL.CDC).

Una vez habilitada la replicación lógica en la base de datos de origen PostgreSQL, siga los siguientes pasos para configurar pglogical para su uso con DMS.

**Para usar el complemento pglogical para la replicación lógica en una base de datos fuente de PostgreSQL con AWS DMS**

1. Cree una extensión pglogical en la base de datos PostgreSQL de origen:

   1. Establezca el parámetro correcto:
      + Para las bases de datos PostgreSQL autoadministradas, establezca el parámetro `shared_preload_libraries= 'pglogical'` de la base de datos.
      + Para las bases de datos PostgreSQL en Amazon RDS y Amazon Aurora PostgreSQL-Compatible Edition, establezca el parámetro `shared_preload_libraries` en `pglogical` en el mismo grupo de parámetros de RDS.

   1. Reinicie la base de datos de origen de PostgreSQL.

   1. En la base de datos PostgreSQL, ejecute el comando, `create extension pglogical;`

1. Ejecute el siguiente comando para comprobar que pglogical se ha instalado correctamente:

   `select * FROM pg_catalog.pg_extension`

Ahora puede crear una AWS DMS tarea que realice la captura de datos de cambios para el punto final de la base de datos de origen de PostgreSQL.

**nota**  
Si no habilita pglogical en la base de datos de origen de PostgreSQL, AWS DMS utiliza el complemento `test_decoding` de forma predeterminada. Cuando pglogical está activado para la decodificación lógica, AWS DMS utiliza pglogical de forma predeterminada. Pero puede configurar el atributo de conexión adicional `PluginName` para usar el complemento `test_decoding` en su lugar.

## Uso de puntos de inicio de CDC nativo para configurar una carga de CDC de un origen de PostgreSQL
<a name="CHAP_Source.PostgreSQL.v10"></a>

Para habilitar puntos de inicio de CDC nativos con PostgreSQL como origen, establezca el atributo de conexión adicional `slotName` en el nombre de una ranura de replicación lógica existente al crear el punto de conexión. Esta ranura de replicación lógica guarda los cambios continuos desde el momento en que se creó el punto de enlace, por lo que permite replicar desde un punto anterior. 

PostgreSQL escribe los cambios de la base de datos en archivos WAL que solamente se descartan cuando AWS DMS lee correctamente los cambios de la ranura de replicación lógica. El uso de ranuras de replicación lógica puede evitar que los cambios registrados se eliminen antes de que el motor de replicación los consuma. 

Sin embargo, en función de la tasa de cambio y consumo, los cambios que contiene una ranura de replicación lógica pueden provocar un uso elevado del disco. Se recomienda establecer alarmas de uso de espacio en la instancia de PostgreSQL de origen cuando se utilizan ranuras de replicación lógica. Para obtener más información acerca de cómo establecer el atributo `slotName` de conexión adicional, consulte [Configuración de punto final y atributos de conexión adicionales (ECAs) cuando se utiliza PostgreSQL como fuente de DMS](#CHAP_Source.PostgreSQL.ConnectionAttrib).

En el siguiente procedimiento, se explica este enfoque paso a paso con más detalle.

**Para utilizar un punto de inicio de CDC nativo con el fin de configurar una carga de CDC de un punto de enlace de origen de PostgreSQL**

1. Identifique una ranura de replicación lógica que se haya empleado en una tarea de replicación anterior (una tarea principal) para utilizarla como punto de inicio. A continuación, consulte la vista `pg_replication_slots` de la base de datos de origen para asegurarse de que esta ranura no tenga ninguna conexión activa. Si tiene, resuélvalas y ciérrelas antes de continuar.

   En los siguientes pasos, vamos a suponer que la ranura de replicación lógica es `abc1d2efghijk_34567890_z0yx98w7_6v54_32ut_1srq_1a2b34c5d67ef`. 

1. Cree un nuevo punto de enlace de origen que incluya la siguiente configuración adicional de atributos de conexión:

   ```
   slotName=abc1d2efghijk_34567890_z0yx98w7_6v54_32ut_1srq_1a2b34c5d67ef;
   ```

1. Cree una nueva tarea exclusiva para los CDC mediante la consola o la API. AWS CLI AWS DMS Por ejemplo, puede usar la CLI para ejecutar el siguiente comando `create-replication-task`. 

   ```
   aws dms create-replication-task --replication-task-identifier postgresql-slot-name-test 
   --source-endpoint-arn arn:aws:dms:us-west-2:012345678901:endpoint:ABCD1EFGHIJK2LMNOPQRST3UV4 
   --target-endpoint-arn arn:aws:dms:us-west-2:012345678901:endpoint:ZYX9WVUTSRQONM8LKJIHGF7ED6 
   --replication-instance-arn arn:aws:dms:us-west-2:012345678901:rep:AAAAAAAAAAA5BB4CCC3DDDD2EE 
   --migration-type cdc --table-mappings "file://mappings.json" --cdc-start-position "4AF/B00000D0" 
   --replication-task-settings "file://task-pg.json"
   ```

   En el comando anterior, se establecen las siguientes opciones:
   + La opción `source-endpoint-arn` se establece en el nuevo valor que creó en el paso 2.
   + La opción `replication-instance-arn` se establece en el mismo valor que en la tarea principal del paso 1.
   + Las opciones `table-mappings` y `replication-task-settings` se establecen en los mismos valores que en la tarea principal del paso 1.
   + Se establece la opción `cdc-start-position` para iniciar un valor de posición. Para encontrar esta posición inicial, consulte la vista `pg_replication_slots` de la base de datos de origen o vea los detalles de la consola de la tarea principal en el paso 1. Para obtener más información, consulte [Determinar un punto de inicio de CDC nativo](CHAP_Task.CDC.md#CHAP_Task.CDC.StartPoint.Native).

   Para activar el modo de inicio personalizado de los CDC al crear una nueva tarea exclusiva para los CDC mediante la AWS DMS consola, haga lo siguiente:
   + En la sección **Configuración de tareas**, para el **modo de inicio de CDC para las transacciones de origen**, elija **Habilitar el modo de inicio de CDC personalizado**.
   + Para el **punto de inicio personalizado de CDC para las transacciones de origen**, elija **Especificar un número de secuencia de registro**. Especifique el número de cambio del sistema o elija **Especificar un punto de control de recuperación** y proporcione un punto de control de recuperación.

   Cuando se ejecuta esta tarea de CDC, se AWS DMS genera un error si la ranura de replicación lógica especificada no existe. También se genera un error si la tarea no se crea con una configuración válida para `cdc-start-position`.

Si utiliza puntos de partida nativos de CDC con el complemento pglogical y desea utilizar una nueva ranura de replicación, complete los pasos de configuración que se indican a continuación antes de crear una tarea de CDC. 

**Uso de una nueva ranura de replicación que no se haya creado anteriormente como parte de otra tarea de DMS**

1. Cree una ranura de replicación, como se muestra a continuación:

   ```
   SELECT * FROM pg_create_logical_replication_slot('replication_slot_name', 'pglogical');
   ```

1. Una vez que la base de datos crea la ranura de replicación, obtenga y anote los valores **restart\$1lsn** y **confirmed\$1flush\$1lsn** de la ranura:

   ```
   select * from pg_replication_slots where slot_name like 'replication_slot_name';
   ```

   Tenga en cuenta que la posición de inicio nativa de CDC para una tarea de CDC creada después de la ranura de replicación no puede ser anterior al valor **confirmed\$1flush\$1lsn**.

   Para obtener información sobre los valores **restart\$1lsn** y **confirmed\$1flush\$1lsn**, consulte [pg\$1replication\$1slots](https://www.postgresql.org/docs/14/view-pg-replication-slots.html) 

1. Cree un nodo pglogical.

   ```
   SELECT pglogical.create_node(node_name := 'node_name', dsn := 'your_dsn_name');
   ```

1. Cree dos conjuntos de replicación mediante la función `pglogical.create_replication_set`. El primer conjunto de replicación realiza un seguimiento de las actualizaciones y eliminaciones de las tablas que tienen claves principales. El segundo conjunto de replicación rastrea solo las inserciones y tiene el mismo nombre que el primer conjunto de replicación, con el prefijo “i” agregado.

   ```
   SELECT pglogical.create_replication_set('replication_slot_name', false, true, true, false);
   SELECT pglogical.create_replication_set('ireplication_slot_name', true, false, false, true);
   ```

1. Agregue una tabla al conjunto de replicación.

   ```
   SELECT pglogical.replication_set_add_table('replication_slot_name', 'schemaname.tablename', true);
   SELECT pglogical.replication_set_add_table('ireplication_slot_name', 'schemaname.tablename', true);
   ```

1. Establezca el atributo de conexión adicional (ECA) que se muestra a continuación al crear el punto de conexión de origen.

   ```
   PluginName=PGLOGICAL;slotName=slot_name;
   ```

Ahora puede crear una tarea exclusiva de CDC con un punto de partida nativo de PostgreSQL mediante la nueva ranura de replicación. Para obtener más información sobre el complemento de pglogical, consulte la [documentación de pglogical 3.7](https://www.enterprisedb.com/docs/pgd/3.7/pglogical/)

## Migración de PostgreSQL a PostgreSQL mediante AWS DMS
<a name="CHAP_Source.PostgreSQL.Homogeneous"></a>

Cuando se migra de un motor de base de datos distinto de PostgreSQL a una base de datos PostgreSQL AWS DMS , casi siempre es la mejor herramienta de migración que se puede utilizar. Pero cuando migre de una base de datos de PostgreSQL a una base de datos de PostgreSQL, las herramientas de PostgreSQL pueden ser más eficaces.

### Uso de herramientas nativas de PostgreSQL para migrar datos
<a name="CHAP_Source.PostgreSQL.Homogeneous.Native"></a>

Es recomendable usar las herramientas de migración de bases de datos de PostgreSQL como `pg_dump` si se dan las condiciones siguientes: 
+ Se trata de una migración homogénea, en la que se migra desde una base de datos de PostgreSQL de origen a una base de datos de PostgreSQL de destino. 
+ Se va a migrar una base de datos completa.
+ Las herramientas nativas le permiten migrar sus datos con un tiempo de inactividad mínimo. 

La utilidad pg\$1dump usa el comando COPY para crear un esquema y un volcado de datos de una base de datos de PostgreSQL. El script de volcado generado por pg\$1dump carga los datos en una base de datos con el mismo nombre y vuelve a crear las tablas, los índices y las claves externas. Para restaurar los datos en una base de datos con un nombre diferente, use el comando `pg_restore` y el parámetro `-d`.

Si va a migrar datos de una base de datos de origen de PostgreSQL que se ejecuta en EC2 a un destino de Amazon RDS para PostgreSQL, puede utilizar el complemento pglogical.

Para obtener más información sobre la importación de una base de datos de PostgreSQL en Amazon RDS para PostgreSQL o Amazon Aurora PostgreSQL-Compatible Edition, consulte [https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/PostgreSQL.Procedural.Importing.html](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/PostgreSQL.Procedural.Importing.html).

### Uso de DMS para migrar datos de PostgreSQL a PostgreSQL
<a name="CHAP_Source.PostgreSQL.Homogeneous.DMS"></a>

 AWS DMS puede migrar datos, por ejemplo, de una base de datos PostgreSQL de origen local a una instancia de Amazon RDS for PostgreSQL o Aurora PostgreSQL de destino. Los tipos de datos de PostgreSQL básicos se migran normalmente sin problemas.

**nota**  
Al replicar tablas particionadas de un origen de PostgreSQL a un destino de PostgreSQL, no es necesario que mencione la tabla principal como parte de los criterios de selección en la tarea de DMS. Mencionar la tabla principal provoca que los datos se dupliquen en las tablas secundarias del destino, lo que podría provocar una infracción de PK. Al seleccionar solo las tablas secundarias en los criterios de selección de la asignación de tablas, la tabla principal se rellena automáticamente.

Es posible que los tipos de datos que se admiten en la base de datos de origen pero que no se admiten en la de destino no se migren correctamente. AWS DMS transmite algunos tipos de datos como cadenas si se desconoce el tipo de datos. Algunos tipos de datos, como XML y JSON, se pueden migrar correctamente como archivos pequeños, pero se puede producir un error si los documentos son grandes. 

Cuando realice la migración de un tipo de datos, tenga en cuenta lo siguiente:
+ En algunos casos, el tipo de datos NUMERIC(p,s) de PostgreSQL no especifica ninguna precisión ni escala. Para las versiones 3.4.2 y anteriores de DMS, DMS usa una precisión de 28 y una escala de 6 de forma predeterminada, NUMERIC(28,6). Por ejemplo, el valor 0.611111104488373 del origen se convierte a 0.611111 en el destino de PostgreSQL.
+ Una tabla con un tipo de datos de MATRIZ debe contar con una clave principal. Una tabla con un tipo de datos de MATRIZ a la que le falta una clave principal se suspende durante la carga completa.

En la siguiente tabla se muestran los tipos de datos de PostgreSQL de origen y se indica si pueden migrarse correctamente:


| Tipo de datos: | Se migra correctamente | Se migra parcialmente | no migra | Comentarios | 
| --- | --- | --- | --- | --- | 
| INTEGER | X |  |  |  | 
| SMALLINT | X |  |  |  | 
| BIGINT | X |  |  |  | 
| NUMERIC/DECIMAL(p,s) |  | X |  | Donde 0<p<39 y 0<s | 
| NUMERIC/DECIMAL |  | X |  | Donde p>38 o p=s=0 | 
| REAL | X |  |  |  | 
| DOUBLE | X |  |  |  | 
| SMALLSERIAL | X |  |  |  | 
| SERIAL | X |  |  |  | 
| BIGSERIAL | X |  |  |  | 
| MONEY | X |  |  |  | 
| CHAR |  | X |  | Sin precisión especificada | 
| CHAR(n) | X |  |  |  | 
| VARCHAR |  | X |  | Sin precisión especificada | 
| VARCHAR(n) | X |  |  |  | 
| TEXT | X |  |  |  | 
| BYTEA | X |  |  |  | 
| TIMESTAMP | X |  |  | Los valores infinitos positivos y negativos se truncan a “9999-12-31 23:59:59” y “4713-01-01 00:00:00 a. C.”, respectivamente. | 
| MARCA DE TIEMPO CON ZONA HORARIA |  | X |  |  | 
| DATE | X |  |  |  | 
| TIME | X |  |  |  | 
| HORA CON ZONA HORARIA | X |  |  |  | 
| INTERVAL |  | X |  |  | 
| BOOLEANO | X |  |  |  | 
| ENUM |  |  | X |  | 
| CIDR | X |  |  |  | 
| INET |  |  | X |  | 
| MACADDR |  |  | X |  | 
| TSVECTOR |  |  | X |  | 
| TSQUERY |  |  | X |  | 
| XML |  | X |  |  | 
| POINT | X |  |  | Tipo de datos espaciales PostGIS | 
| LINE |  |  | X |  | 
| LSEG |  |  | X |  | 
| BOX |  |  | X |  | 
| PATH |  |  | X |  | 
| POLYGON | X |  |  | Tipo de datos espaciales PostGIS | 
| CIRCLE |  |  | X |  | 
| JSON |  | X |  |  | 
| ARRAY | X |  |  | Requiere clave principal | 
| COMPOSITE |  |  | X |  | 
| RANGE |  |  | X |  | 
| LINESTRING | X |  |  | Tipo de datos espaciales PostGIS | 
| MULTIPOINT | X |  |  | Tipo de datos espaciales PostGIS | 
| MULTILINESTRING | X |  |  | Tipo de datos espaciales PostGIS | 
| MULTIPOLYGON | X |  |  | Tipo de datos espaciales PostGIS | 
| GEOMETRYCOLLECTION | X |  |  | Tipo de datos espaciales PostGIS | 

### Migración de tipos de datos espaciales PostGIS
<a name="CHAP_Source.PostgreSQL.DataTypes.Spatial"></a>

Los *datos espaciales* identifican la información de geometría de un objeto o ubicación en el espacio. Las bases de datos relacionales de objetos de PostgreSQL admiten los tipos de datos espaciales PostGIS. 

Antes de migrar objetos de datos espaciales de PostgreSQL, asegúrese de que el complemento PostGIS esté habilitado en el nivel global. De este modo, se garantiza que se AWS DMS crean las columnas de datos espaciales de origen exactas para la instancia de base de datos de destino de PostgreSQL.

Para las migraciones homogéneas de PostgreSQL a PostgreSQL AWS DMS , admite la migración de tipos y subtipos de objetos de datos geométricos y geográficos (coordenadas geodésicas) de PostGIS, como los siguientes:
+  POINT 
+  LINESTRING 
+  POLYGON 
+  MULTIPOINT 
+  MULTILINESTRING 
+  MULTIPOLYGON 
+  GEOMETRYCOLLECTION 

## Migración de Babelfish a Amazon Aurora PostgreSQL mediante AWS DMS
<a name="CHAP_Source.PostgreSQL.Babelfish"></a>

Puede migrar las tablas fuente de PostgreSQL de Babelfish para Aurora a cualquier punto final de destino compatible utilizando. AWS DMS

Al crear el punto de enlace de AWS DMS origen mediante la consola de DMS, la API o los comandos CLI, establece el origen en **Amazon Aurora PostgreSQL** y el nombre de la base de datos en. **babelfish\$1db** En la sección **Endpoint Settings**, asegúrese de que **DatabaseMode**esté establecido en **Babelfish** y en el nombre de la base de datos **BabelfishDatabaseName**T-SQL Babelfish de origen. En lugar de usar el puerto TCP de Babelfish **1433**, utilice el puerto TCP de Aurora PostgreSQL **5432**.

Debe crear las tablas antes de migrar los datos para asegurarse de que DMS utiliza los tipos de datos y los metadatos de las tablas correctos. Si no crea las tablas en el destino antes de ejecutar la migración, es posible que DNS cree las tablas con permisos y tipos de datos incorrectos.

### Agregar reglas de transformación a la tarea de migración
<a name="CHAP_Source.PostgreSQL.Babelfish.Transform"></a>

Al crear una tarea de migración para un origen de Babelfish, debe incluir reglas de transformación que garanticen que DMS utilice las tablas de destino creadas previamente.

Si configuró el modo de migración de bases de datos múltiples al definir el clúster de Babelfish para PostgreSQL, agregue una regla de transformación que cambie el nombre del esquema al del esquema de T-SQL. Por ejemplo, si el nombre del esquema de T-SQL es `dbo` y el nombre del esquema de Babelfish para PostgreSQL es `mydb_dbo`, cambie el nombre del esquema a `dbo` mediante una regla de transformación. Para encontrar el nombre del esquema de PostgreSQL, consulte [Arquitectura de Babelfish](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/babelfish-architecture.html) en la *Guía del usuario de Amazon Aurora*. 

Si utiliza el modo de base de datos única, no necesita una regla de transformación para cambiar el nombre de los esquemas de base de datos. Los nombres de los esquemas de PostgreSQL tienen one-to-one un mapeo con los nombres de los esquemas de la base de datos de T-SQL.

El siguiente ejemplo de regla de transformación muestra cómo volver a cambiar el nombre del esquema de `mydb_dbo` a `dbo`:

```
{
    "rules": [
        {
            "rule-type": "transformation",
            "rule-id": "566251737",
            "rule-name": "566251737",
            "rule-target": "schema",
            "object-locator": {
                "schema-name": "mydb_dbo"
            },
            "rule-action": "rename",
            "value": "dbo",
            "old-value": null
        },
        {
            "rule-type": "selection",
            "rule-id": "566111704",
            "rule-name": "566111704",
            "object-locator": {
                "schema-name": "mydb_dbo",
                "table-name": "%"
            },
            "rule-action": "include",
            "filters": []
        }
    ]
}
```

### Restricciones en el uso de un punto de conexión de origen de PostgreSQL con tablas de Babelfish
<a name="CHAP_Source.PostgreSQL.Babelfish.Limitations"></a>

Las siguientes restricciones se aplican al usar un punto de conexión de origen de PostgreSQL con tablas de Babelfish:
+ DMS solo admite la migración desde las versiones 16.2/15.6 y posteriores de Babelfish y desde la versión 3.5.3 y posteriores de DMS.
+ DMS no replica los cambios de la definición de tabla de Babelfish en el punto de conexión de destino. Una solución para esta limitación consiste en aplicar primero los cambios de la definición de tabla en el destino y, a continuación, cambiar la definición de la tabla en el origen de Babelfish.
+ Al crear tablas de Babelfish con el tipo de datos BYTEA, DMS las convierte al tipo de datos `varbinary(max)` al migrar a SQL Server como destino.
+ DMS no admite el modo de LOB completo para los tipos de datos binarios. En su lugar, utilice el modo de LOB limitado para los tipos de datos binarios.
+ DMS no admite la validación de datos de Babelfish como origen.
+ Para la configuración de la tarea **Modo de preparación de la tabla de destino** utilice solo los modos **No hacer nada** o **Truncar**. No utilice el modo **Borrar tablas en el destino**. Al utilizar **Descartar las tablas en el destino**, DMS puede crear las tablas con tipos de datos incorrectos.
+ Cuando utilice la replicación continua (CDC o Carga completa y CDC), establezca el atributo de conexión adicional `PluginName` en `TEST_DECODING`.
+ DMS no admite la replicación (CDC o Carga completa y CDC) de tablas particionadas para Babelfish como origen.

## Eliminar AWS DMS artefactos de una base de datos fuente de PostgreSQL
<a name="CHAP_Source.PostgreSQL.CleanUp"></a>

Para capturar eventos de DDL, AWS DMS crea varios artefactos en la base de datos de PostgreSQL cuando se inicia una tarea de migración. Cuando se complete la tarea, es posible que quiera eliminar estos artefactos.

Para eliminar los artefactos, emita las instrucciones siguientes (en el orden en el que aparecen), donde `{AmazonRDSMigration}` es el esquema en el que se crearon los artefactos. La operación de ingresar un esquema se debe realizar con su sumo cuidado. No ingrese nunca un esquema operativo, especialmente si es público.

```
drop event trigger awsdms_intercept_ddl;
```

El desencadenador de eventos no pertenece a un esquema específico.

```
drop function {AmazonRDSMigration}.awsdms_intercept_ddl()
drop table {AmazonRDSMigration}.awsdms_ddl_audit
drop schema {AmazonRDSMigration}
```

## Ajustes de configuración adicionales al utilizar una base de datos de PostgreSQL como origen de DMS
<a name="CHAP_Source.PostgreSQL.Advanced"></a>

Puede añadir parámetros de configuración adicionales cuando migre datos desde una base de datos de PostgreSQL de dos maneras:
+ Puede añadir valores al atributo extra connection para capturar eventos DDL y especificar el esquema en el que se crean los artefactos de la base de datos DDL. Para obtener más información, consulte [Configuración de punto final y atributos de conexión adicionales (ECAs) cuando se utiliza PostgreSQL como fuente de DMS](#CHAP_Source.PostgreSQL.ConnectionAttrib).
+ Puede anular parámetros de cadenas de conexión. Elija esta opción para hacer cualquiera de las siguientes acciones:
  + Especifique los parámetros internos. AWS DMS Estos parámetros se necesitan en contadas ocasiones, no están a la vista en la interfaz de usuario.
  + Especifique los valores de transferencia (passthru) para el cliente de base de datos específico. AWS DMS incluye los parámetros de transferencia en la cadena de conexión transferida al cliente de base de datos.
+ Al utilizar el parámetro de nivel de tabla en las versiones 9.4 y posteriores de `REPLICA IDENTITY` PostgreSQL, puede controlar la información que se escribe en los registros de escritura anticipada (). WALs En concreto, lo hace para identificar las filas WALs que se actualizan o eliminan. `REPLICA IDENTITY FULL`registra los valores antiguos de todas las columnas de la fila. Úselo `REPLICA IDENTITY FULL` con cuidado para cada tabla, ya que `FULL` genera un número adicional WALs que puede no ser necesario. Para obtener más información, consulte [ALTER TABLE-REPLICA IDENTITY](https://www.postgresql.org/docs/devel/sql-altertable.html) 

## Réplica de lectura como origen para PostgreSQL
<a name="CHAP_Source.PostgreSQL.ReadReplica"></a>

Utilice réplicas de lectura de PostgreSQL como fuentes de CDC para reducir la carga de la base de datos AWS DMS principal. Esta función está disponible en PostgreSQL 16.x y AWS DMS requiere la versión 3.6.1 o posterior. El uso de réplicas de lectura para el procesamiento de la CDC reduce el impacto operativo en la base de datos principal.

**nota**  
La versión 16.x de Amazon RDS para PostgreSQL presenta limitaciones para la replicación lógica de réplicas de lectura en las configuraciones de tres zonas de disponibilidad (TAZ). Para obtener compatibilidad total con la replicación lógica de réplicas de lectura en las implementaciones de TAZ, debe usar PostgreSQL 17.x o posterior.

### Requisitos previos
<a name="CHAP_Source.PostgreSQL.ReadReplica.prereq"></a>

Antes de utilizar una réplica de lectura como fuente de CDC AWS DMS, debe habilitar la replicación lógica tanto en la instancia de base de datos principal como en su réplica de lectura para crear una decodificación lógica en una réplica de lectura. Lleve a cabo las siguientes acciones:
+ Active la replicación lógica tanto en la instancia de base de datos principal como en su réplica de lectura, junto con cualquier otro parámetro de base de datos necesario. Para obtener más información, consulte [Trabajar con bases de datos PostgreSQL AWS administradas](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Source.PostgreSQL.html#CHAP_Source.PostgreSQL.RDSPostgreSQL) como fuente de DMS.
+ Para las tareas exclusivas de la CDC, cree una ranura de replicación en la instancia principal (de escritura). Para obtener más información, consulte [Uso de puntos de inicio de CDC nativa para configurar una carga de CDC de un origen de PostgreSQL](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Source.PostgreSQL.html#CHAP_Source.PostgreSQL.v10). Esta acción es necesaria, ya que las réplicas de lectura no admiten la creación de ranuras de replicación.
+ Para la versión 16 de PostgreSQL, la ranura debe crearse manualmente en la réplica de lectura.
+ Para la versión 17 y posteriores de PostgreSQL, la ranura de replicación debe crearse en la principal y se sincroniza automáticamente con la réplica de lectura.
+ Al utilizar tareas a plena carga o solo con CDC, AWS DMS puede gestionar automáticamente los intervalos de replicación lógica en las instancias principales, pero no en las réplicas de lectura. Para las réplicas de lectura de PostgreSQL versión 16, debe eliminar y volver a crear manualmente las ranuras de replicación antes de reiniciar una tarea (no reanudarla). Omitir este paso puede provocar errores en las tareas o posiciones de inicio de la CDC incorrectas. A partir de la versión 17 de PostgreSQL, la sincronización de ranuras lógicas desde la instancia principal automatiza este proceso.

Tras cumplir los requisitos previos, puede configurar su terminal de origen replicando la AWS DMS fuente `SlotName` de lectura y réplica en la configuración del terminal y configurar su AWS DMS tarea utilizando los puntos de partida nativos de los CDC. Para obtener más información, consulte [Configuración de puntos de conexión y atributos de conexión adicionales (ECAs) cuando se utiliza PostgreSQL como fuente de DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Source.PostgreSQL.html#CHAP_Source.PostgreSQL.ConnectionAttrib) [y Uso de puntos de inicio nativos de CDC para configurar una carga de CDC de una fuente de](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Source.PostgreSQL.html#CHAP_Source.PostgreSQL.v10) PostgreSQL.

## Uso de la configuración del punto de conexión `MapBooleanAsBoolean` de PostgreSQL
<a name="CHAP_Source.PostgreSQL.ConnectionAttrib.Endpointsetting"></a>

Puede usar la configuración del punto de conexión de PostgreSQL para asignar un booleano como booleano desde el origen de PostgreSQL a un destino de Amazon Redshift. De forma predeterminada, un tipo BOOLEANO se migra como varchar(5). Puede especificar `MapBooleanAsBoolean` para permitir que PostgreSQL migre el tipo booleano como booleano, como se muestra en el siguiente ejemplo.

```
--postgre-sql-settings '{"MapBooleanAsBoolean": true}'
```

Tenga en cuenta que debe establecer esta configuración en los puntos de conexión de origen y destino para que surta efecto.

Como MySQL no tiene ningún tipo BOOLEANO, utilice una regla de transformación en lugar de esta configuración al migrar datos BOOLEANOS a MySQL.

## Configuración de punto final y atributos de conexión adicionales (ECAs) cuando se utiliza PostgreSQL como fuente de DMS
<a name="CHAP_Source.PostgreSQL.ConnectionAttrib"></a>

Puede utilizar la configuración del punto final y los atributos de conexión adicionales (ECAs) para configurar la base de datos fuente de PostgreSQL. Los ajustes de punto final se especifican al crear el punto final de origen mediante la AWS DMS consola o mediante el `create-endpoint` comando de [AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/dms/index.html), con la sintaxis `--postgre-sql-settings '{"EndpointSetting": "value", ...}'` JSON.

En la siguiente tabla se muestran los ajustes de punto final ECAs que puede utilizar con PostgreSQL como fuente.

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/dms/latest/userguide/CHAP_Source.PostgreSQL.html)

## Restricciones en el uso de una base de datos de PostgreSQL como origen de DMS
<a name="CHAP_Source.PostgreSQL.Limitations"></a>

Al utilizar PostgreSQL como origen para AWS DMS se aplican las siguientes restricciones:
+ AWS DMS no funciona con Amazon RDS para PostgreSQL 10.4 ni con Amazon Aurora PostgreSQL 10.4 ni como origen ni como destino.
+ Las tablas de captura deben contar con una clave principal. Si una tabla no tiene una clave principal, AWS DMS ignora las operaciones de eliminación y actualización de registros de esa tabla. Como solución alternativa, consulte [Habilitación de la captura de datos de cambios (CDC) mediante replicación lógica](#CHAP_Source.PostgreSQL.Security). 

  **Nota:** No recomendamos migrar sin un Key/Unique índice principal; de lo contrario, se aplicarán limitaciones adicionales, como la capacidad de aplicación por lotes «NO», la capacidad de LOB total, la validación de datos y la incapacidad de replicar en Redshift Target de manera eficiente.
+ AWS DMS ignora el intento de actualizar un segmento clave principal. En estos casos, el destino identifica la actualización como una que no ha actualizado ninguna fila. Sin embargo, dado que los resultados de actualizar una clave primaria en PostgreSQL son imprevisibles, no se escriben registros en la tabla de excepciones.
+ AWS DMS no admite la opción **Iniciar los cambios del proceso desde la ejecución de la marca de tiempo**.
+ AWS DMS no replica los cambios que resulten de las operaciones de partición o subpartición (`ADD`,`DROP`, o). `TRUNCATE`
+ La replicación de varias tablas con el mismo nombre, donde cada nombre tiene mayúsculas y minúsculas diferentes (por ejemplo, tabla1 y tabla1) puede provocar un comportamiento impredecible. TABLE1 Debido a este problema, AWS DMS no admite este tipo de replicación.
+ En la mayoría de los casos, AWS DMS admite el procesamiento de cambios de las instrucciones DDL CREATE, ALTER y DROP para tablas. AWS DMS no admite este procesamiento de cambios si las tablas se encuentran en un bloque interno del cuerpo de una función o procedimiento o en otras estructuras anidadas.

  Por ejemplo, el siguiente cambio no se capturó.

  ```
  CREATE OR REPLACE FUNCTION attu.create_distributors1() RETURNS void
  LANGUAGE plpgsql
  AS $$
  BEGIN
  create table attu.distributors1(did serial PRIMARY KEY,name
  varchar(40) NOT NULL);
  END;
  $$;
  ```
+ Actualmente, los tipos de datos `boolean` de un origen de PostgreSQL se migran a un destino de SQL Server como tipo de datos `bit` con valores incoherentes. Como solución alternativa, cree previamente la tabla con un tipo de `VARCHAR(1)` datos para la columna (o haga que AWS DMS cree la tabla). A continuación, haga que el procesamiento descendente trate la "F" como falso y la "T" como verdadero.
+ AWS DMS no admite el procesamiento de cambios de las operaciones TRUNCATE.
+ El tipo de datos de LOB OID no se migra al destino.
+ AWS DMS admite el tipo de datos PostGIS solo para migraciones homogéneas.
+ Si el origen es una base de datos de PostgreSQL en las instalaciones o una instancia de Amazon EC2, asegúrese de que el complemento de salida test\$1decoding esté instalado en el punto de conexión de origen. Puede encontrar este complemento en el paquete contrib de PostgreSQL. Para obtener más información acerca del complemento test-decoding consulte la [ documentación de PostgreSQL](https://www.postgresql.org/docs/10/static/test-decoding.html).
+ AWS DMS no admite el procesamiento de cambios para establecer y desconfigurar los valores predeterminados de las columnas (mediante la cláusula ALTER COLUMN SET DEFAULT en las sentencias ALTER TABLE).
+ AWS DMS no admite el procesamiento de cambios para establecer la nulabilidad de las columnas (se utiliza la cláusula ALTER COLUMN [SET\$1DROP] NOT NULL en las sentencias ALTER TABLE).
+ Cuando la replicación lógica está habilitada, el número máximo de cambios guardados en la memoria por transacción es de 4 MB. Después de eso, los cambios se transfieren al disco. Como resultado, `ReplicationSlotDiskUsage` aumenta y `restart_lsn` no avanza hasta que la transacción se complete o detenga y finalice la reversión. Como se trata de una transacción larga, puede tardar mucho tiempo en restaurarse. Por lo tanto, evite las transacciones de larga duración o muchas subtransacciones cuando la replicación lógica esté habilitada. En su lugar, divida la transacción en varias transacciones más pequeñas. 

  En las versiones 13 y posteriores de Aurora PostgreSQL, puede ajustar el parámetro `logical_decoding_work_mem` para controlar cuándo vuelca DMS los datos de cambios en el disco. Para obtener más información, consulte [Archivos de volcado en Aurora PostgreSQL](CHAP_Troubleshooting_Latency_Source_PostgreSQL.md#CHAP_Troubleshooting_Latency_Source_PostgreSQL_Spill).
+ Una tabla con un tipo de datos de MATRIZ debe contar con una clave principal. Una tabla con un tipo de datos de MATRIZ a la que le falta una clave principal se suspende durante la carga completa.
+ AWS DMS [no admite la migración de metadatos de tablas relacionados con la partición o la herencia de tablas.](https://www.postgresql.org/docs/15/ddl-inherit.html) Cuando AWS DMS encuentra una tabla particionada o una tabla que utiliza la herencia, se observa el siguiente comportamiento:
  + AWS DMS identifica e informa de las tablas principales y secundarias que participan en la partición o la herencia en la base de datos de origen.
  + **Creación de tablas en la base de datos de destino**: en la base de datos de destino, AWS DMS crea la tabla como una tabla estándar (no particionada ni heredada), conservando la estructura y las propiedades de las tablas seleccionadas, pero no la lógica de partición o herencia.
  + **Diferenciación de registros en tablas heredadas**: en el caso de las tablas que utilizan la herencia, AWS DMS no distingue los registros que pertenecen a las tablas secundarias al rellenar la tabla principal. Como resultado, no utiliza consultas SQL con sintaxis como: `SELECT * FROM ONLY parent_table_name`.
+ Para replicar tablas con particiones desde un origen de PostgreSQL a un destino de PostgreSQL, primero debe crear manualmente las tablas principal y secundaria en el destino. A continuación, defina una tarea independiente para replicar en estas tablas. En tal caso, establezca la configuración de la tarea en **Truncar antes de cargar**.
+ El tipo de datos `NUMERIC` de PostgreSQL no tiene un tamaño fijo. Cuando se transfieren datos que tienen el tipo de datos `NUMERIC` pero sin precisión ni escala, DMS utiliza `NUMERIC(28,6)` (con una precisión de 28 y una escala de 6) de forma predeterminada. Por ejemplo, el valor 0,611111104488373 del origen se convierte a 0,611111 en el destino de PostgreSQL.
+ AWS DMS admite Aurora PostgreSQL Serverless V1 como fuente únicamente para tareas de carga completa. AWS DMS admite Aurora PostgreSQL Serverless V2 como fuente para tareas de carga completa, carga completa, CDC y únicamente CDC.
+ AWS DMS no admite la replicación de una tabla con un índice único creado con una función de fusión.
+ Si la definición de la clave principal en el origen y el destino no coinciden, los resultados de la replicación pueden ser impredecibles.
+ Cuando se utiliza la característica de carga paralela, no se admite la segmentación de tablas en función de particiones o subparticiones. Para obtener más información acerca de la carga paralela, consulte [Uso de carga paralela para tablas, vistas y recopilaciones seleccionadas](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.md#CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.ParallelLoad) 
+ AWS DMS no admite restricciones diferidas.
+ AWS DMS La versión 3.4.7 admite PostgreSQL 14.x como fuente con las siguientes limitaciones:
  + AWS DMS no admite el procesamiento de cambios de las confirmaciones en dos fases.
  + AWS DMS no admite la replicación lógica para transmitir transacciones prolongadas en curso.
+ AWS DMS no admite CDC para Amazon RDS Proxy para PostgreSQL como fuente.
+ Si se utilizan [filtros de origen](CHAP_Tasks.CustomizingTasks.Filters.md) que no contienen una columna de clave principal, no se capturarán las operaciones `DELETE`.
+ Si la base de datos de origen también es el destino de otro sistema de replicación de terceros, es posible que los cambios de DDL no se migren durante CDC. Porque esa situación puede impedir que se active el desencadenador del evento `awsdms_intercept_ddl`. Para evitar la situación, modifique ese desencadenador en la base de datos de origen de la siguiente manera:

  ```
  alter event trigger awsdms_intercept_ddl enable always;
  ```
+ AWS DMS no admite la replicación de los cambios realizados en las definiciones de las claves principales de la base de datos de origen. Si la estructura de clave principal se modifica durante una tarea de replicación activa, los cambios posteriores en las tablas afectadas no se replican en la de destino.
+ En la replicación DDL como parte de un script, el número total máximo de comandos DDL por script es de 8192 y el número total máximo de líneas por script es de 8192 líneas.
+ AWS DMS no admite vistas materializadas.
+ Para tareas de carga completa y de CDC que utilizan una réplica de lectura como fuente, AWS DMS no se pueden crear ranuras de replicación en las réplicas de lectura.

## Tipos de datos de origen para PostgreSQL
<a name="CHAP_Source-PostgreSQL-DataTypes"></a>

En la siguiente tabla se muestran los tipos de datos de origen de PostgreSQL que se admiten cuando se AWS DMS utiliza y la asignación AWS DMS predeterminada a los tipos de datos.

Para obtener más información sobre cómo ver el tipo de datos que se asigna en el destino, consulte la sección del punto de enlace de destino que esté utilizando.

Para obtener información adicional sobre AWS DMS los tipos de datos, consulte. [Tipos de datos de AWS Database Migration Service](CHAP_Reference.DataTypes.md)


|  Tipos de datos de PostgreSQL  |  Tipos de datos de DMS  | 
| --- | --- | 
|  INTEGER  |  INT4  | 
|  SMALLINT  |  INT2  | 
|  BIGINT  |  INT8  | 
|  NUMERIC (p,s)  |  Si la precisión es de 0 a 38, utilice NUMERIC. Si la precisión es 39 o superior, utilice STRING.  | 
|  DECIMAL(P,S)  |  Si la precisión es de 0 a 38, utilice NUMERIC. Si la precisión es 39 o superior, utilice STRING.  | 
|  REAL  |  REAL4  | 
|  DOBLE  |  REAL8  | 
|  SMALLSERIAL  |  INT2  | 
|  SERIAL  |  INT4  | 
|  BIGSERIAL  |  INT8  | 
|  MONEY  |  NUMERIC(38,4) El tipo de datos MONEY se asigna a FLOAT en SQL Server.  | 
|  CHAR  |  WSTRING (1)  | 
|  CHAR(N)  |  WSTRING (n)  | 
|  VARCHAR(N)  |  WSTRING (n)  | 
|  TEXT  |  NCLOB  | 
|  CITEXT  |  NCLOB  | 
|  BYTEA  |  BLOB  | 
|  TIMESTAMP  |  DATETIME  | 
|  MARCA DE TIEMPO CON ZONA HORARIA  |  DATETIME  | 
|  DATE  |  DATE  | 
|  TIME  |  TIME  | 
|  HORA CON ZONA HORARIA  |  TIME  | 
|  INTERVAL  |  STRING (128): 1 YEAR, 2 MONTHS, 3 DAYS, 4 HOURS, 5 MINUTES, 6 SECONDS  | 
|  BOOLEANO  |  CHAR (5) false o true  | 
|  ENUM  |  STRING (64)  | 
|  CIDR  |  STRING (50)  | 
|  INET  |  STRING (50)  | 
|  MACADDR  |  STRING (18)  | 
|  BIT (n)  |  STRING (n)  | 
|  BIT VARYING (n)  |  STRING (n)  | 
|  UUID  |  STRING  | 
|  TSVECTOR  |  CLOB  | 
|  TSQUERY  |  CLOB  | 
|  XML  |  CLOB  | 
|  POINT  |  STRING (255) "(x,y)"  | 
|  LINE  |  STRING (255) "(x,y,z)"  | 
|  LSEG  |  STRING (255) "((x1,y1),(x2,y2))"  | 
|  BOX  |  STRING (255) "((x1,y1),(x2,y2))"  | 
|  PATH  |  CLOB "((x1,y1),(xn,yn))"  | 
|  POLYGON  |  CLOB "((x1,y1),(xn,yn))"  | 
|  CIRCLE  |  STRING (255) "(x,y),r"  | 
|  JSON  |  NCLOB  | 
|  JSONB  |  NCLOB  | 
|  ARRAY  |  NCLOB  | 
|  COMPOSITE  |  NCLOB  | 
|  HSTORE  |  NCLOB  | 
|  INT4RANGO  |  STRING (255)  | 
|  INT8ALCANCE  |  STRING (255)  | 
|  NUMRANGE  |  STRING (255)  | 
|  STRRANGE  |  STRING (255)  | 

### Trabajo con tipos de datos de origen de LOB para PostgreSQL
<a name="CHAP_Source-PostgreSQL-DataTypes-LOBs"></a>

Los tamaños de columna de PostgreSQL afectan a la conversión de tipos de datos LOB de PostgreSQL a tipos de datos de AWS DMS . Para trabajar con esto, siga los pasos que se indican a continuación para los tipos de AWS DMS datos siguientes:
+ BLOB: establezca **Limitar tamaño de LOB a** en el valor **Tamaño máximo de LOB (KB)** al crear la tarea.
+ CLOB: la replicación trata a cada personaje como un UTF8 personaje. Por lo tanto, encuentre la longitud del texto con más caracteres en la columna, que se muestra aquí como `max_num_chars_text`. Utilice esta longitud para especificar el valor de **Limitar el tamaño de LOB a**. Si los datos incluyen caracteres de 4 bytes, multiplique por 2 para especificar el valor **Limit LOB size to (Limitar tamaño de LOB a)**, que está en bytes. En este caso, **Limit LOB size to (Limitar tamaño de LOB a)** es igual a `max_num_chars_text` multiplicado por 2.
+ NCLOB: la replicación gestiona cada carácter como carácter de dos bytes. Por lo tanto, busque la longitud del texto con más caracteres en la columna (`max_num_chars_text`) y multiplíquela por 2. Hace esto para especificar el valor de **Limitar el tamaño de LOB a**. En este caso, **Limit LOB size to (Limitar tamaño de LOB a)** es igual a `max_num_chars_text` multiplicado por 2. Si los datos incluyen caracteres de 4 bytes, multiplíquelos por 2 de nuevo. En este caso, **Limit LOB size to (Limitar tamaño de LOB a)** es igual a `max_num_chars_text` multiplicado por 4.

# Uso de una base de datos compatible con MySQL como fuente para AWS DMS
<a name="CHAP_Source.MySQL"></a>

Puede migrar datos desde cualquier base de datos compatible con MySQL (MySQL, MariaDB o Amazon Aurora MySQL) mediante Database Migration Service. AWS 

Para obtener información sobre las versiones de MySQL que se AWS DMS admiten como fuente, consulte[Fuentes de AWS DMS](CHAP_Introduction.Sources.md). 

Puede utilizar SSL para cifrar las conexiones entre su punto de enlace compatible con MySQL y la instancia de replicación. Para obtener más información acerca de cómo utilizar SSL con un punto de enlace compatible con MySQL, consulte [Uso de SSL con AWS Database Migration Service](CHAP_Security.SSL.md).

En las secciones siguientes, el término “autoadministrado” se aplica a cualquier base de datos que se instala en las instalaciones o en Amazon EC2. El término “administrado por AWS” se aplica a cualquier base de datos en Amazon RDS, Amazon Aurora o Amazon S3.

Para obtener información adicional sobre cómo trabajar con bases de datos compatibles con MySQL AWS DMS, consulte las siguientes secciones.

**Topics**
+ [Migración de MySQL a MySQL mediante AWS DMS](#CHAP_Source.MySQL.Homogeneous)
+ [Usar cualquier base de datos compatible con MySQL como fuente para AWS DMS](#CHAP_Source.MySQL.Prerequisites)
+ [Uso de una base de datos autogestionada compatible con MySQL como fuente para AWS DMS](#CHAP_Source.MySQL.CustomerManaged)
+ [Uso de una base AWS de datos compatible con MySQL administrada como fuente para AWS DMS](#CHAP_Source.MySQL.AmazonManaged)
+ [Limitaciones del uso de una base de datos MySQL como fuente para AWS DMS](#CHAP_Source.MySQL.Limitations)
+ [Compatibilidad con transacciones XA](#CHAP_Source.MySQL.XA)
+ [Configuración de punto final cuando se utiliza MySQL como fuente para AWS DMS](#CHAP_Source.MySQL.ConnectionAttrib)
+ [Tipos de datos de origen para MySQL](#CHAP_Source.MySQL.DataTypes)

**nota**  
Al configurar las reglas de mapeo AWS Database Migration Service (AWS DMS), es importante evitar el uso de caracteres comodín (%) en los nombres de bases de datos o esquemas. En su lugar, solo debe especificar de forma explícita las bases de datos creadas por los usuarios que deben migrarse. El uso de un carácter comodín incluye todas las bases de datos del proceso de migración, incluidas las bases de datos del sistema que no son necesarias en la instancia de destino. Como el usuario maestro de Amazon RDS para MySQL carece de los permisos necesarios para importar datos a las bases de datos del sistema de destino, se produce un error al intentar migrar estas bases de datos del sistema.

## Migración de MySQL a MySQL mediante AWS DMS
<a name="CHAP_Source.MySQL.Homogeneous"></a>

Para una migración heterogénea, en la que se migra de un motor de base de datos distinto de MySQL a una base de datos MySQL, casi siempre AWS DMS es la mejor herramienta de migración que se puede utilizar. Sin embargo, para una migración homogénea, en la que se migra de una base de datos de MySQL a una base de datos de MySQL, le recomendamos que utilice un proyecto de migración de migraciones de datos homogéneas. Las migraciones de datos homogéneas utilizan herramientas de bases de datos nativas para proporcionar un rendimiento y una precisión de migración de datos mejorados en comparación con AWS DMS.

## Usar cualquier base de datos compatible con MySQL como fuente para AWS DMS
<a name="CHAP_Source.MySQL.Prerequisites"></a>

Antes de empezar a trabajar con una base de datos MySQL como fuente AWS DMS, asegúrese de cumplir los siguientes requisitos previos. Estos requisitos previos se aplican a las fuentes autogestionadas o AWS gestionadas.

Debe tener una cuenta AWS DMS que tenga la función de administrador de replicación. El rol necesita los siguientes privilegios:
+ **REPLICATION CLIENT**: este privilegio es necesario solo para tareas de CDC. En otras palabras, full-load-only las tareas no requieren este privilegio. 
**nota**  
Para MariaDB versión 10.5.2\$1, puede usar BINLOG MONITOR, que reemplaza al CLIENTE DE REPLICACIÓN.
+ **REPLICATION SLAVE**: este privilegio es necesario solo para tareas de CDC. En otras palabras, las full-load-only tareas no requieren este privilegio.
+ **SUPER**: este privilegio es necesario únicamente en versiones de MySQL anteriores a la 5.6.6.

El AWS DMS usuario también debe tener privilegios SELECT para las tablas de origen designadas para la replicación.

Otorgue los siguientes privilegios si utiliza evaluaciones previas a la migración específicas de MySQL:

```
grant select on mysql.user to <dms_user>;
grant select on mysql.db to <dms_user>;
grant select on mysql.tables_priv to <dms_user>;
grant select on mysql.role_edges to <dms_user>  #only for MySQL version 8.0.11 and higher
grant select on performance_schema.replication_connection_status to <dms_user>;  #Required for primary instance validation - MySQL version 5.7 and higher only
```

Si utiliza una fuente de RDS y planea ejecutar evaluaciones previas a la migración específicas de MySQL, añada el siguiente permiso:

```
grant select on mysql.rds_configuration to <dms_user>;  #Required for binary log retention check
```

Si el parámetro `BatchEnable` es `true` es obligatorio conceder:

```
grant create temporary tables on `<schema>`.* to <dms_user>;
```

## Uso de una base de datos autogestionada compatible con MySQL como fuente para AWS DMS
<a name="CHAP_Source.MySQL.CustomerManaged"></a>

Puede utilizar las siguientes bases de datos compatibles con MySQL autoadministradas como orígenes para AWS DMS:
+ MySQL Community Edition
+ MySQL Standard Edition
+ MySQL Enterprise Edition
+ MySQL Cluster Carrier Grade Edition
+ MariaDB Community Edition
+ MariaDB Enterprise Edition
+ Column Store de MariaDB

Para usar CDC, asegúrese de habilitar el registro binario. Para habilitar el registro binario, se deben configurar los siguientes parámetros en el archivo de MySQL `my.ini` (Windows) o `my.cnf` (UNIX).


| Parámetro | Valor | 
| --- | --- | 
| `server_id` | Establezca este parámetro con un valor de 1 o superior. | 
| `log-bin` | Establezca la ruta del archivo de registro binario, como por ejemplo `log-bin=E:\MySql_Logs\BinLog`. No incluya la extensión del archivo. | 
| `binlog_format` | Establezca este parámetro en `ROW`. Recomendamos esta configuración durante la replicación porque, en determinados casos, cuando `binlog_format` se establece en `STATEMENT`, puede provocar incoherencias al replicar los datos en el destino. El motor de base de datos también escribe datos similares e incoherentes en el destino cuando `binlog_format` está establecido en `MIXED`, ya que el motor de base de datos cambia automáticamente al registro basado en `STATEMENT` que puede resultar en datos incoherentes de escritura en la base de datos de destino. | 
| `expire_logs_days` | Establezca este parámetro con un valor de 1 o superior. Para evitar la sobrecarga de espacio en disco, se recomienda que no utilice el valor 0, que es el predeterminado. | 
| `binlog_checksum` | Establezca este parámetro en `NONE` para la versión 3.4.7 o anteriores de DMS. | 
| `binlog_row_image` | Establezca este parámetro en `FULL`. | 
| `log_slave_updates` | Establezca este parámetro en `TRUE` si está utilizando una réplica de lectura de MySQL o MariaDB como origen. | 

Si utiliza una réplica de lectura de MySQL o MariaDB como origen de una tarea de migración de DMS con el modo **Migrar los datos existentes y replicar los cambios continuos**, existe la posibilidad de pérdida de datos. DMS no escribirá una transacción durante la carga completa o la captura de datos de cambio en las siguientes condiciones:
+ La transacción se había confirmado en la instancia principal antes de que se iniciara la tarea de DMS.
+ La transacción no se había confirmado en la réplica hasta que se inició la tarea de DMS, debido al desfase entre la instancia principal y la réplica.

Cuanto mayor sea el intervalo entre la instancia principal y la réplica, mayor será la posibilidad de pérdida de datos.

Si su origen utiliza el motor de base de datos NDB (agrupado), deben configurarse los siguientes parámetros para habilitar la CDC en tablas que utilicen ese motor de almacenamiento. Agregue estos cambios al archivo de MySQL `my.ini` (Windows) o `my.cnf` (UNIX).


| Parámetro | Valor | 
| --- | --- | 
| `ndb_log_bin` | Establezca este parámetro en `ON`. Este valor garantiza que los cambios en las tablas en clúster se anotan en los registros binarios. | 
| `ndb_log_update_as_write` | Establezca este parámetro en `OFF`. Este valor impide escribir instrucciones UPDATE como instrucciones INSERT en el registro binario. | 
| `ndb_log_updated_only` | Establezca este parámetro en `OFF`. Este valor garantiza que el registro binario contiene la totalidad de la fila y no solo las columnas que se han modificado. | 

## Uso de una base AWS de datos compatible con MySQL administrada como fuente para AWS DMS
<a name="CHAP_Source.MySQL.AmazonManaged"></a>

Puede utilizar las siguientes bases de datos AWS gestionadas compatibles con MySQL como fuentes para: AWS DMS
+ MySQL Community Edition
+ MariaDB Community Edition
+ Amazon Aurora MySQL-Compatible Edition

Cuando utilice como fuente una base AWS de datos gestionada compatible con MySQL AWS DMS, asegúrese de cumplir los siguientes requisitos previos para los CDC:
+ Para habilitar los registros binarios de RDS para MySQL y para RDS para MariaDB, habilite las copias de seguridad automáticas en el nivel de instancia. Para habilitar los registros binarios para un clúster de Aurora MySQL, cambie la variable `binlog_format` en el grupo de parámetros.

  Para obtener más información sobre la configuración de copias de seguridad automáticas, consulte [Trabajo con copias de seguridad automáticas](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithAutomatedBackups.html) en la *Guía del usuario de Amazon RDS*.

  Para obtener más información sobre la configuración del registro binario para una base de datos de Amazon RDS para MySQL, consulte [Configuración del formato de registro binario](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_LogAccess.MySQL.BinaryFormat.html) en la *Guía del usuario de Amazon RDS*. 

  Para obtener más información sobre la configuración del registro binario para un clúster de Aurora MySQL, consulte [¿Cómo activo el registro binario para mi clúster de Amazon Aurora MySQL?](https://aws.amazon.com/premiumsupport/knowledge-center/enable-binary-logging-aurora/). 
+ Si piensa usar CDC, active el registro binario. Para obtener más información sobre la configuración del registro binario para una base de datos de Amazon RDS para MySQL, consulte [Configuración del formato de registro binario](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_LogAccess.MySQL.BinaryFormat.html) en la *Guía del usuario de Amazon RDS*.
+ Asegúrese de que los registros binarios estén disponibles para. AWS DMS Dado que las bases de datos AWS administradas compatibles con MySQL purgan los registros binarios lo antes posible, debe aumentar el tiempo que los registros permanecen disponibles. Por ejemplo, para incrementar la retención de logs a 24 horas, ejecute el siguiente comando. 

  ```
   call mysql.rds_set_configuration('binlog retention hours', 24);
  ```
+ Establezca el parámetro `binlog_format` como `"ROW"`.
**nota**  
En MySQL o MariaDB, `binlog_format` es un parámetro dinámico, por lo que no es necesario reiniciar el sistema para que el nuevo valor surta efecto. Sin embargo, el nuevo valor solo se aplicará a las sesiones nuevas. Si cambia `binlog_format` a `ROW` con fines de replicación, la base de datos puede seguir creando registros binarios posteriores con el mismo formato `MIXED`, si esas sesiones se iniciaron antes de que cambiara el valor. Esto puede impedir que se capturen correctamente todos AWS DMS los cambios en la base de datos de origen. Al cambiar la configuración de `binlog_format` en una base de datos de MariaDB o MySQL, asegúrese de reiniciar la base de datos para cerrar todas las sesiones existentes o de reiniciar cualquier aplicación que realice operaciones de DML (lenguaje de manipulación de datos). Obligar a la base de datos a reiniciar todas las sesiones después de cambiar el `binlog_format` parámetro `ROW` garantizará que la base de datos escriba todos los cambios posteriores en la base de datos de origen con el formato correcto, de forma que AWS DMS pueda capturar esos cambios correctamente.
+ Establezca el parámetro `binlog_row_image` como `"Full"`. 
+ Establezca el parámetro `binlog_checksum` en `"NONE"` para la versión 3.4.7 o anteriores de DMS. Para obtener más información acerca de la configuración de parámetros en Amazon RDS MySQL, consulte [Trabajo con copias de seguridad automatizadas](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithAutomatedBackups.html) en la *Guía del usuario de Amazon RDS*.
+ Si utiliza una réplica de lectura de Amazon RDS MySQL o Amazon RDS MariaDB como origen, habilite las copias de seguridad en la réplica de lectura y asegúrese de que el parámetro `log_slave_updates` esté establecido en `TRUE`.

## Limitaciones del uso de una base de datos MySQL como fuente para AWS DMS
<a name="CHAP_Source.MySQL.Limitations"></a>

Cuando utilice una base de datos MySQL como origen, tenga en cuenta lo siguiente:
+  No se admite la captura de datos de cambios (CDC) para Amazon RDS MySQL 5.5 o inferior. Para MySQL de Amazon RDS, debe usar la versión 5.6, 5.7 u 8.0 para habilitar CDC. CDC es compatible con orígenes MySQL 5.5 autoadministrados. 
+ Para CDC, se admiten `CREATE TABLE`, `ADD COLUMN` y `DROP COLUMN` que cambian el tipo de datos de columna y `renaming a column`. Sin embargo, no se admiten `DROP TABLE`, `RENAME TABLE` y las actualizaciones realizadas en otros atributos, como el valor predeterminado de la columna, la nulabilidad de la columna, el conjunto de caracteres, etc.
+  En el caso de las tablas particionadas en el origen, al configurar el **modo de preparación** de **tablas de destino en Drop tables on target**, AWS DMS crea una tabla sencilla sin particiones en el destino de MySQL. Para migrar tablas con particiones a una tabla particionada en el destino, cree previamente las tablas con particiones en la base de datos de MySQL de destino.
+  Los objetivos relacionales no admiten el uso de una `ALTER TABLE table_name ADD COLUMN column_name` sentencia para añadir columnas al principio (FIRST) o al centro de una tabla (AFTER). Las columnas siempre se añaden al final de la tabla. Cuando el destino es Amazon S3 o Amazon Kinesis Data Streams, se admite la adición de columnas mediante FIRST o AFTER.
+ No se admite la CDC cuando un nombre de tabla contiene mayúsculas y minúsculas y el motor de origen está alojado en un sistema operativo con nombres de archivo que no distinguen entre mayúsculas y minúsculas. Un ejemplo es Microsoft Windows u OS X con HFS\$1.
+ Puede usar la edición compatible con MySQL de Aurora sin servidor versión 1 para la carga completa, pero no puede usarla para CDC. Esto se debe a que no se pueden habilitar los requisitos previos de MySQL. Para obtener más información, consulte [Grupos de parámetros y Aurora sin servidor v1](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-serverless.how-it-works.html#aurora-serverless.parameter-groups). 

  La versión 2 de la edición compatible con MySQL de Aurora sin servidor admite CDC.
+  El atributo AUTO\$1INCREMENT en una columna no se migra a una columna de la base de datos de destino.
+  No se admite la captura de los cambios cuando los registros binarios no se almacenan en almacenamiento de bloques estándar. Por ejemplo, CDC no funciona cuando los registros binarios se almacenan en Amazon S3.
+  AWS DMS crea tablas de destino con el motor de almacenamiento InnoDB de forma predeterminada. Si necesita utilizar un motor de almacenamiento distinto de InnoDB, debe crear manualmente la tabla y migrar a ella mediante el modo [no hacer nada](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_GettingStarted.html).
+ No puede utilizar réplicas de Aurora MySQL como fuente a AWS DMS menos que su modo de tarea de migración de DMS sea **Migrar datos existentes**, solo a carga completa.
+  Si el origen compatible con MySQL se detiene durante la carga completa, la tarea de AWS DMS no se detiene con un error. La tarea finaliza correctamente, pero es posible que el destino no esté sincronizado con el origen. Si esto ocurre, reinicie la tarea o vuelva a cargar las tablas afectadas.
+  Los índices creados en una parte del valor de una columna no se migran. Por ejemplo, el índice CREATE INDEX first\$1ten\$1chars ON customer (name(10)) no se crea en el destino.
+ En algunos casos, la tarea está configurada para no replicarse LOBs (SupportLobs«» es falsa en la configuración de la tarea o se selecciona **No incluir columnas LOB** en la consola de tareas). En estos casos, AWS DMS no migra ninguna columna MEDIUMBLOB, LONGBLOB, MEDIUMTEXT ni LONGTEXT al destino.

  Las columnas BLOB, TINYBLOB, TEXT y TINYTEXT no se ven afectadas y se migran al destino.
+ Tablas o sistemas de datos temporales: las tablas de versión no son compatibles con las bases de datos de origen y destino de MariaDB.
+ Si migra entre dos clústeres Aurora MySQL de Amazon RDS, el punto de enlace de origen de Aurora MySQL de RDS debe ser read/write una instancia, no una instancia de réplica. 
+ AWS DMS actualmente no admite la migración de vistas para MariaDB.
+ AWS DMS no admite cambios de DDL para tablas particionadas para MySQL. Para omitir la suspensión de tablas por cambios de DDL de particiones durante la CDC, establezca `skipTableSuspensionForPartitionDdl` en `true`.
+ AWS DMS solo admite transacciones XA en la versión 3.5.0 y versiones posteriores. Las versiones anteriores no admiten transacciones XA. AWS DMS no admite transacciones XA en la versión 10.6 o superior de MariaDB. Para obtener más información, consulte lo siguiente. [Compatibilidad con transacciones XA](#CHAP_Source.MySQL.XA)
+ AWS DMS no se utiliza GTIDs para la replicación, incluso si los datos de origen los contienen. 
+ AWS DMS no es compatible con el registro binario mejorado de Aurora MySQL.
+ AWS DMS no admite la compresión de transacciones de registros binarios.
+ AWS DMS no propaga los eventos ON DELETE CASCADE y ON UPDATE CASCADE para bases de datos MySQL mediante el motor de almacenamiento InnoDB. Para estos eventos, MySQL no genera eventos binlog que reflejen las operaciones en cascada en las tablas secundarias. Por lo tanto, no AWS DMS puede replicar los cambios correspondientes en las tablas secundarias. Para obtener más información, consulte [Los índices, las claves externas o las actualizaciones o eliminaciones en cascada no se migran](CHAP_Troubleshooting.md#CHAP_Troubleshooting.MySQL.FKsAndIndexes).
+ AWS DMS no captura los cambios en las columnas calculadas (`VIRTUAL`y`GENERATED ALWAYS`). Para evitar esta limitación, haga lo siguiente:
  + Cree previamente la tabla de destino en la base de datos de destino y cree la tarea de AWS DMS con la configuración de tareas de carga completa `DO_NOTHING` o `TRUNCATE_BEFORE_LOAD`.
  + Agregue una regla de transformación para eliminar la columna calculada del ámbito de la tarea. Para obtener información sobre las reglas de transformación, consulte [Reglas y acciones de transformación](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.md).
+ Debido a la limitación interna de MySQL, BINLOGs no AWS DMS puede procesar un tamaño superior a 4 GB. BINLOGs Un tamaño superior a 4 GB puede provocar fallos en las tareas del DMS u otros comportamientos impredecibles. Debe reducir el tamaño de las transacciones para evitar que superen los BINLOGs 4 GB.
+ AWS DMS no admite comillas invertidas (```) ni comillas simples (`'`) en los nombres de esquemas, tablas y columnas.
+ AWS DMS no migra los datos de las columnas invisibles de la base de datos de origen. Para incluir estas columnas en el ámbito de la migración, use la instrucción ALTER TABLE para hacer visibles estas columnas.

## Compatibilidad con transacciones XA
<a name="CHAP_Source.MySQL.XA"></a>

Una transacción de arquitectura ampliada (XA) es una transacción que se puede usar para agrupar una serie de operaciones de varios recursos transaccionales en una sola transacción global fiable. Una transacción XA utiliza un protocolo de confirmación en dos fases. En general, la captura de cambios mientras hay transacciones XA abiertas puede provocar la pérdida de datos. Si la base de datos no utiliza transacciones XA, puede ignorar este permiso y la configuración `IgnoreOpenXaTransactionsCheck` mediante el uso del valor predeterminado `TRUE`. Para empezar a replicar desde un origen que tiene transacciones XA, haga lo siguiente:
+ Asegúrese de que el usuario del AWS DMS punto final tenga el siguiente permiso:

  ```
  grant XA_RECOVER_ADMIN on *.* to 'userName'@'%';
  ```
+ Establezca la configuración del punto de conexión `IgnoreOpenXaTransactionsCheck` en `false`.

**nota**  
AWS DMS no admite transacciones XA en MariaDB Source DB versión 10.6 o superior.

## Configuración de punto final cuando se utiliza MySQL como fuente para AWS DMS
<a name="CHAP_Source.MySQL.ConnectionAttrib"></a>

Puede utilizar la configuración de punto de conexión para configurar la base de datos de origen de MySQL de forma similar al uso de atributos de conexión adicionales. Los ajustes se especifican al crear el punto final de origen mediante la AWS DMS consola o mediante el `create-endpoint` comando de [AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/dms/index.html), con la sintaxis `--my-sql-settings '{"EndpointSetting": "value", ...}'` JSON.

La siguiente tabla muestra la configuración de punto de conexión que puede utilizar con MySQL como origen.

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/dms/latest/userguide/CHAP_Source.MySQL.html)

## Tipos de datos de origen para MySQL
<a name="CHAP_Source.MySQL.DataTypes"></a>

La siguiente tabla muestra los tipos de datos de origen de la base de datos MySQL que se admiten cuando se utilizan AWS DMS y la asignación predeterminada de AWS DMS los tipos de datos.

Para obtener más información sobre cómo ver el tipo de datos que se asigna en el destino, consulte la sección del punto de enlace de destino que esté utilizando.

Para obtener información adicional sobre AWS DMS los tipos de datos, consulte[Tipos de datos de AWS Database Migration Service](CHAP_Reference.DataTypes.md).


|  Tipos de datos de MySQL  |  AWS DMS tipos de datos  | 
| --- | --- | 
|  INT  |  INT4  | 
|  BIGINT  |  INT8  | 
|  MEDIUMINT  |  INT4  | 
|  TINYINT  |  INT1  | 
|  SMALLINT  |  INT2  | 
|  UNSIGNED TINYINT  |  UINT1  | 
|  UNSIGNED SMALLINT  |  UINT2  | 
|  UNSIGNED MEDIUMINT  |  UINT4  | 
|  UNSIGNED INT  |  UINT4  | 
|  UNSIGNED BIGINT  |  UINT8  | 
|  DECIMAL (10)  |  NUMERIC (10,0)  | 
|  BINARIO  |  BYTES(1)  | 
|  BIT  |  BOOLEANO  | 
|  BIT(64)  |  BYTES(8)  | 
|  BLOB  |  BYTES(65535)  | 
|  LONGBLOB  |  BLOB  | 
|  MEDIUMBLOB  |  BLOB  | 
|  TINYBLOB  |  BYTES(255)  | 
|  DATE  |  DATE  | 
|  DATETIME  |  DATETIME DATETIME sin un valor entre paréntesis se replica sin milisegundos. DATETIME con un valor entre paréntesis de 1 a 5 (como `DATETIME(5)`) se replica con milisegundos. Al replicar una columna DATETIME, la hora sigue siendo la misma en el destino. No se convierte a UTC.  | 
|  TIME  |  STRING  | 
|  TIMESTAMP  |  DATETIME Al replicar una columna TIMESTAMP, la hora se convierte a UTC en el destino.  | 
|  YEAR  |  INT2  | 
|  DOUBLE  |  REAL8  | 
|  FLOAT  |  REAL(DOUBLE) Si los valores FLOAT no están en el rango siguiente, use una transformación para asignar FLOAT a STRING. Para obtener más información sobre transformaciones, consulte [Reglas y acciones de transformación](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.md). El rango FLOAT admitido es de -1.79E\$1308 a -2.23E-308, 0 y de 2.23E-308 a 1.79E\$1308  | 
|  VARCHAR (45)  |  WSTRING (45)  | 
|  VARCHAR (2000)  |  WSTRING (2000)  | 
|  VARCHAR (4000)  |  WSTRING (4000)  | 
|  VARBINARY (4000)  |  BYTES (4000)  | 
|  VARBINARY (2000)  |  BYTES (2000)  | 
|  CHAR  |  WSTRING  | 
|  TEXT  |  WSTRING  | 
|  LONGTEXT  |  NCLOB  | 
|  MEDIUMTEXT  |  NCLOB  | 
|  TINYTEXT  |  WSTRING(255)  | 
|  GEOMETRY  |  BLOB  | 
|  POINT  |  BLOB  | 
|  LINESTRING  |  BLOB  | 
|  POLYGON  |  BLOB  | 
|  MULTIPOINT  |  BLOB  | 
|  MULTILINESTRING  |  BLOB  | 
|  MULTIPOLYGON  |  BLOB  | 
|  GEOMETRYCOLLECTION  |  BLOB  | 
|  ENUM  |  CADENA () *length* Aquí, *length* es la longitud del valor más largo de la ENUM.  | 
|  SET  |  CADENA () *length* Aquí, *length* es la longitud total de todos los valores del SET, incluidas las comas.  | 
|  JSON  |  CLOB  | 

**nota**  
En algunos casos, puede especificar los tipos de datos DATETIME y TIMESTAMP con un valor “cero” (es decir, 00-00-0000). Si es así, asegúrese de que la base de datos de destino de la tarea de replicación admita valores “cero” para los tipos de datos DATETIME y TIMESTAMP. De lo contrario, estos valores se registran con un valor NULL en el destino.

# Uso de una base de datos SAP ASE como fuente para AWS DMS
<a name="CHAP_Source.SAP"></a>

Puede migrar los datos de una base de datos de SAP Adaptive Server Enterprise (ASE), anteriormente conocida como Sybase, mediante. AWS DMS Con una base de datos SAP ASE como fuente, puede migrar los datos a cualquiera de las demás bases de datos de destino compatibles. AWS DMS 

Para obtener información sobre las versiones de SAP ASE que son AWS DMS compatibles como fuente, consulte[Fuentes de AWS DMS](CHAP_Introduction.Sources.md).

Para obtener más información sobre cómo trabajar con bases de datos de SAP ASE AWS DMS, consulte las siguientes secciones.

**Topics**
+ [Requisitos previos para utilizar una base de datos SAP ASE como fuente de AWS DMS](#CHAP_Source.SAP.Prerequisites)
+ [Limitaciones del uso de SAP ASE como fuente de AWS DMS](#CHAP_Source.SAP.Limitations)
+ [Se requieren permisos para utilizar SAP ASE como fuente de AWS DMS](#CHAP_Source.SAP.Security)
+ [Quitar el punto de truncado](#CHAP_Source.SAP.Truncation)
+ [Configuración del punto final cuando se utiliza SAP ASE como fuente de AWS DMS](#CHAP_Source.SAP.ConnectionAttrib)
+ [Tipos de datos de origen para SAP ASE](#CHAP_Source.SAP.DataTypes)

## Requisitos previos para utilizar una base de datos SAP ASE como fuente de AWS DMS
<a name="CHAP_Source.SAP.Prerequisites"></a>

Para que una base de datos SAP ASE sea una fuente de datos AWS DMS, haga lo siguiente:
+ Habilite la replicación de SAP ASE para las tablas mediante el comando `sp_setreptable`. Para obtener más información, consulte [Sybase Infocenter Archive]( http://infocenter.sybase.com/help/index.jsp?topic=/com.sybase.dc32410_1501/html/refman/X37830.htm). 
+ Inhabilite `RepAgent` en la base de datos de SAP ASE. Para obtener más información, consulte [Detener y deshabilitar el RepAgent subproceso en la base de datos principal](http://infocenter-archive.sybase.com/help/index.jsp?topic=/com.sybase.dc20096_1260/html/mra126ag/mra126ag65.htm). 
+ Para replicar a la versión 15.7 de SAP ASE en una instancia EC2 de Windows configurada para caracteres no latinos (por ejemplo, chino), instale SAP ASE 15.7 SP121 en el equipo de destino.

**nota**  
Para la replicación continua de la captura de datos de cambios (CDC), DMS ejecuta `dbcc logtransfer` y `dbcc log` para leer los datos del registro de transacciones.

## Limitaciones del uso de SAP ASE como fuente de AWS DMS
<a name="CHAP_Source.SAP.Limitations"></a>

Al utilizar una base de datos SAP ASE como origen para AWS DMS se aplican las siguientes restricciones:
+ Solo puede ejecutar una AWS DMS tarea con replicación continua o CDC para cada base de datos de SAP ASE. Puede ejecutar varias full-load-only tareas en paralelo.
+ No se puede cambiar el nombre de una tabla. Por ejemplo, el siguiente comando produce un error.

  ```
  sp_rename 'Sales.SalesRegion', 'SalesReg;
  ```
+ No se puede cambiar el nombre de una columna. Por ejemplo, el siguiente comando produce un error.

  ```
  sp_rename 'Sales.Sales.Region', 'RegID', 'COLUMN';
  ```
+ Los valores situados al final de las cadenas de tipo de datos binarios se truncan cuando se replican para la base de datos de destino. Por ejemplo, `0x0000000000000000000000000100000100000000` en la tabla de origen se convierte en `0x00000000000000000000000001000001`, en la tabla de destino.
+ Si el valor predeterminado de la base de datos no permite valores NULL, AWS DMS crea la tabla de destino con columnas que no permiten valores NULL. En consecuencia, si una tarea de replicación de CDC o de carga completa contiene valores vacíos, AWS DMS se produce un error. Puede evitar que se produzcan estos errores permitiendo valores NULL en la base de datos de origen ejecutando los siguientes comandos.

  ```
  sp_dboption database_name, 'allow nulls by default', 'true'
  go
  use database_name
  CHECKPOINT
  go
  ```
+ No se admite el comando de índice `reorg rebuild`.
+ AWS DMS no admite clústeres ni utiliza MSA (disponibilidad multisitio) o Warm Standby como fuente.
+ Cuando se utiliza la expresión del encabezado de transformación `AR_H_TIMESTAMP` en las reglas de asignación, no se capturarán los milisegundos de una columna agregada.
+ Si se ejecutan operaciones de fusión durante CDC, se producirá un error irrecuperable. Para volver a sincronizar el objetivo, ejecute una carga completa.
+ Los eventos desencadenantes de la reversión no se admiten en las tablas que utilizan un esquema de bloqueo de filas de datos.
+ AWS DMS no puede reanudar una tarea de replicación después de eliminar una tabla del ámbito de la tarea desde una base de datos SAP de origen. Si la tarea de replicación de DMS se detuvo y se realizó alguna operación de DML (INSERTAR, ACTUALIZAR, ELIMINAR) y, a continuación, eliminar la tabla, debe reiniciar la tarea de replicación.

## Se requieren permisos para utilizar SAP ASE como fuente de AWS DMS
<a name="CHAP_Source.SAP.Security"></a>

Para utilizar una base de datos SAP ASE como fuente en una AWS DMS tarea, debe conceder los permisos. Otorgue a la cuenta de usuario especificada en las definiciones AWS DMS de la base de datos los siguientes permisos en la base de datos SAP ASE: 
+ sa\$1role
+ replication\$1role
+ sybase\$1ts\$1role
+ De forma predeterminada, cuando necesita tener permiso para ejecutar el procedimiento `sp_setreptable` almacenado, AWS DMS habilita la opción de replicación de SAP ASE. Si desea ejecutar una tabla directamente desde `sp_setreptable` el punto final de la base de datos y no a través de AWS DMS ella misma, puede utilizar el atributo de conexión `enableReplication` adicional. Para obtener más información, consulte [Configuración del punto final cuando se utiliza SAP ASE como fuente de AWS DMS](#CHAP_Source.SAP.ConnectionAttrib).

## Quitar el punto de truncado
<a name="CHAP_Source.SAP.Truncation"></a>

Cuando se inicia una tarea, AWS DMS establece una `$replication_truncation_point` entrada en la vista `syslogshold` del sistema que indica que hay un proceso de replicación en curso. Mientras AWS DMS está funcionando, avanza el punto de truncamiento de la replicación a intervalos regulares, en función de la cantidad de datos que ya se hayan copiado en el destino.

Una vez establecida la `$replication_truncation_point` entrada, mantenga la AWS DMS tarea en ejecución para evitar que el registro de la base de datos se vuelva excesivamente grande. Si desea detener la AWS DMS tarea de forma permanente, elimine el punto de truncamiento de la replicación ejecutando el siguiente comando:

```
dbcc settrunc('ltm','ignore')
```

Una vez eliminado el punto de truncamiento, no podrá reanudar la tarea. AWS DMS La sesión se seguirá truncando de forma automática en los puntos de control (si se ha establecido el truncado automático).

## Configuración del punto final cuando se utiliza SAP ASE como fuente de AWS DMS
<a name="CHAP_Source.SAP.ConnectionAttrib"></a>

Puede utilizar la configuración de punto de conexión para configurar la base de datos de origen de SAP ASE de forma similar al uso de atributos de conexión adicionales. Los ajustes se especifican al crear el punto final de origen mediante la AWS DMS consola o mediante el `create-endpoint` comando del [AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/dms/index.html), con la sintaxis `--sybase-settings '{"EndpointSetting": "value", ...}'` JSON.

La siguiente tabla muestra la configuración de punto de conexión que puede utilizar con SAP ASE como origen.

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/dms/latest/userguide/CHAP_Source.SAP.html)

## Tipos de datos de origen para SAP ASE
<a name="CHAP_Source.SAP.DataTypes"></a>

Para obtener una lista de los tipos de datos de origen de SAP ASE que se admiten cuando se utiliza AWS DMS y el mapeo predeterminado a partir de AWS DMS los tipos de datos, consulte la siguiente tabla. AWS DMS no admite tablas de origen de SAP ASE con columnas del tipo de datos definido por el usuario (UDT). Las columnas que se replican con este tipo de datos se crean como NULL. 

Para obtener más información sobre cómo ver el tipo de datos que se asigna en el destino, consulte la sección [Destinos para la migración de datos](CHAP_Target.md) de su punto de enlace de destino.

Para obtener información adicional sobre AWS DMS los tipos de datos, consulte. [Tipos de datos de AWS Database Migration Service](CHAP_Reference.DataTypes.md)


|  Tipos de datos de SAP ASE  |  AWS DMS tipos de datos  | 
| --- | --- | 
| BIGINT | INT8 | 
| UNSIGNED BIGINT | UINT8 | 
| INT | INT4 | 
| UNSIGNED INT | UINT4 | 
| SMALLINT | INT2 | 
| UNSIGNED SMALLINT | UINT2 | 
| TINYINT | UINT1 | 
| DECIMAL | NUMERIC | 
| NUMERIC | NUMERIC | 
| FLOAT | REAL8 | 
| DOUBLE | REAL8 | 
| REAL | REAL4 | 
| MONEY | NUMERIC | 
| SMALLMONEY | NUMERIC | 
| DATETIME | DATETIME | 
| BIGDATETIME | DATETIME(6) | 
| SMALLDATETIME | DATETIME | 
| DATE | DATE | 
| TIME | TIME | 
| BIGTIME | TIME | 
| CHAR | STRING | 
| UNICHAR | WSTRING | 
| NCHAR | WSTRING | 
| VARCHAR | STRING | 
| UNIVARCHAR | WSTRING | 
| NVARCHAR | WSTRING | 
| BINARIO | BYTES | 
| VARBINARY | BYTES | 
| BIT | BOOLEANO | 
| TEXT | CLOB | 
| UNITEXT | NCLOB | 
| IMAGE | BLOB | 

# Uso de MongoDB como fuente para AWS DMS
<a name="CHAP_Source.MongoDB"></a>

 Para obtener información sobre las versiones de MongoDB AWS DMS compatibles como fuente, consulte. [Fuentes de AWS DMS](CHAP_Introduction.Sources.md) 

Tenga en cuenta lo siguiente sobre la compatibilidad de versiones de MongoDB:
+ Las versiones AWS DMS 3.4.5 y posteriores admiten las versiones 4.2 y 4.4 de MongoDB. 
+ Las versiones AWS DMS 3.4.5 y posteriores y las versiones de MongoDB 4.2 y posteriores admiten transacciones distribuidas. Para obtener más información sobre las transacciones distribuidas de MongoDB, consulte [Transacciones](https://docs.mongodb.com/manual/core/transactions/) en la [documentación de MongoDB](https://www.mongodb.com/docs/).
+ Las versiones AWS DMS 3.5.0 y posteriores no admiten versiones de MongoDB anteriores a la 3.6.
+ Las versiones AWS DMS 3.5.1 y posteriores son compatibles con MongoDB versión 5.0.
+ Las versiones AWS DMS 3.5.2 y posteriores admiten la versión 6.0 de MongoDB.
+ Las versiones AWS DMS 3.5.4 y posteriores admiten las versiones 7.0 y 8.0 de MongoDB.



Si no está familiarizado con MongoDB, tenga en cuenta los siguientes conceptos importantes sobre las bases de datos MongoDB: 
+ Un registro en MongoDB es un *documento* formado por una estructura de datos compuesta de pares de campo y valor. El valor de un campo puede incluir otros documentos, matrices y matrices de documentos. Un documento es más o menos equivalente a una fila en una tabla de base de datos relacional.
+ Una *colección* en MongoDB es un grupo de documentos y es aproximadamente equivalente a una tabla de base de datos relacional.
+ Una *base de datos* de MongoDB es un conjunto de recopilaciones y equivale aproximadamente a un esquema de una base de datos relacional.
+ Internamente, un documento de MongoDB se almacena como archivo JSON binario (BSON) en formato comprimido, que incluye un tipo para cada campo del documento. Cada documento tiene un identificador único.

AWS DMS *admite dos modos de migración cuando se usa MongoDB como fuente*, modo documento o modo tabla*.* Se especifica qué modo de migración usar al crear el punto de conexión de MongoDB o al configurar el parámetro del **Modo metadatos** desde la consola de AWS DMS . Otra opción, puede crear una segunda columna con un nombre `_id` que actúe como clave principal. Para ello, seleccione el botón de verificación de **\$1id como columna independiente** en el panel de configuración del punto de conexión. 

La selección del modo de migración afecta al formato resultante de los datos de destino, como se indica a continuación. 

**Modo documento**  
En el modo documento, el documento de MongoDB se migra tal cual, es decir, sus datos se consolidan en una única columna de una tabla de destino denominada `_doc`. El modo documento es la configuración predeterminada al usar MongoDB como punto de enlace de origen.  
Por ejemplo, tenga en cuenta los siguientes documentos en una colección de MongoDB llamada myCollection.  

```
 db.myCollection.find()
{ "_id" : ObjectId("5a94815f40bd44d1b02bdfe0"), "a" : 1, "b" : 2, "c" : 3 }
{ "_id" : ObjectId("5a94815f40bd44d1b02bdfe1"), "a" : 4, "b" : 5, "c" : 6 }
```
Después de migrar los datos a una tabla de base de datos relacional utilizando el modo documento, los datos se estructuran de la siguiente forma. Los campos de datos del documento de MongoDB se consolidan en la columna` _doc`.      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/dms/latest/userguide/CHAP_Source.MongoDB.html)
Si lo desea, puede establecer el `extractDocID` del atributo de conexión adicional en *true* para crear otra columna denominada `"_id"` que actúe como clave principal. Si va a utilizar CDC, establezca este parámetro en *verdadero*.  
*Cuando se utiliza CDC con fuentes que generan [transacciones con varios documentos](https://www.mongodb.com/docs/manual/reference/method/Session.startTransaction/#mongodb-method-Session.startTransaction), el `ExtractDocId` parámetro **debe estar** establecido en true.* Si este parámetro no está activado, la AWS DMS tarea fallará cuando detecte una transacción con varios documentos.  
En el modo documento, AWS DMS gestiona la creación y el cambio de nombre de las colecciones de la siguiente manera:  
+ Si agrega una nueva colección a la base de datos de origen, AWS DMS crea una nueva tabla de destino para la colección y replica cualquier documento. 
+ Si se cambia el nombre de una recopilación existente en la base de datos de origen, AWS DMS no cambia el nombre de la tabla de destino. 
Si el punto de conexión de destino es MongoDB o Amazon DocumentDB, ejecute la migración en **Modo documento**.

**Modo de tabla**  
En modo tabla, AWS DMS transforma cada campo de nivel superior de un documento de MongoDB en una columna de la tabla de destino. Si un campo está anidado, AWS DMS aplana los valores anidados en una sola columna. AWS DMS a continuación, agrega un campo clave y tipos de datos al conjunto de columnas de la tabla de destino.   
Para cada documento de MongoDB AWS DMS , agrega cada clave y tipo al conjunto de columnas de la tabla de destino. Por ejemplo, si utiliza el modo de tabla, AWS DMS migra el ejemplo anterior a la tabla siguiente.      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/dms/latest/userguide/CHAP_Source.MongoDB.html)
Los valores anidados se aplanan en una columna que contiene nombres de clave separados por puntos. El nombre de la columna será la concatenación de los nombres de los campos reunidos, separados por puntos. Por ejemplo, AWS DMS migra un documento JSON con un campo de valores anidados, por ejemplo, `{"a" : {"b" : {"c": 1}}}` a una columna llamada `a.b.c.`  
Para crear las columnas de destino, AWS DMS escanea un número específico de documentos de MongoDB y crea un conjunto de todos los campos y sus tipos. AWS DMS luego usa este conjunto para crear las columnas de la tabla de destino. Si crea o modifica el punto de enlace de origen de MongoDB mediante la consola de , puede especificar el número de documentos que se van a analizar. El valor predeterminado es de 1000 documentos. Si usa el AWS CLI, puede usar el atributo de conexión adicional`docsToInvestigate`.  
En el modo tabla, AWS DMS gestiona los documentos y las colecciones de la siguiente manera:  
+ Cuando añada un documento a una colección existente, el documento se replica. Si hay campos que no existen en el destino, estos campos no se replican.
+ Al actualizar un documento, el documento actualizado se replican. Si hay campos que no existen en el destino, estos campos no se replican.
+ Se admite en toda su extensión la eliminación de documentos.
+ Cuando se añade una colección nueva, no se crea una tabla nueva en el destino si se efectúa mientras se desarrolla una tarea de CDC.
+ En la fase de captura de datos de cambio (CDC), AWS DMS no permite cambiar el nombre de una colección.

**Topics**
+ [Permisos necesarios cuando se utiliza MongoDB como fuente para AWS DMS](#CHAP_Source.MongoDB.PrerequisitesCDC)
+ [Configuración de un conjunto de réplicas de MongoDB para CDC](#CHAP_Source.MongoDB.PrerequisitesCDC.ReplicaSet)
+ [Requisitos de seguridad al utilizar MongoDB como fuente de AWS DMS](#CHAP_Source.MongoDB.Security)
+ [Segmentación de recopilaciones y migración en paralelo de MongoDB](#CHAP_Source.MongoDB.ParallelLoad)
+ [Migración de varias bases de datos cuando se usa MongoDB como fuente de AWS DMS](#CHAP_Source.MongoDB.Multidatabase)
+ [Limitaciones al usar MongoDB como fuente de AWS DMS](#CHAP_Source.MongoDB.Limitations)
+ [Ajustes de configuración del punto final cuando se utiliza MongoDB como fuente para AWS DMS](#CHAP_Source.MongoDB.Configuration)
+ [Tipos de datos de origen para MongoDB](#CHAP_Source.MongoDB.DataTypes)

## Permisos necesarios cuando se utiliza MongoDB como fuente para AWS DMS
<a name="CHAP_Source.MongoDB.PrerequisitesCDC"></a>

Para una AWS DMS migración con una fuente de MongoDB, puede crear una cuenta de usuario con privilegios de root o un usuario con permisos únicamente en la base de datos para migrar. 

El código siguiente crear un usuario para que sea la cuenta raíz.

```
use admin
db.createUser(
  {
    user: "root",
    pwd: "password",
    roles: [ { role: "root", db: "admin" } ]
  }
)
```

Para un origen de MongoDB 3.x, el código siguiente crea un usuario con privilegios mínimos en la base de datos que se va a migrar.

```
use database_to_migrate
db.createUser( 
{ 
    user: "dms-user",
    pwd: "password",
    roles: [ { role: "read", db: "local" }, "read"] 
})
```

Para un origen de MongoDB 4.x, el siguiente código crea un usuario con privilegios mínimos.

```
{ resource: { db: "", collection: "" }, actions: [ "find", "changeStream" ] }
```

Por ejemplo, cree el siguiente rol en la base de datos “admin”.

```
use admin
db.createRole(
{
role: "changestreamrole",
privileges: [
{ resource: { db: "", collection: "" }, actions: [ "find","changeStream" ] }
],
roles: []
}
)
```

Y una vez creado el rol, cree un usuario en la base de datos que se va a migrar.

```
 use test
> db.createUser( 
{ 
user: "dms-user12345",
pwd: "password",
roles: [ { role: "changestreamrole", db: "admin" }, "read"] 
})
```

## Configuración de un conjunto de réplicas de MongoDB para CDC
<a name="CHAP_Source.MongoDB.PrerequisitesCDC.ReplicaSet"></a>

Para utilizar la replicación continua o la CDC con MongoDB AWS DMS , se requiere acceso al registro de operaciones de MongoDB (oplog). Para crear dicho log, debe implementar un conjunto de réplicas si no existe ninguno. Para obtener más información, consulte la [ documentación de MongoDB](https://docs.mongodb.com/manual/tutorial/deploy-replica-set/).

Puede utilizar CDC con el nodo principal o secundario de un conjunto de réplicas de MongoDB como punto de enlace de origen.

**Para convertir una instancia independiente a un conjunto de réplicas**

1. Usar la línea de comandos, conectarse a `mongo`.

   ```
   mongo localhost
   ```

1. Detenga el servicio `mongod`.

   ```
   service mongod stop
   ```

1. Reinicie `mongod` utilizando el siguiente comando:

   ```
   mongod --replSet "rs0" --auth -port port_number
   ```

1. Pruebe la conexión con el conjunto de réplicas con los siguientes comandos:

   ```
   mongo -u root -p password --host rs0/localhost:port_number 
     --authenticationDatabase "admin"
   ```

Si tiene previsto realizar una migración con el modo documento, seleccione la opción `_id as a separate column` al crear el punto de enlace de MongoDB. Si se selecciona esta opción, se crea otra columna denominada `_id`, que actúa como clave principal. Esta segunda columna es necesaria AWS DMS para admitir las operaciones con el lenguaje de manipulación de datos (DML).

**nota**  
AWS DMS utiliza el registro de operaciones (oplog) para capturar los cambios durante la replicación en curso. Si MongoDB vacía los registros del oplog antes de leerlos, las tareas fallarán. AWS DMS Recomendamos ajustar el tamaño de oplog para retener los cambios durante al menos 24 horas. 

## Requisitos de seguridad al utilizar MongoDB como fuente de AWS DMS
<a name="CHAP_Source.MongoDB.Security"></a>

AWS El DMS admite dos métodos de autenticación para MongoDB. Los dos métodos de autenticación se utilizan para cifrar la contraseña, de forma que solo se pueda utilizar cuando el parámetro `authType` se haya establecido en *PASSWORD (CONTRASEÑA)*.

Los métodos de autenticación de MongoDB son los siguientes:
+ **MONGODB-CR**: para compatibilidad con versiones anteriores
+ **SCRAM-SHA-1**: el valor predeterminado cuando se usa MongoDB versión 3.x y 4.0

Si no se especifica un método de autenticación, AWS DMS utiliza el método predeterminado para la versión de la fuente de MongoDB.

## Segmentación de recopilaciones y migración en paralelo de MongoDB
<a name="CHAP_Source.MongoDB.ParallelLoad"></a>

Para mejorar el rendimiento de una tarea de migración, los puntos de conexión de origen de MongoDB admiten dos opciones de carga completa paralela en la asignación de tablas. 

En otras palabras, puede migrar una recopilación en paralelo mediante la segmentación automática o de segmentación por rango de la asignación de tablas para una carga completa paralela en la configuración de JSON. Con la segmentación automática, puede especificar los criterios para segmentar automáticamente la fuente AWS DMS para la migración en cada subproceso. Con la segmentación por rangos, puede determinar AWS DMS el rango específico de cada segmento para que DMS migre en cada subproceso. Para obtener más información sobre estas configuraciones, consulte [Reglas y operaciones de configuración de tablas y recopilaciones](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.md).

### Migración de una base de datos de MongoDB en paralelo mediante rangos de segmentación automática
<a name="CHAP_Source.MongoDB.ParallelLoad.AutoPartitioned"></a>

Puede migrar los documentos en paralelo especificando los criterios para que AWS DMS particione (segmentar) automáticamente los datos de cada subproceso. En concreto, se especifica el número de documentos que se van a migrar por subproceso. Con este enfoque, AWS DMS intenta optimizar los límites de los segmentos para obtener el máximo rendimiento por hilo.

Puede especificar los criterios de segmentación mediante las siguientes opciones de configuración de tabla en la asignación de tablas.


|  Opción de configuración de tabla  |  Description (Descripción)  | 
| --- | --- | 
|  `"type"`  |  (Obligatorio) Establezca `"partitions-auto"` para MongoDB como origen.  | 
|  `"number-of-partitions"`  |  (Opcional) Número total de particiones (segmentos) utilizadas para la migración. El valor predeterminado es 16.  | 
|  `"collection-count-from-metadata"`  |  (Opcional) Si esta opción se establece en `true`, AWS DMS utiliza un recuento de recopilaciones estimado para determinar el número de particiones. Si esta opción está establecida en`false`, AWS DMS utiliza el recuento de colecciones real. El valor predeterminado es `true`.  | 
|  `"max-records-skip-per-page"`  |  (Opcional) El número de registros que se van a omitir a la vez al determinar los límites de cada partición. AWS DMS utiliza un método de omisión paginada para determinar el límite mínimo de una partición. El valor predeterminado es 10 000.  El establecimiento de un valor relativamente alto puede provocar tiempos de espera del cursor y errores en las tareas. Si se establece un valor relativamente bajo, se realizan más operaciones por página y se ralentiza la carga completa.   | 
|  `"batch-size"`  |  (Opcional) Limita el número de documentos que se devuelven en un lote. Cada lote requiere un viaje de ida y vuelta al servidor. Si el tamaño del lote es cero (0), el cursor utiliza el tamaño máximo de lote definido por el servidor. El valor predeterminado es 0.  | 

En el siguiente ejemplo, se muestra una tabla de asignación para la segmentación automática.

```
{
    "rules": [
        {
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "object-locator": {
                "schema-name": "admin",
                "table-name": "departments"
            },
            "rule-action": "include",
            "filters": []
        },
        {
            "rule-type": "table-settings",
            "rule-id": "2",
            "rule-name": "2",
            "object-locator": {
                "schema-name": "admin",
                "table-name": "departments"
            },
            "parallel-load": {
                "type": "partitions-auto",
                "number-of-partitions": 5,
                "collection-count-from-metadata": "true",
                "max-records-skip-per-page": 1000000,
                "batch-size": 50000
            }
        }
    ]
}
```

La segmentación automática tiene la siguiente limitación. La migración de cada segmento obtiene el recuento de la recopilación y el `_id` mínimo para la recopilación de forma individual. A continuación, utiliza un salto paginado para calcular el límite mínimo de ese segmento. 

Por lo tanto, asegúrese de que el valor de `_id` mínimo de cada recopilación permanezca constante hasta que se calculen todos los límites de los segmentos de la recopilación. Si cambia el valor de `_id` mínimo de una recopilación durante el cálculo del límite del segmento, puede provocar la pérdida de datos o errores en las filas duplicadas.

### Migración de una base de datos de MongoDB en paralelo mediante la segmentación por rango
<a name="CHAP_Source.MongoDB.ParallelLoad.Ranges"></a>

Puede migrar los documentos en paralelo especificando los rangos de cada segmento de un subproceso. Con este enfoque, usted indica AWS DMS los documentos específicos que se deben migrar en cada hilo de acuerdo con los rangos de documentos que haya elegido por hilo.

La siguiente imagen muestra una recopilación de MongoDB que tiene siete elementos y `_id` como la clave principal.

![\[Recopilación de MongoDB con siete artículos.\]](http://docs.aws.amazon.com/es_es/dms/latest/userguide/images/datarep-docdb-collection.png)


Para dividir la colección en tres segmentos específicos para AWS DMS migrar en paralelo, puede añadir reglas de mapeo de tablas a su tarea de migración. Este enfoque se muestra en el siguiente ejemplo de JSON.

```
{ // Task table mappings:
  "rules": [
    {
      "rule-type": "selection",
      "rule-id": "1",
      "rule-name": "1",
      "object-locator": {
        "schema-name": "testdatabase",
        "table-name": "testtable"
      },
      "rule-action": "include"
    }, // "selection" :"rule-type"
    {
      "rule-type": "table-settings",
      "rule-id": "2",
      "rule-name": "2",
      "object-locator": {
        "schema-name": "testdatabase",
        "table-name": "testtable"
      },
      "parallel-load": {
        "type": "ranges",
        "columns": [
           "_id",
           "num"
        ],
        "boundaries": [
          // First segment selects documents with _id less-than-or-equal-to 5f805c97873173399a278d79
          // and num less-than-or-equal-to 2.
          [
             "5f805c97873173399a278d79",
             "2"
          ],
          // Second segment selects documents with _id > 5f805c97873173399a278d79 and
          // _id less-than-or-equal-to 5f805cc5873173399a278d7c and
          // num > 2 and num less-than-or-equal-to 5.
          [
             "5f805cc5873173399a278d7c",
             "5"
          ]                                   
          // Third segment is implied and selects documents with _id > 5f805cc5873173399a278d7c.
        ] // :"boundaries"
      } // :"parallel-load"
    } // "table-settings" :"rule-type"
  ] // :"rules"
} // :Task table mappings
```

Esa definición de asignación de tablas divide la recopilación de orígenes en tres segmentos y migra en paralelo. A continuación, se muestran límites de segmentación.

```
Data with _id less-than-or-equal-to "5f805c97873173399a278d79" and num less-than-or-equal-to 2 (2 records)
Data with _id > "5f805c97873173399a278d79" and num > 2 and _id  less-than-or-equal-to "5f805cc5873173399a278d7c" and num less-than-or-equal-to 5 (3 records)
Data with _id > "5f805cc5873173399a278d7c" and num > 5 (2 records)
```

Una vez finalizada la tarea de migración, puede comprobar en los registros de tareas que las tablas se han cargado en paralelo, como se muestra en el siguiente ejemplo. También puede comprobar la cláusula `find` de MongoDB utilizada para descargar cada segmento de la tabla de origen.

```
[TASK_MANAGER    ] I:  Start loading segment #1 of 3 of table 'testdatabase'.'testtable' (Id = 1) by subtask 1. Start load timestamp 0005B191D638FE86  (replicationtask_util.c:752)

[SOURCE_UNLOAD   ] I:  Range Segmentation filter for Segment #0 is initialized.   (mongodb_unload.c:157)

[SOURCE_UNLOAD   ] I:  Range Segmentation filter for Segment #0 is: { "_id" : { "$lte" : { "$oid" : "5f805c97873173399a278d79" } }, "num" : { "$lte" : { "$numberInt" : "2" } } }  (mongodb_unload.c:328)

[SOURCE_UNLOAD   ] I: Unload finished for segment #1 of segmented table 'testdatabase'.'testtable' (Id = 1). 2 rows sent.

[TASK_MANAGER    ] I: Start loading segment #1 of 3 of table 'testdatabase'.'testtable' (Id = 1) by subtask 1. Start load timestamp 0005B191D638FE86 (replicationtask_util.c:752)
 
[SOURCE_UNLOAD   ] I: Range Segmentation filter for Segment #0 is initialized. (mongodb_unload.c:157) 

[SOURCE_UNLOAD   ] I: Range Segmentation filter for Segment #0 is: { "_id" : { "$lte" : { "$oid" : "5f805c97873173399a278d79" } }, "num" : { "$lte" : { "$numberInt" : "2" } } } (mongodb_unload.c:328)
 
[SOURCE_UNLOAD   ] I: Unload finished for segment #1 of segmented table 'testdatabase'.'testtable' (Id = 1). 2 rows sent.

[TARGET_LOAD     ] I: Load finished for segment #1 of segmented table 'testdatabase'.'testtable' (Id = 1). 1 rows received. 0 rows skipped. Volume transfered 480.

[TASK_MANAGER    ] I: Load finished for segment #1 of table 'testdatabase'.'testtable' (Id = 1) by subtask 1. 2 records transferred.
```

Actualmente, AWS DMS admite los siguientes tipos de datos de MongoDB como columna de clave de segmento:
+ Double
+ Cadena
+ ObjectId
+ Entero de 32 bits
+ Entero de 64 bits

## Migración de varias bases de datos cuando se usa MongoDB como fuente de AWS DMS
<a name="CHAP_Source.MongoDB.Multidatabase"></a>

AWS DMS las versiones 3.4.5 y superiores admiten la migración de varias bases de datos en una sola tarea para todas las versiones de MongoDB compatibles. Si desea migrar varias bases de datos, realice estos pasos:

1. Al crear el punto de conexión de origen de MongoDB, realice alguna de las siguientes operaciones:
   + En la página **Crear punto de conexión** de la consola de DMS, asegúrese de que el **nombre de la base de datos** esté vacío en la **configuración del punto de conexión**.
   + Con el AWS CLI `CreateEndpoint` comando, asigne un valor de cadena vacío al parámetro in. `DatabaseName` `MongoDBSettings`

1. Para cada base de datos que desee migrar desde un origen de MongoDB, especifique el nombre de la base de datos como nombre de esquema en la tabla de asignación de la tarea. Puede hacerlo mediante la entrada guiada de la consola o directamente en JSON. Para obtener más información sobre la entrada guiada, consulte [Especificación de selección de tablas y reglas de transformaciones desde la consola](CHAP_Tasks.CustomizingTasks.TableMapping.Console.md). Para obtener más información sobre el archivo JSON, consulte [Reglas y acciones de selección](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Selections.md).

Por ejemplo, es posible que especifique el siguiente JSON para migrar tres bases de datos de MongoDB.

**Example Migrar todas las tablas de un esquema**  
El siguiente JSON migra todas las tablas de base de datos de `Customers`, `Orders` y `Suppliers` del punto de conexión de origen al punto de conexión de destino.  

```
{
    "rules": [
        {
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "object-locator": {
                "schema-name": "Customers",
                "table-name": "%"
            },
            "rule-action": "include",
            "filters": []
        },
        {
            "rule-type": "selection",
            "rule-id": "2",
            "rule-name": "2",
            "object-locator": {
                "schema-name": "Orders",
                "table-name": "%"
            },
            "rule-action": "include",
            "filters": []
        },
        {
            "rule-type": "selection",
            "rule-id": "3",
            "rule-name": "3",
            "object-locator": {
                "schema-name": "Inventory",
                "table-name": "%"
            },
            "rule-action": "include",
            "filters": []
        }
    ]
}
```

## Limitaciones al usar MongoDB como fuente de AWS DMS
<a name="CHAP_Source.MongoDB.Limitations"></a>

Las siguientes son limitaciones al usar MongoDB como fuente para: AWS DMS
+ En el modo tabla, los documentos de una recopilación deben ser coherentes en cuanto al tipo de datos que utilizan para el valor del mismo campo. Por ejemplo, si un documento de una recopilación incluye `'{ a:{ b:value ... }'`, todos los documentos de la recopilación que hacen referencia al `value` del campo `a.b` deben usar el mismo tipo de datos para `value`, independientemente del lugar donde aparezcan en la recopilación.
+ Cuando la `_id` opción se establece como una columna independiente, la cadena del identificador no puede superar los 200 caracteres.
+ Las claves de ID de objeto y de tipo de matriz se convierten en columnas que tienen los prefijos `oid` y `array` en el modo de tabla.

  Internamente, se hace referencia a estas columnas con los nombres con prefijos. Si utiliza reglas de transformación AWS DMS que hacen referencia a estas columnas, asegúrese de especificar la columna con prefijo. Por ejemplo, especifique `${oid__id}` y no `${_id}` o `${array__addresses}` y no `${_addresses}`. 
+  Los nombres de recopilaciones y claves no pueden incluir el símbolo del dólar (\$1). 
+ AWS DMS no admite colecciones que contengan el mismo campo con mayúsculas y minúsculas diferentes (mayúsculas o inferiores) en el modo tabla con un objetivo de RDBMS. Por ejemplo, no AWS DMS admite tener dos colecciones `Field1` denominadas y. `field1` 
+ El modo de tabla y el modo de documento tienen las limitaciones descritas con anterioridad.
+ La migración en paralelo mediante la segmentación automática tiene las limitaciones descritas anteriormente.
+ Los filtros de origen no son compatibles con MongoDB.
+ AWS DMS no admite documentos en los que el nivel de anidación sea superior a 97.
+ AWS DMS requiere datos de origen codificados en UTF-8 al migrar a destinos que no son de DocumentDB. Para las fuentes con caracteres distintos de UTF-8, conviértalas a UTF-8 antes de la migración o, en su lugar, migre a Amazon DocumentDB.
+ AWS DMS no es compatible con las siguientes funciones de MongoDB versión 5.0:
  + Cambios de los fragmentos en directo
  + Cifrado en el nivel de campo del lado del cliente (CSFLE)
  + Migración de recopilación de series temporales
**nota**  
Una recopilación de series temporales migrada en la fase de carga completa se convertirá en una recopilación normal en Amazon DocumentDB, ya que DocumentDB no admite recopilaciones de series temporales.

## Ajustes de configuración del punto final cuando se utiliza MongoDB como fuente para AWS DMS
<a name="CHAP_Source.MongoDB.Configuration"></a>

Al configurar el punto final de origen de MongoDB, puede especificar varios ajustes de configuración del punto final mediante la consola. AWS DMS 

La siguiente tabla describe los ajustes de configuración disponibles cuando se utilizan bases de datos MongoDB como fuente. AWS DMS 


| Configuración (atributo) | Valores válidos | Valor predeterminado y descripción | 
| --- | --- | --- | 
|  **Modo de autenticación**  |  `"none"` `"password"`  |  El valor `"password"` solicita un nombre de usuario y una contraseña. Cuando se especifica `"none"`, no se utilizan los parámetros de nombre de usuario y contraseña.  | 
|  **Origen de autenticación**  |  Un nombre de la base de datos MongoDB válido.  |  Es el nombre de la base de datos de MongoDB que desea utilizar para validar las credenciales de autenticación. El valor predeterminado es `"admin"`.   | 
|  **Mecanismo de autenticación**  |  `"default"` `"mongodb_cr"` `"scram_sha_1"`  |  El mecanismo de autenticación. El valor de ` "default"` es `"scram_sha_1"`. Esta configuración no se utiliza cuando `authType` se establece en `"no"`.  | 
|  **Modo de metadatos**  |  Documento y tabla  |  Elige el modo de documento o de tabla.   | 
|  **Número de documentos que se van a escanear** (`docsToInvestigate`)  |  Un número entero positivo mayor que `0`.  |  Utilice esta opción solo en modo tabla para definir la tabla de destino.  | 
|  **\$1id como columna independiente**  |  Marca de comprobación en la casilla  |  Casilla de verificación de comprobación opcional que crea una segunda columna denominada `_id` que actúa como clave principal.  | 
|   `ExtractDocID`   |  `true` `false`  |  `false`: utilice este atributo cuando `NestingLevel` se establezca en `"none"`.  Cuando se utiliza CDC con fuentes que generan [transacciones con varios documentos](https://www.mongodb.com/docs/manual/reference/method/Session.startTransaction/#mongodb-method-Session.startTransaction), el `ExtractDocId` parámetro **debe estar** establecido en. `true` Si este parámetro no está activado, la AWS DMS tarea fallará cuando detecte una transacción con varios documentos.  | 
|  `socketTimeoutMS`  |  Un entero mayor o igual a 0. Solo el atributo de conexión adicional (ECA).  |  Esta configuración está en unidades de milisegundos y configura el tiempo de espera de la conexión para los clientes de MongoDB. Si el valor es menor o igual a cero, se utiliza el valor predeterminado del cliente de MongoDB.  | 
|   `UseUpdateLookUp`   |  `true` `false`  |  Si es verdadero, durante los eventos de actualización de los CDC, AWS DMS copia todo el documento actualizado al objetivo. Cuando se establece en false, AWS DMS utiliza el comando de actualización de MongoDB para actualizar solo los campos modificados del documento en el destino.  | 
|   `ReplicateShardCollections`   |  `true` `false`  |  Si es verdadero, AWS DMS replica los datos en colecciones de fragmentos. AWS DMS solo usa esta configuración si el punto final de destino es un clúster elástico de DocumentDB. Cuando esta configuración es verdadera, tenga en cuenta lo siguiente: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/dms/latest/userguide/CHAP_Source.MongoDB.html)  | 
|  `useTransactionVerification`  |  `true` `false`  |  Si es `false`, desactiva la verificación entre el flujo de cambios y los oplog.   Puede omitir operaciones si se producen discrepancias entre los flujos de cambios y las entradas de oplog, ya que el comportamiento predeterminado de DMS es que la tarea falle en estos casos. Predeterminado: `true`.   | 
|  `useOplog`  |  `true` `false`  |  Si es `true`, permite que la tarea de DMS lea directamente del oplog en lugar de utilizar el flujo de cambios. Predeterminado: `false`.  | 

Si elige **Documento** como **modo de metadatos**, hay diferentes opciones disponibles. 

Si el punto de conexión de destino es DocumentDB, asegúrese de ejecutar la migración en **modo mocumento**. Además, modifique el punto de conexión de origen y seleccione la opción **\$1id como columna independiente**. Este es un requisito previo obligatorio si la carga de trabajo de MongoDB de origen incluye transacciones.

## Tipos de datos de origen para MongoDB
<a name="CHAP_Source.MongoDB.DataTypes"></a>

La migración de datos que utiliza MongoDB como fuente es AWS DMS compatible con la mayoría de los tipos de datos de MongoDB. En la siguiente tabla, puede encontrar los tipos de datos de origen de MongoDB que se admiten cuando se AWS DMS utiliza y el mapeo AWS DMS predeterminado a partir de los tipos de datos. Para obtener más información sobre los tipos de datos de MongoDB, consulte [BSON types](https://docs.mongodb.com/manual/reference/bson-types) en la documentación de MongoDB.

Para obtener más información sobre cómo ver el tipo de datos que se asigna en el destino, consulte la sección del punto de enlace de destino que esté utilizando.

Para obtener información adicional sobre AWS DMS los tipos de datos, consulte. [Tipos de datos de AWS Database Migration Service](CHAP_Reference.DataTypes.md)


|  Tipos de datos de MongoDB  |  AWS DMS tipos de datos  | 
| --- | --- | 
| Booleano | Bool | 
| Binario | BLOB | 
| Date | Date | 
| Marca temporal | Date | 
| Int | INT4 | 
| Largo | INT8 | 
| Doble | REAL8 | 
| Cadena (UTF-8) | CLOB | 
| Matriz | CLOB | 
| OID | Cadena | 
| REGEX | CLOB | 
| CODE | CLOB | 

# Uso de Amazon DocumentDB (compatible con MongoDB) como fuente para AWS DMS
<a name="CHAP_Source.DocumentDB"></a>

Para obtener información acerca de las versiones de Amazon DocumentDB (con compatibilidad con MongoDB) que AWS DMS admite como origen, consulte [Fuentes de AWS DMS](CHAP_Introduction.Sources.md).

 Con Amazon DocumentDB como origen, puede migrar datos de un clúster de Amazon DocumentDB a otro clúster de Amazon DocumentDB. También puede migrar datos de un clúster de Amazon DocumentDB a uno de los otros puntos de enlace de destino compatibles con. AWS DMS

Si es la primera vez que utiliza Amazon DocumentDB, tenga en cuenta los siguientes conceptos importantes para las bases de datos de Amazon DocumentDB:
+ Un registro en Amazon DocumentDB es un *documento*, una estructura de datos compuesta de pares de campo y valor. El valor de un campo puede incluir otros documentos, matrices y matrices de documentos. Un documento es más o menos equivalente a una fila en una tabla de base de datos relacional.
+ Una *recopilación* en Amazon DocumentDB es un grupo de documentos y es aproximadamente equivalente a una tabla de base de datos relacional.
+ Una *base de datos* de Amazon DocumentDB es un conjunto de recopilaciones y equivale aproximadamente a un esquema de una base de datos relacional.

AWS DMS admite dos modos de migración cuando se utiliza Amazon DocumentDB como fuente, modo documento y modo tabla. El modo de migración se especifica al crear el punto final de origen de Amazon DocumentDB en la AWS DMS consola, mediante la opción de **modo Metadata** o el atributo de conexión adicional. `nestingLevel` Después, puede encontrar una explicación sobre cómo la elección del modo de migración afecta al formato resultante de los datos de destino.

**Modo documento**  
En el *modo documento, *el documento JSON se migra tal cual. Eso significa que los datos del documento se consolidan en uno de dos elementos. Cuando se utiliza una base de datos relacional como destino, los datos son una sola columna denominada `_doc` en una tabla de destino. Cuando se utiliza una base de datos no relacional como destino, los datos son un único documento JSON. El modo documento es el modo predeterminado, que recomendamos al migrar a un destino de Amazon DocumentDB.  
Por ejemplo, tenga en cuenta los siguientes documentos en una recopilación de Amazon DocumentDB llamada `myCollection`.  

```
 db.myCollection.find()
{ "_id" : ObjectId("5a94815f40bd44d1b02bdfe0"), "a" : 1, "b" : 2, "c" : 3 }
{ "_id" : ObjectId("5a94815f40bd44d1b02bdfe1"), "a" : 4, "b" : 5, "c" : 6 }
```
Después de migrar los datos a una tabla de base de datos relacional utilizando el modo documento, los datos se estructuran de la siguiente forma. Los campos de datos del documento se consolidan en la columna` _doc`.      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/dms/latest/userguide/CHAP_Source.DocumentDB.html)
Si lo desea, puede establecer el atributo de conexión adicional `extractDocID` en `true` para crear otra columna denominada `"_id"` que actúe como clave principal. Si va a utilizar la captura de datos de cambios (CDC), establezca este parámetro en `true` excepto cuando utilice Amazon DocumentDB como destino.  
Cuando se utiliza CDC con fuentes que generan [transacciones con varios documentos](https://www.mongodb.com/docs/manual/reference/method/Session.startTransaction/#mongodb-method-Session.startTransaction), el `ExtractDocId` parámetro **debe estar establecido en**. `true` Si este parámetro no está activado, la AWS DMS tarea fallará cuando detecte una transacción con varios documentos.  
Si agrega una nueva colección a la base de datos de origen, AWS DMS crea una nueva tabla de destino para la colección y replica todos los documentos. 

**Modo de tabla**  
En el *modo tabla, *AWS DMS transforma cada uno de los campos de nivel superior en un documento de Amazon DocumentDB en una columna en la tabla de destino. Si un campo está anidado, AWS DMS aplana los valores anidados en una sola columna. AWS DMS a continuación, agrega un campo clave y tipos de datos al conjunto de columnas de la tabla de destino.   
Para cada documento de Amazon DocumentDB, AWS DMS añada cada clave y tipo al conjunto de columnas de la tabla de destino. Por ejemplo, si utiliza el modo de tabla, AWS DMS migra el ejemplo anterior a la tabla siguiente.      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/dms/latest/userguide/CHAP_Source.DocumentDB.html)
Los valores anidados se aplanan en una columna que contiene nombres de clave separados por puntos. La columna se nombra con la concatenación de los nombres de los campos reunidos, separados por puntos. Por ejemplo, AWS DMS migra un documento JSON con un campo de valores anidados, por ejemplo, `{"a" : {"b" : {"c": 1}}}` a una columna llamada `a.b.c.`  
Para crear las columnas de destino, AWS DMS escanea un número específico de documentos de Amazon DocumentDB y crea un conjunto de todos los campos y sus tipos. AWS DMS a continuación, utiliza este conjunto para crear las columnas de la tabla de destino. Si crea o modifica el punto de conexión de origen de Amazon DocumentDB mediante la consola, puede especificar el número de documentos que se van a analizar. El valor predeterminado es de 1000 documentos. Si usa el AWS CLI, puede usar el atributo de conexión adicional`docsToInvestigate`.  
En el modo tabla, AWS DMS gestiona los documentos y las colecciones de la siguiente manera:  
+ Cuando añada un documento a una colección existente, el documento se replica. Si hay campos que no existen en el destino, estos campos no se replican.
+ Al actualizar un documento, el documento actualizado se replican. Si hay campos que no existen en el destino, estos campos no se replican.
+ Se admite en toda su extensión la eliminación de documentos.
+ Cuando se añade una colección nueva, no se crea una tabla nueva en el destino si se efectúa mientras se desarrolla una tarea de CDC.
+ En la fase de captura de datos de cambio (CDC), AWS DMS no permite cambiar el nombre de una colección.

**Topics**
+ [Configuración de permisos para usar Amazon DocumentDB como origen](#CHAP_Source.DocumentDB.Permissions)
+ [Configuración de CDC para un clúster de Amazon DocumentDB](#CHAP_Source.DocumentDB.ConfigureCDC)
+ [Conexión a Amazon DocumentDB mediante TLS](#CHAP_Source.DocumentDB.TLS)
+ [Creación de un punto de conexión de origen de Amazon DocumentDB](#CHAP_Source.DocumentDB.ConfigureEndpoint)
+ [Segmentación de recopilaciones de Amazon DocumentDB y migración en paralelo](#CHAP_Source.DocumentDB.ParallelLoad)
+ [Migración de varias bases de datos cuando se utiliza Amazon DocumentDB como fuente de AWS DMS](#CHAP_Source.DocumentDB.Multidatabase)
+ [Limitaciones del uso de Amazon DocumentDB como fuente para AWS DMS](#CHAP_Source.DocumentDB.Limitations)
+ [Uso de la configuración de puntos de conexión con Amazon DocumentDB como origen](#CHAP_Source.DocumentDB.ECAs)
+ [Tipos de datos de origen de Amazon DocumentDB](#CHAP_Source.DocumentDB.DataTypes)

## Configuración de permisos para usar Amazon DocumentDB como origen
<a name="CHAP_Source.DocumentDB.Permissions"></a>

Al utilizar el código fuente de Amazon DocumentDB para una AWS DMS migración, puede crear una cuenta de usuario con privilegios de root. O bien, puede crear un usuario con permisos solo para la base de datos que se va a migrar. 

El código siguiente crea un usuario como la cuenta raíz.

```
use admin
db.createUser(
  {
    user: "root",
    pwd: "password",
    roles: [ { role: "root", db: "admin" } ]
  })
```

Para Amazon DocumentDB 3.6, el código siguiente crea un usuario con privilegios mínimos en la base de datos que se va a migrar.

```
use db_name
db.createUser( 
    {
        user: "dms-user",
        pwd: "password",
        roles: [{ role: "read", db: "db_name" }]
    }
)
```

Para Amazon DocumentDB 4.0 y versiones posteriores, AWS DMS utiliza un flujo de cambios para toda la implementación. A continuación, el código siguiente crea un usuario con privilegios mínimos.

```
db.createUser( 
{ 
    user: "dms-user",
    pwd: "password",
    roles: [ { role: "readAnyDatabase", db: "admin" }] 
})
```

## Configuración de CDC para un clúster de Amazon DocumentDB
<a name="CHAP_Source.DocumentDB.ConfigureCDC"></a>

Para utilizar la replicación continua o la CDC con Amazon DocumentDB, AWS DMS necesita acceso a las secuencias de cambios del clúster de Amazon DocumentDB. Para obtener una descripción de la secuencia ordenada por tiempo de los eventos de actualización en las recopilaciones y bases de datos del clúster, consulte [Uso de flujos de cambios](https://docs.aws.amazon.com/documentdb/latest/developerguide/change_streams.html) en la *Guía para desarrolladores de Amazon DocumentDB*. 

Autentíquese en el clúster de Amazon DocumentDB mediante el shell de MongoDB. A continuación, ejecute el siguiente comando para habilitar los flujos de cambios.

```
db.adminCommand({modifyChangeStreams: 1,
    database: "DB_NAME",
    collection: "", 
    enable: true});
```

Este enfoque habilita el flujo de cambios para todas las recopilaciones de la base de datos. Una vez habilitados los flujos de cambios, puede crear una tarea de migración que migre los datos existentes y, al mismo tiempo, replique los cambios en curso. AWS DMS sigue capturando y aplicando los cambios incluso después de cargar los datos masivos. Con el tiempo, las bases de datos de origen y de destino se sincronizarán, por lo que el tiempo de inactividad de la migración será mínimo.

**nota**  
AWS DMS utiliza el registro de operaciones (oplog) para capturar los cambios durante la replicación en curso. Si Amazon DocumentDB vacía los registros del oplog antes de leerlos, las tareas AWS DMS fallarán. Recomendamos ajustar el tamaño de oplog para retener los cambios durante al menos 24 horas.

## Conexión a Amazon DocumentDB mediante TLS
<a name="CHAP_Source.DocumentDB.TLS"></a>

De forma predeterminada, un clúster de Amazon DocumentDB recién creado solo acepta conexiones seguras mediante la seguridad de la capa de transporte (TLS). Cuando TLS está habilitado, cada conexión a Amazon DocumentDB requiere una clave pública.

Puede recuperar la clave pública de Amazon DocumentDB descargando el archivo `rds-combined-ca-bundle.pem` desde un bucket AWS de Amazon S3 alojado. Para obtener más información acerca de la descarga de este archivo, consulte [Cifrado de conexiones mediante TLS](https://docs.aws.amazon.com/documentdb/latest/developerguide/security.encryption.ssl.html) en la *Guía para desarrolladores de Amazon DocumentDB.* 

Tras descargar el `rds-combined-ca-bundle.pem` archivo, puede importar la clave pública que contiene. AWS DMS En los pasos siguientes, se describe cómo hacerlo así.

**Para importar la clave pública mediante la AWS DMS consola**

1. Inicie sesión en Consola de administración de AWS y elija AWS DMS.

1. En el panel de navegación, elija **Certificates**.

1. Seleccione **Importar certificado**. Aparece la página **Importar nuevo certificado de entidad de certificación**.

1. En la sección **Configuración de certificado**, realice una de las siguientes acciones:
   + Para **Identificador del certificado**, escriba un nombre único para el certificado, como `docdb-cert`.
   + Elija **Elegir archivo**, vaya a la ubicación en la que guardó el archivo `rds-combined-ca-bundle.pem` y selecciónelo.

1. Elija **Add new CA certificate (Agregar un nuevo certificado de entidad de certificación)**.

 AWS CLI En el siguiente ejemplo, se utiliza el AWS DMS `import-certificate` comando para importar el `rds-combined-ca-bundle.pem` archivo de clave pública.

```
aws dms import-certificate \
    --certificate-identifier docdb-cert \
    --certificate-pem file://./rds-combined-ca-bundle.pem
```

## Creación de un punto de conexión de origen de Amazon DocumentDB
<a name="CHAP_Source.DocumentDB.ConfigureEndpoint"></a>

Puede crear un punto de conexión de origen de Amazon DocumentDB mediante la consola o la AWS CLI. Utilice el siguiente procedimiento con la consola.

**Para configurar un punto final de origen de Amazon DocumentDB mediante la consola AWS DMS**

1. Inicie sesión en Consola de administración de AWS y elija AWS DMS.

1. Elija **Puntos de conexión** en el panel de navegación y, a continuación, elija **Crear punto de conexión**.

1. Para **identificador de punto de conexión**, proporcione un nombre que le ayude a identificarlo fácilmente, por ejemplo `docdb-source`.

1. Para **Motor de origen**, elija **Amazon DocumentDB (con compatibilidad con MongoDB)**.

1. Para **Nombre del servidor**, ingrese el nombre del servidor en el que reside el punto de conexión de la base de datos de Amazon DocumentDB. Por ejemplo, puede ingresar el nombre de DNS público de la instancia de Amazon EC2, como `democluster.cluster-cjf6q8nxfefi.us-east-2.docdb.amazonaws.com`.

1. Para **Puerto**, escriba 27 017.

1. En **SSL mode (Modo de SSL)**, elija **verify-full**. Si ha desactivado SSL en el clúster de Amazon DocumentDB, puede omitir este paso.

1. Para el **certificado de entidad de certificación**, elija el certificado de Amazon DocumentDB, `rds-combined-ca-bundle.pem`. Para obtener instrucciones sobre cómo agregar este certificado, consulte [Conexión a Amazon DocumentDB mediante TLS](#CHAP_Source.DocumentDB.TLS).

1. Para **Nombre de base de datos**, escriba el nombre de la base de datos que se va a migrar.

Utilice el procedimiento siguiente con la CLI.

**Para configurar un punto final de origen de Amazon DocumentDB mediante el AWS CLI**
+ Ejecute el siguiente AWS DMS `create-endpoint` comando para configurar un punto final de origen de Amazon DocumentDB y sustituir los marcadores de posición por sus propios valores.

  ```
  aws dms create-endpoint \
             --endpoint-identifier a_memorable_name \
             --endpoint-type source \
             --engine-name docdb \
             --username value \
             --password value \
             --server-name servername_where_database_endpoint_resides \
             --port 27017 \
             --database-name name_of_endpoint_database
  ```

## Segmentación de recopilaciones de Amazon DocumentDB y migración en paralelo
<a name="CHAP_Source.DocumentDB.ParallelLoad"></a>

Para mejorar el rendimiento de una tarea de migración, los puntos de conexión de origen de Amazon DocumentDB admiten dos opciones de la característica de carga completa paralela en la asignación de tablas. En otras palabras, puede migrar una recopilación en paralelo mediante las opciones de segmentación automática o de segmentación por rango de la asignación de tablas para una carga completa paralela en la configuración de JSON. Las opciones de segmentación automática le permiten especificar los criterios para segmentar automáticamente la fuente AWS DMS para la migración en cada subproceso. Las opciones de segmentación por rango permiten indicar AWS DMS el rango específico de cada segmento para que el DMS migre en cada subproceso. Para obtener más información sobre estas configuraciones, consulte [Reglas y operaciones de configuración de tablas y recopilaciones](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.md).

### Migración de una base de datos de Amazon DocumentDB en paralelo mediante rangos de segmentación automática
<a name="CHAP_Source.DocumentDB.ParallelLoad.AutoPartitioned"></a>

Puede migrar los documentos en paralelo si especifica los criterios para que AWS DMS particione (segmente) de forma automática los datos de cada subproceso, especialmente el número de documentos que se van a migrar por subproceso. Con este enfoque, AWS DMS intenta optimizar los límites de los segmentos para obtener el máximo rendimiento por subproceso.

Puede especificar los criterios de segmentación mediante las siguientes opciones de configuración de tablas en la asignación de tablas:


|  Opción de configuración de tabla  |  Description (Descripción)  | 
| --- | --- | 
|  `"type"`  |  (Obligatorio) Establezca `"partitions-auto"` para Amazon DocumentDB como origen.  | 
|  `"number-of-partitions"`  |  (Opcional) Número total de particiones (segmentos) utilizadas para la migración. El valor predeterminado es 16.  | 
|  `"collection-count-from-metadata"`  |  (Opcional) Si se establece en`true`, AWS DMS utiliza un recuento de recopilaciones estimado para determinar el número de particiones. Si se establece en`false`, AWS DMS utiliza el recuento de colecciones real. El valor predeterminado es `true`.  | 
|  `"max-records-skip-per-page"`  |  (Opcional) El número de registros que se van a omitir a la vez al determinar los límites de cada partición. AWS DMS utiliza un método de omisión paginada para determinar el límite mínimo de una partición. El valor predeterminado es 10 000. Si se establece un valor relativamente alto es posible que se produzcan tiempos de espera del cursor y errores en las tareas. Si se establece un valor relativamente bajo, se realizan más operaciones por página y se ralentiza la carga completa.   | 
|  `"batch-size"`  |  (Opcional) Limita el número de documentos que se devuelven en un lote. Cada lote requiere un viaje de ida y vuelta al servidor. Si el tamaño del lote es cero (0), el cursor utiliza el tamaño máximo de lote definido por el servidor. El valor predeterminado es 0.  | 

En el siguiente ejemplo, se muestra una tabla de asignación para la segmentación automática.

```
{
    "rules": [
        {
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "object-locator": {
                "schema-name": "admin",
                "table-name": "departments"
            },
            "rule-action": "include",
            "filters": []
        },
        {
            "rule-type": "table-settings",
            "rule-id": "2",
            "rule-name": "2",
            "object-locator": {
                "schema-name": "admin",
                "table-name": "departments"
            },
            "parallel-load": {
                "type": "partitions-auto",
                "number-of-partitions": 5,
                "collection-count-from-metadata": "true",
                "max-records-skip-per-page": 1000000,
                "batch-size": 50000
            }
        }
    ]
}
```

La segmentación automática tiene la siguiente limitación. La migración de cada segmento obtiene el recuento de la recopilación y el `_id` mínimo para la recopilación de forma individual. A continuación, utiliza un salto paginado para calcular el límite mínimo de ese segmento. Por lo tanto, asegúrese de que el valor de `_id` mínimo de cada recopilación permanezca constante hasta que se calculen todos los límites de los segmentos de la recopilación. Si cambia el valor de `_id` mínimo de una recopilación durante el cálculo del límite del segmento, esto podría provocar la pérdida de datos o errores en las filas duplicadas.

### Migración de una base de datos de Amazon DocumentDB en paralelo mediante rangos de segmentos específicos
<a name="CHAP_Source.DocumentDB.ParallelLoad.Ranges"></a>

El siguiente ejemplo muestra una recopilación de Amazon DocumentDB que tiene siete elementos y `_id` como la clave principal.

![\[Recopilación de Amazon DocumentDB con siete artículos.\]](http://docs.aws.amazon.com/es_es/dms/latest/userguide/images/datarep-docdb-collection.png)


Para dividir la recopilación en tres segmentos y migrar en paralelo, puede agregar reglas de asignación de tablas a la tarea de migración, como se muestra en el siguiente ejemplo de JSON.

```
{ // Task table mappings:
  "rules": [
    {
      "rule-type": "selection",
      "rule-id": "1",
      "rule-name": "1",
      "object-locator": {
        "schema-name": "testdatabase",
        "table-name": "testtable"
      },
      "rule-action": "include"
    }, // "selection" :"rule-type"
    {
      "rule-type": "table-settings",
      "rule-id": "2",
      "rule-name": "2",
      "object-locator": {
        "schema-name": "testdatabase",
        "table-name": "testtable"
      },
      "parallel-load": {
        "type": "ranges",
        "columns": [
           "_id",
           "num"
        ],
        "boundaries": [
          // First segment selects documents with _id less-than-or-equal-to 5f805c97873173399a278d79
          // and num less-than-or-equal-to 2.
          [
             "5f805c97873173399a278d79",
             "2"
          ],
          // Second segment selects documents with _id > 5f805c97873173399a278d79 and
          // _id less-than-or-equal-to 5f805cc5873173399a278d7c and
          // num > 2 and num less-than-or-equal-to 5.
          [
             "5f805cc5873173399a278d7c",
             "5"
          ]                                   
          // Third segment is implied and selects documents with _id > 5f805cc5873173399a278d7c.
        ] // :"boundaries"
      } // :"parallel-load"
    } // "table-settings" :"rule-type"
  ] // :"rules"
} // :Task table mappings
```

Esa definición de asignación de tablas divide la recopilación de orígenes en tres segmentos y migra en paralelo. A continuación, se muestran límites de segmentación.

```
Data with _id less-than-or-equal-to "5f805c97873173399a278d79" and num less-than-or-equal-to 2 (2 records)
Data with _id less-than-or-equal-to "5f805cc5873173399a278d7c" and num less-than-or-equal-to 5 and not in (_id less-than-or-equal-to  "5f805c97873173399a278d79" and num less-than-or-equal-to 2) (3 records)
Data not in (_id less-than-or-equal-to "5f805cc5873173399a278d7c" and num less-than-or-equal-to 5) (2 records)
```

Una vez finalizada la tarea de migración, puede comprobar en los registros de tareas que las tablas se han cargado en paralelo, como se muestra en el siguiente ejemplo. También puede comprobar la cláusula `find` de Amazon DocumentDB utilizada para descargar cada segmento de la tabla de origen.

```
[TASK_MANAGER    ] I:  Start loading segment #1 of 3 of table 'testdatabase'.'testtable' (Id = 1) by subtask 1. Start load timestamp 0005B191D638FE86  (replicationtask_util.c:752)

[SOURCE_UNLOAD   ] I:  Range Segmentation filter for Segment #0 is initialized.   (mongodb_unload.c:157)

[SOURCE_UNLOAD   ] I:  Range Segmentation filter for Segment #0 is: { "_id" : { "$lte" : { "$oid" : "5f805c97873173399a278d79" } }, "num" : { "$lte" : { "$numberInt" : "2" } } }  (mongodb_unload.c:328)

[SOURCE_UNLOAD   ] I: Unload finished for segment #1 of segmented table 'testdatabase'.'testtable' (Id = 1). 2 rows sent.

[TASK_MANAGER    ] I: Start loading segment #1 of 3 of table 'testdatabase'.'testtable' (Id = 1) by subtask 1. Start load timestamp 0005B191D638FE86 (replicationtask_util.c:752)
 
[SOURCE_UNLOAD   ] I: Range Segmentation filter for Segment #0 is initialized. (mongodb_unload.c:157) 

[SOURCE_UNLOAD   ] I: Range Segmentation filter for Segment #0 is: { "_id" : { "$lte" : { "$oid" : "5f805c97873173399a278d79" } }, "num" : { "$lte" : { "$numberInt" : "2" } } } (mongodb_unload.c:328)
 
[SOURCE_UNLOAD   ] I: Unload finished for segment #1 of segmented table 'testdatabase'.'testtable' (Id = 1). 2 rows sent.

[TARGET_LOAD     ] I: Load finished for segment #1 of segmented table 'testdatabase'.'testtable' (Id = 1). 1 rows received. 0 rows skipped. Volume transfered 480.

[TASK_MANAGER    ] I: Load finished for segment #1 of table 'testdatabase'.'testtable' (Id = 1) by subtask 1. 2 records transferred.
```

Actualmente, AWS DMS admite los siguientes tipos de datos de Amazon DocumentDB como columna de clave de segmento:
+ Double
+ Cadena
+ ObjectId
+ Entero de 32 bits
+ Entero de 64 bits

## Migración de varias bases de datos cuando se utiliza Amazon DocumentDB como fuente de AWS DMS
<a name="CHAP_Source.DocumentDB.Multidatabase"></a>

AWS DMS las versiones 3.4.5 y superiores admiten la migración de varias bases de datos en una sola tarea solo para las versiones 4.0 y posteriores de Amazon DocumentDB. Si desea migrar varias bases de datos, haga lo siguiente:

1. Al crear el punto de conexión de origen de Amazon DocumentDB:
   + En el formulario AWS DMS, deje el Consola de administración de AWS **nombre de la base de datos** vacío en la sección **Configuración de puntos de conexión de** la página **Crear** puntos de conexión.
   + En AWS Command Line Interface (AWS CLI), asigne un valor de cadena vacío al **DatabaseName**parámetro del **documento DBSettings** que especifique para la **CreateEndpoint**acción.

1. Para cada base de datos que desee migrar desde este punto de conexión de origen de Amazon DocumentDB, especifique el nombre de cada base de datos como nombre de un esquema en la asignación de tabla de la tarea mediante la entrada guiada de la consola o directamente en JSON. Para obtener más información sobre la entrada guiada, consulte la descripción de [Especificación de selección de tablas y reglas de transformaciones desde la consola](CHAP_Tasks.CustomizingTasks.TableMapping.Console.md). Para obtener más información sobre el archivo JSON, consulte [Reglas y acciones de selección](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Selections.md).

Por ejemplo, es posible que especifique el siguiente JSON para migrar tres bases de datos de Amazon DocumentDB.

**Example Migrar todas las tablas de un esquema**  
El siguiente JSON migra todas las tablas de base de datos de `Customers`, `Orders` y `Suppliers` del punto de conexión de origen al punto de conexión de destino.  

```
{
    "rules": [
        {
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "object-locator": {
                "schema-name": "Customers",
                "table-name": "%"
            },
            "object-locator": {
                "schema-name": "Orders",
                "table-name": "%"
            },
            "object-locator": {
                "schema-name": "Inventory",
                "table-name": "%"
            },
            "rule-action": "include"
        }
    ]
}
```

## Limitaciones del uso de Amazon DocumentDB como fuente para AWS DMS
<a name="CHAP_Source.DocumentDB.Limitations"></a>

Las siguientes son limitaciones a la hora de utilizar Amazon DocumentDB como fuente para: AWS DMS
+ Cuando la `_id` opción se establece como una columna independiente, la cadena del identificador no puede superar los 200 caracteres.
+ Las claves de ID de objeto y de tipo de matriz se convierten en columnas que tienen los prefijos `oid` y `array` en el modo de tabla.

  Internamente, se hace referencia a estas columnas con los nombres con prefijos. Si utiliza reglas de transformación AWS DMS que hacen referencia a estas columnas, asegúrese de especificar la columna con prefijo. Por ejemplo, especifique `${oid__id}` y no `${_id}` o `${array__addresses}` y no `${_addresses}`. 
+  Los nombres de recopilaciones y claves no pueden incluir el símbolo del dólar (\$1). 
+ El modo de tabla y el modo de documento tienen las limitaciones tratadas con anterioridad.
+ La migración en paralelo mediante la segmentación automática tiene las limitaciones descritas anteriormente.
+ Un origen de Amazon DocumentDB (compatible con MongoDB) no admite el uso de una marca temporal específica como punto de partida para la captura de datos de cambios (CDC). Una tarea de replicación continua comienza a capturar los cambios independientemente de la marca temporal.
+ AWS DMS no admite documentos en los que el nivel de anidación sea superior a 97 para AWS DMS versiones anteriores a la 3.5.2.
+ DocumentDB no admite filtros de origen.
+ AWS DMS no admite la replicación CDC (captura de datos de cambios) para DocumentDB como fuente en modo de clúster elástico.

## Uso de la configuración de puntos de conexión con Amazon DocumentDB como origen
<a name="CHAP_Source.DocumentDB.ECAs"></a>

Puede utilizar la configuración de punto de conexión para configurar la base de datos de origen de Amazon DocumentDB de forma similar al uso de atributos de conexión adicionales. Los ajustes se especifican al crear el punto final de origen mediante la AWS DMS consola o mediante el `create-endpoint` comando de [AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/dms/index.html), con la sintaxis `--doc-db-settings '{"EndpointSetting": "value", ...}'` JSON.

La siguiente tabla muestra la configuración de punto de conexión que puede utilizar con Amazon DocumentDB como origen.


| Nombre de atributo | Valores válidos | Valor predeterminado y descripción | 
| --- | --- | --- | 
|   `NestingLevel`   |  `"none"` `"one"`  |  `"none"`: especifique `"none"` para utilizar el modo de documento. Especifique `"one"` para utilizar el modo de tabla.  | 
|   `ExtractDocID`   |  `true` `false`  |  `false`: utilice este atributo cuando `NestingLevel` se establezca en `"none"`.  Cuando se utiliza CDC con fuentes que generan [transacciones con varios documentos](https://www.mongodb.com/docs/manual/reference/method/Session.startTransaction/#mongodb-method-Session.startTransaction), el `ExtractDocId` parámetro **debe estar** `true` establecido en. Si este parámetro no está activado, la AWS DMS tarea fallará cuando detecte una transacción con varios documentos.  | 
|   `DocsToInvestigate`   |  Un número entero positivo mayor que `0`.  |  `1000`: utilice este atributo cuando `NestingLevel` se establezca en `"one"`.   | 
|   `ReplicateShardCollections `   |  `true` `false`  |  Si es verdadero, AWS DMS replica los datos en colecciones fragmentadas. AWS DMS solo usa esta configuración si el punto final de destino es un clúster elástico de DocumentDB. Cuando esta configuración es verdadera, tenga en cuenta lo siguiente: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/dms/latest/userguide/CHAP_Source.DocumentDB.html)  | 

## Tipos de datos de origen de Amazon DocumentDB
<a name="CHAP_Source.DocumentDB.DataTypes"></a>

En la siguiente tabla, podrá encontrar los tipos de datos de origen de Amazon DocumentDB que se admiten cuando se utiliza AWS DMS. También puede encontrar el mapeo predeterminado a partir de AWS DMS los tipos de datos en esta tabla. Para obtener más información sobre tipos de datos, consulte [Tipos de BSON](https://docs.mongodb.com/manual/reference/bson-types) en la documentación de MongoDB.

Para obtener más información sobre cómo ver el tipo de datos que se asigna en el destino, consulte la sección del punto de enlace de destino que esté utilizando.

Para obtener información adicional sobre AWS DMS los tipos de datos, consulte[Tipos de datos de AWS Database Migration Service](CHAP_Reference.DataTypes.md).


|  Tipos de datos de Amazon DocumentDB  |  AWS DMS tipos de datos  | 
| --- | --- | 
| Booleano | Bool | 
| Binario | BLOB | 
| Date | Date | 
| Marca temporal | Date | 
| Int | INT4 | 
| Largo | INT8 | 
| Doble | REAL8 | 
| Cadena (UTF-8) | CLOB | 
| Matriz | CLOB | 
| OID | Cadena | 

# Uso de Amazon S3 como fuente de AWS DMS
<a name="CHAP_Source.S3"></a>

Puede migrar datos desde un bucket de Amazon S3 mediante AWS DMS. Para ello, proporcione acceso a un bucket de Amazon S3 que contenga uno o varios archivos de datos. En ese bucket de S3 incluya un archivo JSON que describa el mapeo entre los datos y las tablas de la base de datos de los datos de esos archivos.

Los archivos de datos de origen deben estar en el bucket de Amazon S3 antes de que comience la carga completa. El nombre del bucket se especifica mediante el parámetro `bucketName`. 

Los archivos de datos de origen pueden tener los siguientes formatos:
+ Valores separados por comas (.csv)
+ Parquet (versión 3.5.3 de DMS y posteriores). Para obtener más información sobre el uso de archivos con formato Parquet, consulte [Uso de archivos con formato Parquet en Amazon S3 como fuente para AWS DMS](#CHAP_Source.S3.Parquet).

En el caso de los archivos de datos de origen en formato de valores separados por comas (.csv), asígneles un nombre con la convención de nomenclatura siguiente. En esta convención, *`schemaName`* es el esquema de origen y *`tableName`* es el nombre de una tabla dentro de dicho esquema.

```
/schemaName/tableName/LOAD001.csv
/schemaName/tableName/LOAD002.csv
/schemaName/tableName/LOAD003.csv
...
```

 Por ejemplo, supongamos que los archivos de datos están en `amzn-s3-demo-bucket`, en la siguiente ruta de Amazon S3.

```
s3://amzn-s3-demo-bucket/hr/employee
```

En el momento de la carga, AWS DMS asume que el nombre del esquema de origen es `hr` y que el nombre de la tabla de origen es`employee`.

Además `bucketName` (obligatorio), puede proporcionar opcionalmente un `bucketFolder` parámetro para especificar dónde AWS DMS deben buscarse los archivos de datos en el bucket de Amazon S3. Continuando con el ejemplo anterior, si se establece `bucketFolder` en`sourcedata`, AWS DMS lee los archivos de datos en la siguiente ruta.

```
s3://amzn-s3-demo-bucket/sourcedata/hr/employee
```

Puede especificar el delimitador de columnas, el delimitador de filas, el indicador de valor nulo y otros parámetros mediante los atributos de conexión adicionales. Para obtener más información, consulte [Configuración de puntos de conexión para Amazon S3 como fuente de AWS DMS](#CHAP_Source.S3.Configuring).

Puede especificar el propietario de un bucket y evitar saqueos mediante la configuración del punto de conexión de Amazon S3 `ExpectedBucketOwner`, como se muestra a continuación. A continuación, cuando realice una solicitud para probar una conexión o realizar una migración, S3 comprobará el ID de cuenta del propietario del bucket con el parámetro especificado.

```
--s3-settings='{"ExpectedBucketOwner": "AWS_Account_ID"}'
```

**Topics**
+ [Definir tablas externas para Amazon S3 como fuente de AWS DMS](#CHAP_Source.S3.ExternalTableDef)
+ [Uso de CDC con Amazon S3 como fuente de AWS DMS](#CHAP_Source.S3.CDC)
+ [Requisitos previos al utilizar Amazon S3 como fuente de AWS DMS](#CHAP_Source.S3.Prerequisites)
+ [Limitaciones al usar Amazon S3 como fuente de AWS DMS](#CHAP_Source.S3.Limitations)
+ [Configuración de puntos de conexión para Amazon S3 como fuente de AWS DMS](#CHAP_Source.S3.Configuring)
+ [Tipos de datos de origen de Amazon S3](#CHAP_Source.S3.DataTypes)
+ [Uso de archivos con formato Parquet en Amazon S3 como fuente para AWS DMS](#CHAP_Source.S3.Parquet)

## Definir tablas externas para Amazon S3 como fuente de AWS DMS
<a name="CHAP_Source.S3.ExternalTableDef"></a>

Además de los archivos de datos, debe indicar también una definición de tabla externa. Una *definición de tabla externa* es un documento JSON que describe cómo se AWS DMS deben interpretar los datos de Amazon S3. El tamaño máximo de este documento es de 2 MB. Si crea un punto final de origen mediante la consola AWS DMS de administración, puede introducir el JSON directamente en el cuadro de mapeo de tablas. Si utilizas AWS Command Line Interface (AWS CLI) o la AWS DMS API para realizar migraciones, puedes crear un archivo JSON para especificar la definición de la tabla externa.

Supongamos que tiene un archivo de datos que contiene la información siguiente.

```
101,Smith,Bob,2014-06-04,New York
102,Smith,Bob,2015-10-08,Los Angeles
103,Smith,Bob,2017-03-13,Dallas
104,Smith,Bob,2017-03-13,Dallas
```

A continuación se muestra un ejemplo de definición de tabla externa para estos datos.

```
{
    "TableCount": "1",
    "Tables": [
        {
            "TableName": "employee",
            "TablePath": "hr/employee/",
            "TableOwner": "hr",
            "TableColumns": [
                {
                    "ColumnName": "Id",
                    "ColumnType": "INT8",
                    "ColumnNullable": "false",
                    "ColumnIsPk": "true"
                },
                {
                    "ColumnName": "LastName",
                    "ColumnType": "STRING",
                    "ColumnLength": "20"
                },
                {
                    "ColumnName": "FirstName",
                    "ColumnType": "STRING",
                    "ColumnLength": "30"
                },
                {
                    "ColumnName": "HireDate",
                    "ColumnType": "DATETIME"
                },
                {
                    "ColumnName": "OfficeLocation",
                    "ColumnType": "STRING",
                    "ColumnLength": "20"
                }
            ],
            "TableColumnsTotal": "5"
        }
    ]
}
```

Los elementos de este documento JSON son los siguientes:

`TableCount`: el número de tablas de origen. En este ejemplo, solo hay una tabla.

`Tables`: una matriz que consta de un mapa JSON por tabla de origen. En este ejemplo, solo hay un mapa. Cada mapa está formado por los siguientes elementos:
+ `TableName`: el nombre de la tabla de origen.
+ `TablePath`: la ruta del bucket de Amazon S3 donde AWS DMS puede encontrar el archivo de carga de datos completa. Si se especifica un valor `bucketFolder`, el valor se anexa delante de la ruta.
+ `TableOwner`: nombre del esquema para esta tabla.
+ `TableColumns`: una matriz de uno o varios mapas, en la que cada mapa describe una columna de la tabla de origen:
  + `ColumnName`: el nombre de una columna de la tabla de origen.
  + `ColumnType`: el tipo de datos de la columna. Para consultar los tipos de datos válidos, vea [Tipos de datos de origen de Amazon S3](#CHAP_Source.S3.DataTypes).
  + `ColumnLength`: el número de bytes de esta columna. La longitud máxima de las columnas está limitada a 2147483647 bytes (2.047 MegaBytes), ya que una fuente de S3 no admite el modo FULL LOB. `ColumnLength`es válido para los siguientes tipos de datos:
    + BYTE
    + STRING
  + `ColumnNullable`: valor booleano que es `true` si esta columna puede contener valores NULL (predeterminado=`false`).
  + `ColumnIsPk`: un valor booleano que es `true` si esta columna es parte de la clave principal (predeterminado=`false`).
  + `ColumnDateFormat`: el formato de fecha de entrada de una columna con los tipos DATE, TIME y DATETIME, y se utiliza para analizar una cadena de datos y convertirla en un objeto de fecha. Los valores posibles son:

    ```
    - YYYY-MM-dd HH:mm:ss
    - YYYY-MM-dd HH:mm:ss.F
    - YYYY/MM/dd HH:mm:ss
    - YYYY/MM/dd HH:mm:ss.F
    - MM/dd/YYYY HH:mm:ss
    - MM/dd/YYYY HH:mm:ss.F
    - YYYYMMdd HH:mm:ss
    - YYYYMMdd HH:mm:ss.F
    ```
+ `TableColumnsTotal`: el número total de columnas. Este número debe coincidir con el número de elementos de la matriz `TableColumns`.

Si no especifica lo contrario, se AWS DMS supone que `ColumnLength` es cero.

**nota**  
En las versiones compatibles de AWS DMS, los datos de origen de S3 también pueden contener una columna de operaciones opcional como primera columna antes del valor de la `TableName` columna. Esta columna de operación identifica la operación (`INSERT`) utilizada para migrar los datos a un punto de enlace de destino S3 durante una carga completa.   
Si está presente, el valor de esta columna es el carácter inicial de la `INSERT`palabra clave de operación (`I`). Si se especifica, esta columna generalmente indica que el origen S3 fue creado por DMS como un destino S3 durante una migración anterior.   
En versiones anteriores a 3.4.2 de DMS, esta columna no estaba presente en los datos de origen de S3 creados a partir de una carga completa de DMS anterior. Agregar esta columna a los datos de destino S3 permite que el formato de todas las filas escritas en el objetivo S3 sea coherente, ya sea que se escriban durante una carga completa o durante una carga CDC. Para obtener más información acerca de las opciones para el formateo de datos de destino de S3, consulte [Indicar operaciones de base de datos de origen en datos de S3 migrados](CHAP_Target.S3.md#CHAP_Target.S3.Configuring.InsertOps).

Para una columna de tipo NUMERIC, especifique la precisión y la escala. *Precisión* es el número total de dígitos de un número y *escala* es el número de dígitos situados a la derecha de la coma decimal. Utilice los elementos `ColumnPrecision` y `ColumnScale` para esto, tal y como se muestra a continuación.

```
...
    {
        "ColumnName": "HourlyRate",
        "ColumnType": "NUMERIC",
        "ColumnPrecision": "5"
        "ColumnScale": "2"
    }
...
```

Para una columna del tipo DATETIME con datos que contienen fracciones de segundos, especifique la escala. La *escala* es el número de dígitos de las fracciones de segundo y puede oscilar entre 0 y 9. Utilice el elemento de `ColumnScale` para esto, tal y como se muestra a continuación.

```
...
{
      "ColumnName": "HireDate",
      "ColumnType": "DATETIME",
      "ColumnScale": "3"
}
...
```

Si no especifica lo contrario, AWS DMS asume que `ColumnScale` es cero y trunca las fracciones de segundo.

## Uso de CDC con Amazon S3 como fuente de AWS DMS
<a name="CHAP_Source.S3.CDC"></a>

Después de AWS DMS realizar una carga de datos completa, puede replicar opcionalmente los cambios de datos en el punto final de destino. Para ello, debe cargar archivos de captura de datos de cambios (archivos CDC) en su bucket de Amazon S3. AWS DMS lee estos archivos CDC cuando los carga y, a continuación, aplica los cambios en el punto final de destino. 

Las archivos CDC se denominan de la forma siguiente:

```
CDC00001.csv
CDC00002.csv
CDC00003.csv
...
```

**nota**  
Para poder replicar archivos de CDC correctamente en la carpeta de datos de cambios, cárguelos por orden léxico (secuencial). Por ejemplo, cargue el archivo CDC00002 .csv antes del archivo CDC00003 .csv. De lo contrario, CDC00002 .csv se omite y no se replica si lo cargas después de .csv. CDC00003 Sin embargo, el archivo CDC00004 .csv se replica correctamente si se carga después de .csv. CDC00003

Para indicar dónde AWS DMS puede encontrar los archivos, especifique el parámetro. `cdcPath` Prosiguiendo con el ejemplo anterior, si establece `cdcPath` en `changedata`, entonces AWS DMS leerá los archivos de CDC en la ruta siguiente.

```
s3://amzn-s3-demo-bucket/changedata
```

Si establece `cdcPath` en `changedata` y `bucketFolder` en `myFolder`, AWS DMS lee los archivos CDC en la siguiente ruta.

```
s3://amzn-s3-demo-bucket/myFolder/changedata
```

Los registros de un archivo CDC se formatean de la siguiente manera:
+ Operación: la operación de cambio que realizar: `INSERT` o `I`, `UPDATE` o `U` o `DELETE` o `D`. Estos valores de palabras clave y caracteres no distinguen entre mayúsculas y minúsculas.
**nota**  
En AWS DMS las versiones compatibles, AWS DMS puede identificar la operación a realizar para cada registro de carga de dos maneras. AWS DMS puede hacerlo a partir del valor de la palabra clave del registro (por ejemplo,`INSERT`) o desde el carácter inicial de la palabra clave (por ejemplo,`I`). En versiones anteriores, AWS DMS reconocía la operación de carga solo a partir del valor completo de la palabra clave.   
En versiones anteriores de AWS DMS, el valor completo de la palabra clave se escribía para registrar los datos de los CDC. Además, las versiones anteriores escribieron el valor de la operación en cualquier destino de S3 utilizando solo la inicial de la palabra clave.   
Reconocer ambos formatos AWS DMS permite gestionar la operación independientemente de cómo se escriba la columna de operaciones para crear los datos de origen de S3. Este enfoque admite el uso de datos de destino de S3 como origen para una migración posterior. Con este enfoque, no necesita cambiar el formato de ningún valor inicial de palabra clave que aparezca en la columna de operación de la fuente S3 posterior.
+ Nombre de tabla: el nombre de la tabla de origen.
+ Nombre de esquema: el nombre del esquema de origen.
+ Datos: una o varias columnas que representan los datos que se van a cambiar.

A continuación se muestra un ejemplo de un archivo CDC para una tabla con el nombre `employee`.

```
INSERT,employee,hr,101,Smith,Bob,2014-06-04,New York
UPDATE,employee,hr,101,Smith,Bob,2015-10-08,Los Angeles
UPDATE,employee,hr,101,Smith,Bob,2017-03-13,Dallas
DELETE,employee,hr,101,Smith,Bob,2017-03-13,Dallas
```

## Requisitos previos al utilizar Amazon S3 como fuente de AWS DMS
<a name="CHAP_Source.S3.Prerequisites"></a>

Para utilizar Amazon S3 como fuente AWS DMS, el bucket de S3 de origen debe estar en la misma AWS región que la instancia de replicación de DMS que migra los datos. Además, la cuenta de AWS que utiliza para la migración debe tener acceso de lectura al bucket de origen. Para la AWS DMS versión 3.4.7 y versiones posteriores, el DMS debe acceder al bucket de origen a través de un punto final de VPC o una ruta pública. Para obtener información sobre los puntos de conexión de VPC, consulte [Configuración de puntos finales de VPC para AWS DMS](CHAP_VPC_Endpoints.md).

El rol AWS Identity and Access Management (IAM) asignado a la cuenta de usuario utilizada para crear la tarea de migración debe tener el siguiente conjunto de permisos.

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
       {
            "Effect": "Allow",
            "Action": [
                "s3:GetObject"
            ],
            "Resource": [
                "arn:aws:s3:::amzn-s3-demo-bucket*/*"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::amzn-s3-demo-bucket*"
            ]
        }
    ]
}
```

------

El rol AWS Identity and Access Management (IAM) asignado a la cuenta de usuario utilizada para crear la tarea de migración debe tener el siguiente conjunto de permisos si el control de versiones está habilitado en el bucket de Amazon S3.

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
       {
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:GetObjectVersion"
            ],
            "Resource": [
                "arn:aws:s3:::amzn-s3-demo-bucket*/*"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::amzn-s3-demo-bucket*"
            ]
        }
    ]
}
```

------

## Limitaciones al usar Amazon S3 como fuente de AWS DMS
<a name="CHAP_Source.S3.Limitations"></a>

Las siguientes limitaciones se aplican cuando se utiliza Amazon S3 como origen:
+ No habilite el control de versiones para S3. Si necesita el control de versiones de S3, utilice las políticas de ciclo de vida para eliminar activamente las versiones antiguas. De lo contrario, es posible que se produzcan errores en la conexión de las pruebas de punto de conexión debido al tiempo de espera de una llamada a `list-object` de S3. Para crear una política de ciclo de vida para un bucket de S3, consulte [Administración del ciclo de vida del almacenamiento](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html). Para eliminar una versión de un objeto de S3, consulte [Eliminación de versiones de objetos de un bucket con control de versiones habilitado](https://docs.aws.amazon.com/AmazonS3/latest/dev/DeletingObjectVersions.html).
+ En las versiones 3.4.7 y superiores se admite un bucket S3 habilitado para VPC (VPC de puerta de enlace).
+ MySQL convierte el tipo de datos `time` en `string`. Para ver los valores de los tipos de datos `time` en MySQL, defina la columna de la tabla de destino como `string` y establezca la configuración **Modo de preparación de la tabla de destino** de la tarea en **Truncar**.
+ AWS DMS utiliza el tipo de `BYTE` datos internamente para los datos de ambos `BYTE` tipos de `BYTES` datos.
+ Los puntos de conexión de origen de S3 no admiten la característica de recarga de tablas de DMS.
+ AWS DMS no admite el modo LOB completo con Amazon S3 como fuente.

Las siguientes limitaciones se aplican al usar archivos de formato Parquet en Amazon S3 como origen:
+ Las fechas en formato `MMYYYYDD` o `DDMMYYYY` no son compatibles con la característica de particionamiento de fechas de Parquet de S3 como origen.

## Configuración de puntos de conexión para Amazon S3 como fuente de AWS DMS
<a name="CHAP_Source.S3.Configuring"></a>

Puede utilizar la configuración de punto de conexión para configurar la base de datos de origen de Amazon S3 de forma similar al uso de atributos de conexión adicionales. Los ajustes se especifican al crear el punto final de origen mediante la AWS DMS consola o mediante el `create-endpoint` comando incluido [AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/dms/index.html)en la sintaxis `--s3-settings '{"EndpointSetting": "value", ...}'` JSON.

**nota**  
AWS DMS de forma predeterminada, es una conexión segura al punto de conexión Amazon S3 sin necesidad de especificar el modo o el certificado SSL.

La siguiente tabla muestra la configuración de punto de conexión que puede utilizar con Amazon S3 como origen.


| **Opción** | **Descripción** | 
| --- | --- | 
| BucketFolder |  (Opcional) Nombre de carpeta en el bucket de S3. Si se proporciona este atributo, los archivos de datos de origen y los archivos de CDC se leen desde la ruta `s3://amzn-s3-demo-bucket/bucketFolder/schemaName/tableName/` y `s3://amzn-s3-demo-bucket/bucketFolder/` respectivamente. Si no se especifica este atributo, la ruta utilizada es `schemaName/tableName/`.  `'{"BucketFolder": "sourceData"}'`  | 
| BucketName |  Nombre del bucket de S3. `'{"BucketName": "amzn-s3-demo-bucket"}'`  | 
| CdcPath | La ubicación de los archivos de CDC. Este atributo es obligatorio si una tarea captura datos de cambios; de lo contrario, es opcional. Si CdcPath está presente, AWS DMS lee los archivos CDC de esta ruta y replica los cambios de datos en el punto final de destino. Para obtener más información, consulte [Uso de CDC con Amazon S3 como fuente de AWS DMS](#CHAP_Source.S3.CDC). `'{"CdcPath": "changeData"}'`  | 
| CsvDelimiter |  Delimitador utilizado para separar columnas en los archivos de origen. El valor predeterminado es una coma. Ejemplo: `'{"CsvDelimiter": ","}'`  | 
| CsvNullValue |  Cadena definida por el usuario que se AWS DMS considera nula cuando se lee desde la fuente. El valor predeterminado es una cadena vacía. Si no establece este parámetro, AWS DMS trata una cadena vacía como un valor nulo. Si establece este parámetro en una cadena como «\$1 N», AWS DMS trata esta cadena como un valor nulo y trata las cadenas vacías como un valor de cadena vacío.  | 
| CsvRowDelimiter |  Delimitador utilizado para separar filas en los archivos de origen. El valor predeterminado es una nueva línea (`\n`). `'{"CsvRowDelimiter": "\n"}'`  | 
| DataFormat |  Establezca este valor en `Parquet` para leer los datos en formato Parquet. `'{"DataFormat": "Parquet"}'`  | 
| IgnoreHeaderRows |  Si este valor se establece en 1, AWS DMS ignora el encabezado de la primera fila de un archivo.csv. Un valor de 1 habilita la característica, un valor de 0 deshabilita la característica. El valor predeterminado es 0. `'{"IgnoreHeaderRows": 1}'`  | 
| Rfc4180 |  Cuando este valor se establece en `true` o `y`, las comillas dobles de inicio tienen que ir seguidas de comillas dobles finales. Este formato cumple con RFC 4180. Cuando este valor se establece en `false` o `n`, los literales de cadena se copian en el destino tal cual. En este caso, un delimitador (fila o columna) señala el final del campo. Por lo tanto, no puede utilizar un delimitador como parte de la cadena, ya que señala el final del valor. El valor predeterminado es `true`. Valores válidos: `true`, `false`, `y`, `n` `'{"Rfc4180": false}'`  | 

## Tipos de datos de origen de Amazon S3
<a name="CHAP_Source.S3.DataTypes"></a>

Migración de datos que utiliza Amazon S3 como fuente para AWS DMS las necesidades de mapear datos de Amazon S3 a tipos de AWS DMS datos. Para obtener más información, consulte [Definir tablas externas para Amazon S3 como fuente de AWS DMS](#CHAP_Source.S3.ExternalTableDef).

Para obtener más información sobre cómo ver el tipo de datos que se asigna en el destino, consulte la sección del punto de enlace de destino que esté utilizando.

Para obtener información adicional sobre AWS DMS los tipos de datos, consulte[Tipos de datos de AWS Database Migration Service](CHAP_Reference.DataTypes.md).

Los siguientes tipos de AWS DMS datos se utilizan con Amazon S3 como fuente:
+ BYTE: requiere `ColumnLength`. Para obtener más información, consulte [Definir tablas externas para Amazon S3 como fuente de AWS DMS](#CHAP_Source.S3.ExternalTableDef).
+ DATE
+ TIME
+ DATETIME: para obtener más información y un ejemplo, consulte el ejemplo del tipo DATETIME en [Definir tablas externas para Amazon S3 como fuente de AWS DMS](#CHAP_Source.S3.ExternalTableDef).
+ INT1
+ INT2
+ INT4
+ INT8
+ NUMÉRICO: requiere `ColumnPrecision` y`ColumnScale`. AWS DMS admite los siguientes valores máximos:
  + **ColumnPrecision: 38**
  + **ColumnScale: 31**

  Para obtener más información y un ejemplo, consulte el ejemplo del tipo NUMERIC en [Definir tablas externas para Amazon S3 como fuente de AWS DMS](#CHAP_Source.S3.ExternalTableDef).
+ REAL4
+ REAL8
+ STRING: requiere `ColumnLength`. Para obtener más información, consulte [Definir tablas externas para Amazon S3 como fuente de AWS DMS](#CHAP_Source.S3.ExternalTableDef).
+ UINT1
+ UINT2
+ UINT4
+ UINT8
+ BLOB
+ CLOB
+ BOOLEANO

## Uso de archivos con formato Parquet en Amazon S3 como fuente para AWS DMS
<a name="CHAP_Source.S3.Parquet"></a>

En la AWS DMS versión 3.5.3 y posteriores, puede usar archivos con formato Parquet en un bucket de S3 como fuente tanto para la replicación a carga completa como para la replicación CDC. 

DMS solo admite archivos en formato Parquet como origen que DMS genera al migrar datos a un punto de conexión de destino de S3. Los nombres de los archivos deben estar en el formato compatible; de lo contrario, DMS no los incluirá en la migración.

En el caso de archivos de datos de origen en formato Parquet, estos deben estar en la carpeta y la convención de nomenclatura siguientes.

```
schema/table1/LOAD00001.parquet
schema/table2/LOAD00002.parquet
schema/table2/LOAD00003.parquet
```

En el caso de archivos de datos de origen para datos CDC en formato Parquet, asígneles un nombre y almacénelos con la carpeta y la convención de nomenclatura siguientes.

```
schema/table/20230405-094615814.parquet
schema/table/20230405-094615853.parquet
schema/table/20230405-094615922.parquet
```

Para acceder a los archivos en formato Parquet, establezca la siguiente configuración de punto de conexión:
+ Establece `DataFormat` en `Parquet`. 
+ No establezca el valor `cdcPath`. Asegúrese de crear los archivos con formato Parquet en las carpetas de esquemas o tablas especificadas. 

Para obtener más información sobre la configuración de los puntos de conexión de S3, consulte [S3Settings](https://docs.aws.amazon.com/dms/latest/APIReference/API_S3Settings.html) en la *Referencia de la API de AWS Database Migration Service *.

### Tipos de datos compatibles con los archivos en formato Parquet
<a name="CHAP_Source.S3.Parquet.Datatypes"></a>

AWS DMS admite los siguientes tipos de datos de origen y destino al migrar datos desde archivos con formato Parquet. Asegúrese de que la tabla de destino tenga columnas con los tipos de datos correctos antes de realizar la migración.


| Tipo de datos de origen | Tipo de datos de destino | 
| --- | --- | 
| BYTE | BINARY | 
| DATE | DATE32 | 
| TIME | TIME32 | 
| DATETIME | TIMESTAMP | 
| INT1 | INT8 | 
| INT2 | INT16 | 
| INT4 | INT32 | 
| INT8 | INT64 | 
| NUMERIC | DECIMAL | 
| REAL4 | FLOAT | 
| REAL8 | DOUBLE | 
| STRING | STRING | 
| UINT1 | UINT8 | 
| UINT2 | UINT16 | 
| UINT4 | UINT32 | 
| UINT8 | UINT | 
| WSTRING | STRING | 
| BLOB | BINARY | 
| NCLOB | STRING | 
| CLOB | STRING | 
| BOOLEAN | BOOL | 

# Uso de la base de datos IBM Db2 para Linux, Unix, Windows y Amazon RDS (Db2 LUW) como fuente para AWS DMS
<a name="CHAP_Source.DB2"></a>

Puede migrar datos de una base de datos IBM Db2 para Linux, Unix, Windows y Amazon RDS (Db2 LUW) a cualquier base de datos de destino compatible mediante (). AWS Database Migration Service AWS DMS

Para obtener información sobre las versiones de Db2 en Linux, Unix, Windows y RDS que son compatibles como fuente, consulte. AWS DMS [Fuentes de AWS DMS](CHAP_Introduction.Sources.md) 

Puede utilizar la Capa de conexión segura (SSL) para cifrar las conexiones entre el punto de enlace de Db2 LUW y la instancia de replicación. Para obtener más información sobre cómo utilizar SSL con un punto de enlace de Db2 LUW, consulte [Uso de SSL con AWS Database Migration Service](CHAP_Security.SSL.md).

Cuando AWS DMS lee los datos de una base de datos fuente de IBM Db2, utiliza el nivel de aislamiento CURSOR STABILITY (CS) predeterminado para la versión 9.7 y superior de Db2. Para obtener más información, consulte la documentación de [IBM Db2 for Linux, UNIX and Windows](https://www.ibm.com/docs/en/db2/12.1.0).

## Requisitos previos al utilizar Db2 LUW como fuente de AWS DMS
<a name="CHAP_Source.DB2.Prerequisites"></a>

Los siguientes requisitos previos son necesarios para poder utilizar una base de datos Db2 LUW como origen.

Para habilitar la replicación continua, también llamada captura de datos de cambios (CDC), haga lo siguiente:
+ Configure la base de datos para que sea recuperable, lo que AWS DMS requiere capturar los cambios. Una base de datos es recuperable si uno o ambos parámetros de configuración de la base de datos, `LOGARCHMETH1` y `LOGARCHMETH2`, se establecen en `ON`.

  Si su base de datos es recuperable, AWS DMS puede acceder al Db2 si es necesario. `ARCHIVE LOG`
+ Asegúrese de que los registros de DB2 transacciones estén disponibles, con un período de retención suficiente para procesarlos. AWS DMS
+ DB2 requiere `SYSADM` o `DBADM` autorización para extraer los registros del registro de transacciones. Conceda a la cuenta de usuario los siguientes permisos:
  + `SYSADM` o `DBADM`
  + `DATAACCESS`
**nota**  
Para las tareas exclusivas de carga completa, la cuenta de usuario de DMS necesita el permiso DATAACCESS.
+ Cuando utilice la versión 9.7 de IBM DB2 for LUW como fuente, defina el atributo de conexión adicional (ECA) de la `CurrentLsn` siguiente manera:

  `CurrentLsn=LSN` donde `LSN` especifica un número de secuencia de registro (LSN) donde desea que comience la replicación. O `CurrentLsn=scan`.
+ Cuando utilice Amazon RDS para Db2 LUW como fuente, asegúrese de que los registros del archivo estén disponibles para. AWS DMS Dado que las bases AWS de datos Db2 administradas purgan los registros del archivo lo antes posible, debe aumentar el tiempo que los registros permanecen disponibles. Por ejemplo, para incrementar la retención de registros a 24 horas, ejecute el siguiente comando:

  ```
  db2 "call rdsadmin.set_archive_log_retention( ?, 'TESTDB', '24')"
  ```

  Para obtener más información sobre los procedimientos de Amazon RDS para Db2 LUW, consulte la [Referencia de procedimientos almacenados de Amazon RDS para Db2](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/db2-stored-procedures.html) en la *Guía del usuario de Amazon Relational Database Service*.
+ Otorgue los siguientes privilegios si utiliza evaluaciones previas a la migración DB2 específicas:

  ```
  GRANT CONNECT ON DATABASE TO USER <DMS_USER>;
  GRANT SELECT ON SYSIBM.SYSDUMMY1 TO USER <DMS_USER>;
  GRANT SELECT ON SYSIBMADM.ENV_INST_INFO TO USER <DMS_USER>;
  GRANT SELECT ON SYSIBMADM.DBCFG TO USER <DMS_USER>;
  GRANT SELECT ON SYSCAT.SCHEMATA TO USER <DMS_USER>;
  GRANT SELECT ON SYSCAT.COLUMNS TO USER <DMS_USER>;
  GRANT SELECT ON SYSCAT.TABLES TO USER <DMS_USER>;
  GRANT EXECUTE ON FUNCTION SYSPROC.AUTH_LIST_AUTHORITIES_FOR_AUTHID TO <DMS_USER>;
  GRANT EXECUTE ON PACKAGE NULLID.SYSSH200 TO USER <DMS_USER>;
  ```

## Limitaciones al utilizar Db2 LUW como fuente de AWS DMS
<a name="CHAP_Source.DB2.Limitations"></a>

AWS DMS no admite bases de datos agrupadas. Sin embargo, puede definir una base de datos Db2 LUW independiente para cada uno de los puntos de enlace de un clúster. Por ejemplo, puede crear una tarea de migración de carga completa con cualquiera de los nodos del clúster y, a continuación, crear tareas independientes de cada nodo.

AWS DMS no admite el tipo de `BOOLEAN` datos de la base de datos LUW Db2 de origen.

Al utilizar la replicación continua (CDC), se aplican las siguientes restricciones:
+ Cuando se trunca una tabla con varias particiones, el número de eventos DDL que se muestran en la AWS DMS consola es igual al número de particiones. Esto se debe a que Db2 LUW registra un DDL individual para cada partición.
+ Las siguientes acciones de DDL no se admiten en las tablas con particiones:
  + ALTER TABLE ADD PARTITION
  + ALTER TABLE DETACH PARTITION
  + ALTER TABLE ATTACH PARTITION
+ AWS DMS no admite una migración de replicación continua desde una instancia en espera de recuperación ante desastres (HADR) de DB2 alta disponibilidad. No se puede acceder al modo de espera.
+ No se admite el tipo de datos DECFLOAT. Por lo tanto, los cambios en las columnas DECFLOAT se omiten durante la replicación continua.
+ No se admite la instrucción RENAME COLUMN.
+ Al actualizar las tablas de agrupamiento multidimensional (MDC), cada actualización se muestra en la AWS DMS consola como INSERT \$1 DELETE.
+ Cuando la opción de tarea **Include LOB columns in replication (Incluir columnas LOB en la replicación)** no está habilitada, toda tabla que tenga columnas LOB se suspende durante la replicación continua.
+ En las versiones 10.5 y superiores de Db2 LUW, se omiten las columnas de cadenas de longitud variable con datos almacenados. out-of-row Esta limitación solo se aplica a las tablas creadas con un tamaño de fila ampliado para columnas con tipos de datos como VARCHAR y VARGRAPHIC. Para evitar esta limitación, mueva la tabla a un espacio de tabla con un tamaño de página superior. Para obtener más información, consulte [¿Qué puedo hacer si quiero cambiar el tamaño de página de los espacios de tabla]( https://www.ibm.com/support/pages/what-can-i-do-if-i-want-change-pagesize-db2-tablespaces )? DB2 
+ Para una replicación continua, DMS no admite la migración de los datos cargados a nivel de página mediante la utilidad LOAD. DB2 En su lugar, utilice la utilidad IMPORT, que utiliza inserciones SQL. Para obtener más información, consulte las [diferencias entre las utilidades de importación y carga]( https://www.ibm.com/docs/en/db2/11.1?topic=utilities-differences-between-import-load-utility). 
+ Mientras se ejecuta una tarea de replicación, DMS captura CREATE TABLE DDLs solo si las tablas se crearon con el atributo DATA CAPTURE CHANGE.
+ DMS presenta las siguientes limitaciones al utilizar la característica de partición de bases de datos de Db2:
  + DMS no puede coordinar las transacciones entre los nodos de Db2 en un entorno de partición de bases de datos. Esto se debe a las limitaciones de la interfaz API DB2 READLOG de IBM. En el DPF, las transacciones pueden abarcar varios nodos de Db2, en función de cómo se DB2 particionen los datos. Como resultado, la solución de DMS debe capturar las transacciones de cada nodo de Db2 de forma independiente.
  + DMS puede capturar las transacciones locales de cada nodo de Db2 en el clúster de partición de bases de datos si se establece `connectNode` en `1` en varios puntos de conexión de origen de DMS. Esta configuración corresponde a los números de nodos lógicos definidos en el archivo de configuración del DB2 servidor. `db2nodes.cfg`
  + Las transacciones locales en nodos individuales de Db2 pueden formar parte de una transacción global más grande. DMS aplica cada transacción local de forma independiente en el destino, sin coordinación con las transacciones de otros nodos de Db2. Este procesamiento independiente puede provocar complicaciones, sobre todo cuando se mueven las filas entre las particiones.
  + Cuando DMS se replica desde varios nodos de Db2, no se garantiza el orden correcto de las operaciones en el destino, ya que DMS aplica las operaciones de forma independiente para cada nodo de Db2. Debe asegurarse de que la captura de transacciones locales con independencia de cada nodo de Db2 funcione para su caso de uso específico.
  + Al migrar desde un entorno de partición de bases de datos, se recomienda ejecutar primero una tarea de carga completa sin eventos en caché y, después, ejecutar tareas exclusivas de CDC. Se recomienda ejecutar una tarea por nodo de Db2, empezando por la marca de tiempo de inicio a plena carga o el LRI (identificador de registro) que establezca con el atributo de conexión adicional del `StartFromContext` punto final. Para obtener información sobre cómo determinar el punto de inicio de la replicación, consulte [Finding the LSN or LRI value for replication start](https://www.ibm.com/support/pages/db2-finding-lsn-or-lri-value-replication-start) en la *documentación de soporte de IBM*. 
+ Para la replicación continua (CDC), si planea iniciar la replicación desde una marca de tiempo específica, debe establecer el atributo de conexión `StartFromContext` adicional en la marca de tiempo requerida.
+ Actualmente, DMS no admite la función PureScale de Db2, una extensión de DB2 LUW que puede utilizar para escalar su solución de base de datos.
+ La opción de `DATA CAPTURE CHANGES` tabla es un requisito previo fundamental para los procesos de replicación de datos. DB2 Si no se habilita esta opción al crear tablas, es posible que falten datos, especialmente en el caso de la CDC (Change Data Capture), que solo se trata de tareas de replicación iniciadas desde un punto de partida anterior. AWS DMS activará este atributo de forma predeterminada al reiniciar una tarea de CDC o FULL\$1CDC. Sin embargo, es posible que se omita cualquier cambio realizado en la base de datos de origen antes del reinicio de la tarea.

  ```
  ALTER TABLE TABLE_SCHEMA.TABLE_NAME DATA CAPTURE CHANGES INCLUDE LONGVAR COLUMNS;
  ```

## Configuración del punto final cuando se utiliza Db2 LUW como fuente de AWS DMS
<a name="CHAP_Source.DB2.ConnectionSettings"></a>

Puede especificar la configuración al crear el punto final de origen mediante la AWS DMS consola o mediante el `create-endpoint` comando de [AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/dms/create-endpoint.html), con la

`--ibm-db2-settings '{"EndpointSetting1": "value1","EndpointSetting2": "value2"}'`

Sintaxis JSON.

La siguiente tabla muestra la configuración de punto de conexión que puede utilizar con Db2 LUW como origen.


| Nombre de configuración | Description (Descripción) | 
| --- | --- | 
|  `CurrentLsn`  |  Para la replicación continua de cambios (CDC), utilice `CurrentLsn` para especificar un número de secuencia de registro (LSN) donde desea que comience la replicación.   | 
|  `MaxKBytesPerRead`  |  Número máximo de bytes por lectura, como valor NUMBER. El valor predeterminado es 64 KB.  | 
|  `SetDataCaptureChanges`  |  Habilita la replicación continua (CDC) como valor booleano. El valor predeterminado es true.  | 

## Atributos de conexión adicionales (ECAs) cuando se utiliza Db2 LUW como fuente para AWS DMS
<a name="CHAP_Source.DB2.ConnectionAttrib"></a>

Puede especificar los atributos de conexión adicionales (ECAs) al crear el punto final de origen mediante la AWS DMS consola o mediante el `create-endpoint` comando de [AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/dms/create-endpoint.html), con el

`--extra-connection-attributes 'ECAname1=value1;ECAname2=value2;'`

En la siguiente tabla se muestran los ECAs que puede utilizar con Db2 LUW como fuente.


| Nombre de atributo | Description (Descripción) | 
| --- | --- | 
|  `ConnectionTimeout`  |  Utilice este ECA para configurar el tiempo de espera de la conexión del punto final LUW de Db2, en segundos. El valor de predeterminado es de 10 segundos. Ejemplo: `ConnectionTimeout=30;`  | 
|  `executeTimeout`  |  Atributo de conexión adicional que establece el tiempo de espera de la sentencia (consulta) para el punto final DB2 LUW, en segundos. El valor de predeterminado es de 60 segundos. Ejemplo: `executeTimeout=120;`  | 
|  `StartFromContext`  |  Para la replicación continua (CDC), utilice `StartFromContext` para especificar un límite inferior de un registro desde donde desea que comience la replicación. `StartFromContext` acepta diferentes formas de valores. Los valores válidos son: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/dms/latest/userguide/CHAP_Source.DB2.html) [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/dms/latest/userguide/CHAP_Source.DB2.html) [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/dms/latest/userguide/CHAP_Source.DB2.html) Para determinar el LRI/LSN rango de un archivo de registro, ejecute el `db2flsn` comando como se muestra en el siguiente ejemplo. <pre>db2flsn -db SAMPLE -lrirange 2</pre> El resultado de ese ejemplo es similar al siguiente.  <pre><br />S0000002.LOG: has LRI range 00000000000000010000000000002254000000000004F9A6 to <br />000000000000000100000000000022CC000000000004FB13</pre> En ese resultado, el archivo de registro es S0000002.LOG y el valor **StartFromContext**LRI son los 34 bytes al final del rango. <pre>0100000000000022CC000000000004FB13</pre>  | 

## Tipos de datos de origen para IBM Db2 LUW
<a name="CHAP_Source.DB2.DataTypes"></a>

La migración de datos que utiliza Db2 LUW como fuente es AWS DMS compatible con la mayoría de los tipos de datos LUW de Db2. La siguiente tabla muestra los tipos de datos de origen LUW de Db2 que se admiten cuando se utilizan AWS DMS y el mapeo predeterminado a partir de los tipos de datos. AWS DMS Para obtener más información sobre los tipos de datos de Db2 LUW, consulte la [documentación sobre Db2 LUW](https://www.ibm.com/support/knowledgecenter/SSEPGG_10.5.0/com.ibm.db2.luw.sql.ref.doc/doc/r0008483.html).

Para obtener más información sobre cómo ver el tipo de datos que se asigna en el destino, consulte la sección del punto de enlace de destino que esté utilizando.

Para obtener información adicional sobre AWS DMS los tipos de datos, consulte. [Tipos de datos de AWS Database Migration Service](CHAP_Reference.DataTypes.md)


|  Tipos de datos de Db2 LUW  |  AWS DMS tipos de datos  | 
| --- | --- | 
|  INTEGER  |  INT4  | 
|  SMALLINT  |  INT2  | 
|  BIGINT  |  INT8  | 
|  DECIMAL (p,s)  |  NUMERIC (p,s)  | 
|  FLOAT  |  REAL8  | 
|  DOUBLE  |  REAL8  | 
|  REAL  |  REAL4  | 
|  DECFLOAT (p)  |  Si la precisión es 16, entonces REAL8; si la precisión es 34, entonces STRING  | 
|  GRAPHIC (n)  |  WSTRING, para cadenas de gráficos de longitud fija de caracteres de dos bytes con una longitud mayor que 0 y menor o igual a 127  | 
|  VARGRAPHIC (n)  |  WSTRING, para cadenas de gráficos de longitud variable con una longitud mayor que 0 y menor o igual a 16.352 caracteres de dos bytes  | 
|  LONG VARGRAPHIC (n)  |  CLOB, para cadenas de gráficos de longitud variable con una longitud mayor que 0 y menor o igual a 16.352 caracteres de dos bytes  | 
|  CHARACTER (n)  |  STRING, para cadenas de longitud fija de caracteres de dos bytes con una longitud mayor que 0 y menor o igual a 255  | 
|  VARCHAR (n)  |  STRING, para cadenas de longitud variable de caracteres de dos bytes con una longitud mayor que 0 y menor o igual a 32.704  | 
|  LONG VARCHAR (n)  |  CLOB, para cadenas de longitud variable de caracteres de dos bytes con una longitud mayor que 0 y menor o igual a 32.704  | 
|  CHAR (n) FOR BIT DATA  |  BYTES  | 
|  VARCHAR (n) FOR BIT DATA  |  BYTES  | 
|  LONG VARCHAR FOR BIT DATA  |  BYTES  | 
|  DATE  |  DATE  | 
|  TIME  |  TIME  | 
|  TIMESTAMP  |  DATETIME  | 
|  BLOB (n)  |  BLOB La longitud máxima es de 2 147 483 647 bytes  | 
|  CLOB (n)  |  CLOB La longitud máxima es de 2 147 483 647 bytes  | 
|  DBCLOB (n)  |  CLOB La longitud máxima es 1 073 741 824 de caracteres de dos bytes  | 
|  XML  |  CLOB  | 

# Uso de IBM Db2 para z/OS bases de datos como fuente para AWS DMS
<a name="CHAP_Source.DB2zOS"></a>

Puede migrar datos de una base de datos de IBM for a cualquier z/OS base de datos de destino compatible mediante AWS Database Migration Service (AWS DMS). 

Para obtener información sobre las versiones de Db2 z/OS que se AWS DMS admiten como fuente, consulte[Fuentes de AWS DMS](CHAP_Introduction.Sources.md).

## Requisitos previos al utilizar Db2 for z/OS como fuente de AWS DMS
<a name="CHAP_Source.DB2zOS.Prerequisites"></a>

Para utilizar una z/OS base de datos IBM Db2 for como fuente AWS DMS, conceda los siguientes privilegios al Db2 para el z/OS usuario especificado en la configuración de conexión del punto final de origen.

```
GRANT SELECT ON SYSIBM.SYSTABLES TO Db2USER;
GRANT SELECT ON SYSIBM.SYSTABLESPACE TO Db2USER;
GRANT SELECT ON SYSIBM.SYSTABLEPART TO Db2USER;                    
GRANT SELECT ON SYSIBM.SYSCOLUMNS TO Db2USER;
GRANT SELECT ON SYSIBM.SYSDATABASE TO Db2USER;
GRANT SELECT ON SYSIBM.SYSDUMMY1 TO Db2USER
```

Conceda también las tablas de origen SELECT ON `user defined`.

Un punto final de AWS DMS IBM Db2 para z/OS origen se basa en el controlador IBM Data Server for ODBC para acceder a los datos. El servidor de base de datos debe tener una licencia IBM ODBC Connect válida para que DMS se conecte a este punto de conexión.

## Limitaciones a la hora de utilizar Db2 for z/OS como fuente para AWS DMS
<a name="CHAP_Source.DB2zOS.Limitations"></a>

Las siguientes limitaciones se aplican al utilizar una z/OS base de datos IBM Db2 for como fuente para: AWS DMS
+ Solo se admiten las tareas de replicación de carga completa. No se admite la captura de datos de cambios (CDC).
+ La carga paralela no es compatible.
+ La validación de datos de vistas no es compatible.
+ Los nombres de los esquemas, tablas y columnas deben especificarse en mayúsculas en las asignaciones de tablas para las transformaciones de nivel y los filtros de selección a Column/table nivel de fila.

## Tipos de datos de origen para IBM Db2 para z/OS
<a name="CHAP_Source.DB2zOS.DataTypes"></a>

Las migraciones de datos que utilizan Db2 z/OS como fuente son AWS DMS compatibles con la mayoría de los tipos de datos de Db2 for. z/OS La siguiente tabla muestra el Db2 para los tipos de datos de z/OS origen que se admiten cuando se utilizan y el mapeo predeterminado a AWS DMS partir de los tipos de datos. AWS DMS 

Para obtener más información sobre Db2 para z/OS los tipos de datos, consulte la documentación de [IBM Db2](https://www.ibm.com/docs/en/db2-for-zos/12?topic=elements-data-types). z/OS 

Para obtener más información sobre cómo ver el tipo de datos que se asigna en el destino, consulte la sección del punto de enlace de destino que esté utilizando.

Para obtener información adicional sobre AWS DMS los tipos de datos, consulte. [Tipos de datos de AWS Database Migration Service](CHAP_Reference.DataTypes.md)


|  Db2 para tipos de z/OS datos  |  AWS DMS tipos de datos  | 
| --- | --- | 
|  INTEGER  |  INT4  | 
|  SMALLINT  |  INT2  | 
|  BIGINT  |  INT8  | 
|  DECIMAL (p,s)  |  NUMERIC (p,s) Si el punto decimal se establece en una coma (,) en la DB2 configuración, configure Replicate para que sea compatible con el DB2 ajuste.   | 
|  FLOAT  |  REAL8  | 
|  DOUBLE  |  REAL8  | 
|  REAL  |  REAL4  | 
|  DECFLOAT (p)  |  Si la precisión es 16, entonces REAL8; si la precisión es 34, entonces STRING  | 
|  GRAPHIC (n)  |  Si n>=127 entonces WSTRING, para cadenas de gráficos de longitud fija de caracteres de dos bytes con una longitud mayor que 0 y menor o igual a 127  | 
|  VARGRAPHIC (n)  |  WSTRING, para cadenas de gráficos de longitud variable con una longitud mayor que 0 y menor o igual a 16.352 caracteres de dos bytes  | 
|  LONG VARGRAPHIC (n)  |  CLOB, para cadenas de gráficos de longitud variable con una longitud mayor que 0 y menor o igual a 16.352 caracteres de dos bytes  | 
|  CHARACTER (n)  |  STRING, para cadenas de longitud fija de caracteres de dos bytes con una longitud mayor que 0 y menor o igual a 255  | 
|  VARCHAR (n)  |  STRING, para cadenas de longitud variable de caracteres de dos bytes con una longitud mayor que 0 y menor o igual a 32.704  | 
|  LONG VARCHAR (n)  |  CLOB, para cadenas de longitud variable de caracteres de dos bytes con una longitud mayor que 0 y menor o igual a 32.704  | 
|  CHAR (n) FOR BIT DATA  |  BYTES  | 
|  VARCHAR (n) FOR BIT DATA  |  BYTES  | 
|  LONG VARCHAR FOR BIT DATA  |  BYTES  | 
|  DATE  |  DATE  | 
|  TIME  |  TIME  | 
|  TIMESTAMP  |  DATETIME  | 
|  BLOB (n)  |  BLOB La longitud máxima es de 2 147 483 647 bytes  | 
|  CLOB (n)  |  CLOB La longitud máxima es de 2 147 483 647 bytes  | 
|  DBCLOB (n)  |  CLOB La longitud máxima es 1 073 741 824 de caracteres de dos bytes  | 
|  XML  |  CLOB  | 
|  BINARIO  |  BYTES  | 
|  VARBINARY  |  BYTES  | 
|  ROWID  |  BYTES. Para obtener más información acerca de cómo trabajar con ROWID, consulte lo siguiente.   | 
|  MARCA DE TIEMPO CON ZONA HORARIA  |  No admitido.  | 

Las columnas ROWID se migran de forma predeterminada cuando el modo de preparación de la tabla de destino para la tarea está establecido en DROP\$1AND\$1CREATE (predeterminado). La validación de datos ignora estas columnas porque las filas no tienen sentido fuera de la base de datos y la tabla específicas. Para desactivar la migración de estas columnas, puede realizar uno de los siguientes pasos preparatorios: 
+ Cree previamente la tabla de destino sin estas columnas. A continuación, establezca el modo de preparación de la tabla de destino de la tarea en DO\$1NOTHING o TRUNCATE\$1BEFORE\$1LOAD. Puede usar AWS Schema Conversion Tool (AWS SCT) para crear previamente la tabla de destino sin las columnas.
+ Agregue una regla de asignación de tablas a una tarea que filtre estas columnas para ignorarlas. Para obtener más información, consulte [Reglas y acciones de transformación](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.md).

## Colaciones EBCDIC en PostgreSQL para el servicio de modernización de mainframe AWS
<a name="CHAP_Source.DB2zOS.EBCDIC"></a>

AWS El programa de modernización de mainframe le ayuda a modernizar sus aplicaciones de mainframe para convertirlas en entornos de tiempo de ejecución gestionados. AWS Ofrece herramientas y recursos para ayudarle a planificar e implementar los proyectos de migración y modernización. [Para obtener más información sobre la modernización y migración de mainframes, consulte Modernización de mainframes con. AWS](https://aws.amazon.com/mainframe/)

Algunos conjuntos de z/OS datos de IBM Db2 están codificados en el juego de caracteres EBCDIC (Extended Binary Coded Decimal Interchange). Se trata de un conjunto de caracteres que se desarrolló antes de que se generalizara el uso de ASCII (American Standard Code for Information Interchange). Una *página de códigos* asigna cada carácter del texto a los caracteres de un conjunto de caracteres. Una página de códigos tradicional contiene la información de asignación entre un punto de código y un ID de carácter. Un *ID de carácter* es una cadena de datos de caracteres de 8 bytes. Un *punto de código* es un número binario de 8 bits que representa un carácter. Los puntos de código se suelen mostrar como representaciones hexadecimales de los valores binarios.

Si actualmente utiliza Micro Focus o BluAge un componente del servicio de modernización del mainframe, debe indicarle que *cambie* (traduzca) AWS DMS determinados puntos del código. Puede utilizar la configuración de las AWS DMS tareas para realizar los turnos. El siguiente ejemplo muestra cómo utilizar la AWS DMS `CharacterSetSettings` operación para mapear los turnos en una configuración de tareas de DMS.

```
"CharacterSetSettings": {
        "CharacterSetSupport": null,
        "CharacterReplacements": [
{"SourceCharacterCodePoint": "0000","TargetCharacterCodePoint": "0180"}
,{"SourceCharacterCodePoint": "00B8","TargetCharacterCodePoint": "0160"}
,{"SourceCharacterCodePoint": "00BC","TargetCharacterCodePoint": "0161"}
,{"SourceCharacterCodePoint": "00BD","TargetCharacterCodePoint": "017D"}
,{"SourceCharacterCodePoint": "00BE","TargetCharacterCodePoint": "017E"}
,{"SourceCharacterCodePoint": "00A8","TargetCharacterCodePoint": "0152"}
,{"SourceCharacterCodePoint": "00B4","TargetCharacterCodePoint": "0153"}
,{"SourceCharacterCodePoint": "00A6","TargetCharacterCodePoint": "0178"}
            }
        ]
    }
```

Ya existen algunas intercalaciones EBCDIC para PostgreSQL que comprenden el cambio que se necesita. Se admiten varias páginas de código diferentes. Las siguientes secciones proporcionan ejemplos de JSON de lo que debe cambiar para todas las páginas de códigos compatibles. Puede simplificar copy-and-past el JSON necesario para su tarea de DMS.

### Intercalaciones EBCDIC específicas de Micro Focus
<a name="CHAP_Source.DB2zOS.EBCDIC.MicroFocus"></a>

Para Micro Focus, cambie un subconjunto de caracteres según sea necesario para las siguientes intercalaciones.

```
 da-DK-cp1142m-x-icu
 de-DE-cp1141m-x-icu
 en-GB-cp1146m-x-icu
 en-US-cp1140m-x-icu
 es-ES-cp1145m-x-icu
 fi-FI-cp1143m-x-icu
 fr-FR-cp1147m-x-icu
 it-IT-cp1144m-x-icu
 nl-BE-cp1148m-x-icu
```

**Example Los datos de Micro Focus cambian por intercalación:**  
**en\$1us\$1cp1140m**  
Cambio de código:  

```
0000    0180
00A6    0160
00B8    0161
00BC    017D
00BD    017E
00BE    0152
00A8    0153
00B4    0178
```
Mapeo de entrada correspondiente a una AWS DMS tarea:  

```
 {"SourceCharacterCodePoint": "0000","TargetCharacterCodePoint": "0180"}
,{"SourceCharacterCodePoint": "00A6","TargetCharacterCodePoint": "0160"}
,{"SourceCharacterCodePoint": "00B8","TargetCharacterCodePoint": "0161"}
,{"SourceCharacterCodePoint": "00BC","TargetCharacterCodePoint": "017D"}
,{"SourceCharacterCodePoint": "00BD","TargetCharacterCodePoint": "017E"}
,{"SourceCharacterCodePoint": "00BE","TargetCharacterCodePoint": "0152"}
,{"SourceCharacterCodePoint": "00A8","TargetCharacterCodePoint": "0153"}
,{"SourceCharacterCodePoint": "00B4","TargetCharacterCodePoint": "0178"}
```
**en\$1us\$1cp1141m**  
Cambio de código:  

```
0000    0180
00B8    0160
00BC    0161
00BD    017D
00BE    017E
00A8    0152
00B4    0153
00A6    0178
```
Mapeo de entrada correspondiente a una AWS DMS tarea:  

```
 {"SourceCharacterCodePoint": "0000","TargetCharacterCodePoint": "0180"}
,{"SourceCharacterCodePoint": "00B8","TargetCharacterCodePoint": "0160"}
,{"SourceCharacterCodePoint": "00BC","TargetCharacterCodePoint": "0161"}
,{"SourceCharacterCodePoint": "00BD","TargetCharacterCodePoint": "017D"}
,{"SourceCharacterCodePoint": "00BE","TargetCharacterCodePoint": "017E"}
,{"SourceCharacterCodePoint": "00A8","TargetCharacterCodePoint": "0152"}
,{"SourceCharacterCodePoint": "00B4","TargetCharacterCodePoint": "0153"}
,{"SourceCharacterCodePoint": "00A6","TargetCharacterCodePoint": "0178"}
```
**en\$1us\$1cp1142m**  
Cambio de código:  

```
0000    0180
00A6    0160
00B8    0161
00BC    017D
00BD    017E
00BE    0152
00A8    0153
00B4    0178
```
Mapeo de entrada correspondiente a una AWS DMS tarea:  

```
 {"SourceCharacterCodePoint": "0000","TargetCharacterCodePoint": "0180"}
,{"SourceCharacterCodePoint": "00A6","TargetCharacterCodePoint": "0160"}
,{"SourceCharacterCodePoint": "00B8","TargetCharacterCodePoint": "0161"}
,{"SourceCharacterCodePoint": "00BC","TargetCharacterCodePoint": "017D"}
,{"SourceCharacterCodePoint": "00BD","TargetCharacterCodePoint": "017E"}
,{"SourceCharacterCodePoint": "00BE","TargetCharacterCodePoint": "0152"}
,{"SourceCharacterCodePoint": "00A8","TargetCharacterCodePoint": "0153"}
,{"SourceCharacterCodePoint": "00B4","TargetCharacterCodePoint": "0178"}
```
**en\$1us\$1cp1143m**  
Cambio de código:  

```
0000    0180
00B8    0160
00BC    0161
00BD    017D
00BE    017E
00A8    0152
00B4    0153
00A6    0178
```
Mapeo de entrada correspondiente a una AWS DMS tarea:  

```
 {"SourceCharacterCodePoint": "0000","TargetCharacterCodePoint": "0180"}
,{"SourceCharacterCodePoint": "00B8","TargetCharacterCodePoint": "0160"}
,{"SourceCharacterCodePoint": "00BC","TargetCharacterCodePoint": "0161"}
,{"SourceCharacterCodePoint": "00BD","TargetCharacterCodePoint": "017D"}
,{"SourceCharacterCodePoint": "00BE","TargetCharacterCodePoint": "017E"}
,{"SourceCharacterCodePoint": "00A8","TargetCharacterCodePoint": "0152"}
,{"SourceCharacterCodePoint": "00B4","TargetCharacterCodePoint": "0153"}
,{"SourceCharacterCodePoint": "00A6","TargetCharacterCodePoint": "0178"}
```
**en\$1us\$1cp1144m**  
Cambio de código:  

```
0000    0180
00B8    0160
00BC    0161
00BD    017D
00BE    017E
00A8    0152
00B4    0153
00A6    0178
```
Mapeo de entrada correspondiente a una AWS DMS tarea:  

```
 {"SourceCharacterCodePoint": "0000","TargetCharacterCodePoint": "0180"}
,{"SourceCharacterCodePoint": "00B8","TargetCharacterCodePoint": "0160"}
,{"SourceCharacterCodePoint": "00BC","TargetCharacterCodePoint": "0161"}
,{"SourceCharacterCodePoint": "00BD","TargetCharacterCodePoint": "017D"}
,{"SourceCharacterCodePoint": "00BE","TargetCharacterCodePoint": "017E"}
,{"SourceCharacterCodePoint": "00A8","TargetCharacterCodePoint": "0152"}
,{"SourceCharacterCodePoint": "00B4","TargetCharacterCodePoint": "0153"}
,{"SourceCharacterCodePoint": "00A6","TargetCharacterCodePoint": "0178"}
```
**en\$1us\$1cp1145m**  
Cambio de código:  

```
0000    0180
00A6    0160
00B8    0161
00A8    017D
00BC    017E
00BD    0152
00BE    0153
00B4    0178
```
Mapeo de entrada correspondiente a una AWS DMS tarea:  

```
 {"SourceCharacterCodePoint": "0000","TargetCharacterCodePoint": "0180"}
,{"SourceCharacterCodePoint": "00A6","TargetCharacterCodePoint": "0160"}
,{"SourceCharacterCodePoint": "00B8","TargetCharacterCodePoint": "0161"}
,{"SourceCharacterCodePoint": "00A8","TargetCharacterCodePoint": "017D"}
,{"SourceCharacterCodePoint": "00BC","TargetCharacterCodePoint": "017E"}
,{"SourceCharacterCodePoint": "00BD","TargetCharacterCodePoint": "0152"}
,{"SourceCharacterCodePoint": "00BE","TargetCharacterCodePoint": "0153"}
,{"SourceCharacterCodePoint": "00B4","TargetCharacterCodePoint": "0178"}
```
**en\$1us\$1cp1146m**  
Cambio de código:  

```
0000    0180
00A6    0160
00B8    0161
00BC    017D
00BD    017E
00BE    0152
00A8    0153
00B4    0178
```
Mapeo de entrada correspondiente a una AWS DMS tarea:  

```
 {"SourceCharacterCodePoint": "0000","TargetCharacterCodePoint": "0180"}
,{"SourceCharacterCodePoint": "00A6","TargetCharacterCodePoint": "0160"}
,{"SourceCharacterCodePoint": "00B8","TargetCharacterCodePoint": "0161"}
,{"SourceCharacterCodePoint": "00BC","TargetCharacterCodePoint": "017D"}
,{"SourceCharacterCodePoint": "00BD","TargetCharacterCodePoint": "017E"}
,{"SourceCharacterCodePoint": "00BE","TargetCharacterCodePoint": "0152"}
,{"SourceCharacterCodePoint": "00A8","TargetCharacterCodePoint": "0153"}
,{"SourceCharacterCodePoint": "00B4","TargetCharacterCodePoint": "0178"}
```
**en\$1us\$1cp1147m**  
Cambio de código:  

```
0000    0180
00B8    0160
00A8    0161
00BC    017D
00BD    017E
00BE    0152
00B4    0153
00A6    0178
```
Mapeo de entrada correspondiente a una AWS DMS tarea:  

```
 {"SourceCharacterCodePoint": "0000","TargetCharacterCodePoint": "0180"}
,{"SourceCharacterCodePoint": "00B8","TargetCharacterCodePoint": "0160"}
,{"SourceCharacterCodePoint": "00A8","TargetCharacterCodePoint": "0161"}
,{"SourceCharacterCodePoint": "00BC","TargetCharacterCodePoint": "017D"}
,{"SourceCharacterCodePoint": "00BD","TargetCharacterCodePoint": "017E"}
,{"SourceCharacterCodePoint": "00BE","TargetCharacterCodePoint": "0152"}
,{"SourceCharacterCodePoint": "00B4","TargetCharacterCodePoint": "0153"}
,{"SourceCharacterCodePoint": "00A6","TargetCharacterCodePoint": "0178"}
```
**en\$1us\$1cp1148m**  
Cambio de código:  

```
0000    0180
00A6    0160
00B8    0161
00BC    017D
00BD    017E
00BE    0152
00A8    0153
00B4    0178
```
Mapeo de entrada correspondiente a una AWS DMS tarea:  

```
 {"SourceCharacterCodePoint": "0000","TargetCharacterCodePoint": "0180"}
,{"SourceCharacterCodePoint": "00A6","TargetCharacterCodePoint": "0160"}
,{"SourceCharacterCodePoint": "00B8","TargetCharacterCodePoint": "0161"}
,{"SourceCharacterCodePoint": "00BC","TargetCharacterCodePoint": "017D"}
,{"SourceCharacterCodePoint": "00BD","TargetCharacterCodePoint": "017E"}
,{"SourceCharacterCodePoint": "00BE","TargetCharacterCodePoint": "0152"}
,{"SourceCharacterCodePoint": "00A8","TargetCharacterCodePoint": "0153"}
,{"SourceCharacterCodePoint": "00B4","TargetCharacterCodePoint": "0178"}
```

### BluAge recopilaciones EBCDIC específicas
<a name="CHAP_Source.DB2zOS.EBCDIC.BluAge"></a>

Para BluAge, cambie todos los siguientes *valores bajos* y *altos* según sea necesario. Estas recopilaciones solo deben usarse para respaldar el servicio de migración BluAge de mainframe.

```
da-DK-cp1142b-x-icu
 da-DK-cp277b-x-icu
 de-DE-cp1141b-x-icu
 de-DE-cp273b-x-icu
 en-GB-cp1146b-x-icu
 en-GB-cp285b-x-icu
 en-US-cp037b-x-icu
 en-US-cp1140b-x-icu
 es-ES-cp1145b-x-icu
 es-ES-cp284b-x-icu
 fi-FI-cp1143b-x-icu
 fi-FI-cp278b-x-icu 
 fr-FR-cp1147b-x-icu
 fr-FR-cp297b-x-icu
 it-IT-cp1144b-x-icu
 it-IT-cp280b-x-icu
 nl-BE-cp1148b-x-icu
 nl-BE-cp500b-x-icu
```

**Example BluAge Cambios de datos:**  
**DA-DK-CP277b y **DA-DK-CP1142b****  
Cambio de código:  

```
0180    0180
0001    0181
0002    0182
0003    0183
009C    0184
0009    0185
0086    0186
007F    0187
0097    0188
008D    0189
008E    018A
000B    018B
000C    018C
000D    018D
000E    018E
000F    018F
0010    0190
0011    0191
0012    0192
0013    0193
009D    0194
0085    0195
0008    0196
0087    0197
0018    0198
0019    0199
0092    019A
008F    019B
001C    019C
001D    019D
001E    019E
001F    019F
0080    01A0
0081    01A1
0082    01A2
0083    01A3
0084    01A4
000A    01A5
0017    01A6
001B    01A7
0088    01A8
0089    01A9
008A    01AA
008B    01AB
008C    01AC
0005    01AD
0006    01AE
0007    01AF
0090    01B0
0091    01B1
0016    01B2
0093    01B3
0094    01B4
0095    01B5
0096    01B6
0004    01B7
0098    01B8
0099    01B9
009A    01BA
009B    01BB
0014    01BC
0015    01BD
009E    01BE
001A    01BF
009F    027F
```
Mapeo de entrada correspondiente a una AWS DMS tarea:  

```
 {"SourceCharacterCodePoint": "0180","TargetCharacterCodePoint": "0180"}
,{"SourceCharacterCodePoint": "0001","TargetCharacterCodePoint": "0181"}
,{"SourceCharacterCodePoint": "0002","TargetCharacterCodePoint": "0182"}
,{"SourceCharacterCodePoint": "0003","TargetCharacterCodePoint": "0183"}
,{"SourceCharacterCodePoint": "009C","TargetCharacterCodePoint": "0184"}
,{"SourceCharacterCodePoint": "0009","TargetCharacterCodePoint": "0185"}
,{"SourceCharacterCodePoint": "0086","TargetCharacterCodePoint": "0186"}
,{"SourceCharacterCodePoint": "007F","TargetCharacterCodePoint": "0187"}
,{"SourceCharacterCodePoint": "0097","TargetCharacterCodePoint": "0188"}
,{"SourceCharacterCodePoint": "008D","TargetCharacterCodePoint": "0189"}
,{"SourceCharacterCodePoint": "008E","TargetCharacterCodePoint": "018A"}
,{"SourceCharacterCodePoint": "000B","TargetCharacterCodePoint": "018B"}
,{"SourceCharacterCodePoint": "000C","TargetCharacterCodePoint": "018C"}
,{"SourceCharacterCodePoint": "000D","TargetCharacterCodePoint": "018D"}
,{"SourceCharacterCodePoint": "000E","TargetCharacterCodePoint": "018E"}
,{"SourceCharacterCodePoint": "000F","TargetCharacterCodePoint": "018F"}
,{"SourceCharacterCodePoint": "0010","TargetCharacterCodePoint": "0190"}
,{"SourceCharacterCodePoint": "0011","TargetCharacterCodePoint": "0191"}
,{"SourceCharacterCodePoint": "0012","TargetCharacterCodePoint": "0192"}
,{"SourceCharacterCodePoint": "0013","TargetCharacterCodePoint": "0193"}
,{"SourceCharacterCodePoint": "009D","TargetCharacterCodePoint": "0194"}
,{"SourceCharacterCodePoint": "0085","TargetCharacterCodePoint": "0195"}
,{"SourceCharacterCodePoint": "0008","TargetCharacterCodePoint": "0196"}
,{"SourceCharacterCodePoint": "0087","TargetCharacterCodePoint": "0197"}
,{"SourceCharacterCodePoint": "0018","TargetCharacterCodePoint": "0198"}
,{"SourceCharacterCodePoint": "0019","TargetCharacterCodePoint": "0199"}
,{"SourceCharacterCodePoint": "0092","TargetCharacterCodePoint": "019A"}
,{"SourceCharacterCodePoint": "008F","TargetCharacterCodePoint": "019B"}
,{"SourceCharacterCodePoint": "001C","TargetCharacterCodePoint": "019C"}
,{"SourceCharacterCodePoint": "001D","TargetCharacterCodePoint": "019D"}
,{"SourceCharacterCodePoint": "001E","TargetCharacterCodePoint": "019E"}
,{"SourceCharacterCodePoint": "001F","TargetCharacterCodePoint": "019F"}
,{"SourceCharacterCodePoint": "0080","TargetCharacterCodePoint": "01A0"}
,{"SourceCharacterCodePoint": "0081","TargetCharacterCodePoint": "01A1"}
,{"SourceCharacterCodePoint": "0082","TargetCharacterCodePoint": "01A2"}
,{"SourceCharacterCodePoint": "0083","TargetCharacterCodePoint": "01A3"}
,{"SourceCharacterCodePoint": "0084","TargetCharacterCodePoint": "01A4"}
,{"SourceCharacterCodePoint": "000A","TargetCharacterCodePoint": "01A5"}
,{"SourceCharacterCodePoint": "0017","TargetCharacterCodePoint": "01A6"}
,{"SourceCharacterCodePoint": "001B","TargetCharacterCodePoint": "01A7"}
,{"SourceCharacterCodePoint": "0088","TargetCharacterCodePoint": "01A8"}
,{"SourceCharacterCodePoint": "0089","TargetCharacterCodePoint": "01A9"}
,{"SourceCharacterCodePoint": "008A","TargetCharacterCodePoint": "01AA"}
,{"SourceCharacterCodePoint": "008B","TargetCharacterCodePoint": "01AB"}
,{"SourceCharacterCodePoint": "008C","TargetCharacterCodePoint": "01AC"}
,{"SourceCharacterCodePoint": "0005","TargetCharacterCodePoint": "01AD"}
,{"SourceCharacterCodePoint": "0006","TargetCharacterCodePoint": "01AE"}
,{"SourceCharacterCodePoint": "0007","TargetCharacterCodePoint": "01AF"}
,{"SourceCharacterCodePoint": "0090","TargetCharacterCodePoint": "01B0"}
,{"SourceCharacterCodePoint": "0091","TargetCharacterCodePoint": "01B1"}
,{"SourceCharacterCodePoint": "0016","TargetCharacterCodePoint": "01B2"}
,{"SourceCharacterCodePoint": "0093","TargetCharacterCodePoint": "01B3"}
,{"SourceCharacterCodePoint": "0094","TargetCharacterCodePoint": "01B4"}
,{"SourceCharacterCodePoint": "0095","TargetCharacterCodePoint": "01B5"}
,{"SourceCharacterCodePoint": "0096","TargetCharacterCodePoint": "01B6"}
,{"SourceCharacterCodePoint": "0004","TargetCharacterCodePoint": "01B7"}
,{"SourceCharacterCodePoint": "0098","TargetCharacterCodePoint": "01B8"}
,{"SourceCharacterCodePoint": "0099","TargetCharacterCodePoint": "01B9"}
,{"SourceCharacterCodePoint": "009A","TargetCharacterCodePoint": "01BA"}
,{"SourceCharacterCodePoint": "009B","TargetCharacterCodePoint": "01BB"}
,{"SourceCharacterCodePoint": "0014","TargetCharacterCodePoint": "01BC"}
,{"SourceCharacterCodePoint": "0015","TargetCharacterCodePoint": "01BD"}
,{"SourceCharacterCodePoint": "009E","TargetCharacterCodePoint": "01BE"}
,{"SourceCharacterCodePoint": "001A","TargetCharacterCodePoint": "01BF"}
,{"SourceCharacterCodePoint": "009F","TargetCharacterCodePoint": "027F"}
```
**de-DE-273b** y **de-DE-1141b**  
Cambio de código:  

```
0180    0180
0001    0181
0002    0182
0003    0183
009C    0184
0009    0185
0086    0186
007F    0187
0097    0188
008D    0189
008E    018A
000B    018B
000C    018C
000D    018D
000E    018E
000F    018F
0010    0190
0011    0191
0012    0192
0013    0193
009D    0194
0085    0195
0008    0196
0087    0197
0018    0198
0019    0199
0092    019A
008F    019B
001C    019C
001D    019D
001E    019E
001F    019F
0080    01A0
0081    01A1
0082    01A2
0083    01A3
0084    01A4
000A    01A5
0017    01A6
001B    01A7
0088    01A8
0089    01A9
008A    01AA
008B    01AB
008C    01AC
0005    01AD
0006    01AE
0007    01AF
0090    01B0
0091    01B1
0016    01B2
0093    01B3
0094    01B4
0095    01B5
0096    01B6
0004    01B7
0098    01B8
0099    01B9
009A    01BA
009B    01BB
0014    01BC
0015    01BD
009E    01BE
001A    01BF
009F    027F
```
Mapeo de entrada correspondiente a una AWS DMS tarea:  

```
 {"SourceCharacterCodePoint": "0180","TargetCharacterCodePoint": "0180"}
,{"SourceCharacterCodePoint": "0001","TargetCharacterCodePoint": "0181"}
,{"SourceCharacterCodePoint": "0002","TargetCharacterCodePoint": "0182"}
,{"SourceCharacterCodePoint": "0003","TargetCharacterCodePoint": "0183"}
,{"SourceCharacterCodePoint": "009C","TargetCharacterCodePoint": "0184"}
,{"SourceCharacterCodePoint": "0009","TargetCharacterCodePoint": "0185"}
,{"SourceCharacterCodePoint": "0086","TargetCharacterCodePoint": "0186"}
,{"SourceCharacterCodePoint": "007F","TargetCharacterCodePoint": "0187"}
,{"SourceCharacterCodePoint": "0097","TargetCharacterCodePoint": "0188"}
,{"SourceCharacterCodePoint": "008D","TargetCharacterCodePoint": "0189"}
,{"SourceCharacterCodePoint": "008E","TargetCharacterCodePoint": "018A"}
,{"SourceCharacterCodePoint": "000B","TargetCharacterCodePoint": "018B"}
,{"SourceCharacterCodePoint": "000C","TargetCharacterCodePoint": "018C"}
,{"SourceCharacterCodePoint": "000D","TargetCharacterCodePoint": "018D"}
,{"SourceCharacterCodePoint": "000E","TargetCharacterCodePoint": "018E"}
,{"SourceCharacterCodePoint": "000F","TargetCharacterCodePoint": "018F"}
,{"SourceCharacterCodePoint": "0010","TargetCharacterCodePoint": "0190"}
,{"SourceCharacterCodePoint": "0011","TargetCharacterCodePoint": "0191"}
,{"SourceCharacterCodePoint": "0012","TargetCharacterCodePoint": "0192"}
,{"SourceCharacterCodePoint": "0013","TargetCharacterCodePoint": "0193"}
,{"SourceCharacterCodePoint": "009D","TargetCharacterCodePoint": "0194"}
,{"SourceCharacterCodePoint": "0085","TargetCharacterCodePoint": "0195"}
,{"SourceCharacterCodePoint": "0008","TargetCharacterCodePoint": "0196"}
,{"SourceCharacterCodePoint": "0087","TargetCharacterCodePoint": "0197"}
,{"SourceCharacterCodePoint": "0018","TargetCharacterCodePoint": "0198"}
,{"SourceCharacterCodePoint": "0019","TargetCharacterCodePoint": "0199"}
,{"SourceCharacterCodePoint": "0092","TargetCharacterCodePoint": "019A"}
,{"SourceCharacterCodePoint": "008F","TargetCharacterCodePoint": "019B"}
,{"SourceCharacterCodePoint": "001C","TargetCharacterCodePoint": "019C"}
,{"SourceCharacterCodePoint": "001D","TargetCharacterCodePoint": "019D"}
,{"SourceCharacterCodePoint": "001E","TargetCharacterCodePoint": "019E"}
,{"SourceCharacterCodePoint": "001F","TargetCharacterCodePoint": "019F"}
,{"SourceCharacterCodePoint": "0080","TargetCharacterCodePoint": "01A0"}
,{"SourceCharacterCodePoint": "0081","TargetCharacterCodePoint": "01A1"}
,{"SourceCharacterCodePoint": "0082","TargetCharacterCodePoint": "01A2"}
,{"SourceCharacterCodePoint": "0083","TargetCharacterCodePoint": "01A3"}
,{"SourceCharacterCodePoint": "0084","TargetCharacterCodePoint": "01A4"}
,{"SourceCharacterCodePoint": "000A","TargetCharacterCodePoint": "01A5"}
,{"SourceCharacterCodePoint": "0017","TargetCharacterCodePoint": "01A6"}
,{"SourceCharacterCodePoint": "001B","TargetCharacterCodePoint": "01A7"}
,{"SourceCharacterCodePoint": "0088","TargetCharacterCodePoint": "01A8"}
,{"SourceCharacterCodePoint": "0089","TargetCharacterCodePoint": "01A9"}
,{"SourceCharacterCodePoint": "008A","TargetCharacterCodePoint": "01AA"}
,{"SourceCharacterCodePoint": "008B","TargetCharacterCodePoint": "01AB"}
,{"SourceCharacterCodePoint": "008C","TargetCharacterCodePoint": "01AC"}
,{"SourceCharacterCodePoint": "0005","TargetCharacterCodePoint": "01AD"}
,{"SourceCharacterCodePoint": "0006","TargetCharacterCodePoint": "01AE"}
,{"SourceCharacterCodePoint": "0007","TargetCharacterCodePoint": "01AF"}
,{"SourceCharacterCodePoint": "0090","TargetCharacterCodePoint": "01B0"}
,{"SourceCharacterCodePoint": "0091","TargetCharacterCodePoint": "01B1"}
,{"SourceCharacterCodePoint": "0016","TargetCharacterCodePoint": "01B2"}
,{"SourceCharacterCodePoint": "0093","TargetCharacterCodePoint": "01B3"}
,{"SourceCharacterCodePoint": "0094","TargetCharacterCodePoint": "01B4"}
,{"SourceCharacterCodePoint": "0095","TargetCharacterCodePoint": "01B5"}
,{"SourceCharacterCodePoint": "0096","TargetCharacterCodePoint": "01B6"}
,{"SourceCharacterCodePoint": "0004","TargetCharacterCodePoint": "01B7"}
,{"SourceCharacterCodePoint": "0098","TargetCharacterCodePoint": "01B8"}
,{"SourceCharacterCodePoint": "0099","TargetCharacterCodePoint": "01B9"}
,{"SourceCharacterCodePoint": "009A","TargetCharacterCodePoint": "01BA"}
,{"SourceCharacterCodePoint": "009B","TargetCharacterCodePoint": "01BB"}
,{"SourceCharacterCodePoint": "0014","TargetCharacterCodePoint": "01BC"}
,{"SourceCharacterCodePoint": "0015","TargetCharacterCodePoint": "01BD"}
,{"SourceCharacterCodePoint": "009E","TargetCharacterCodePoint": "01BE"}
,{"SourceCharacterCodePoint": "001A","TargetCharacterCodePoint": "01BF"}
,{"SourceCharacterCodePoint": "009F","TargetCharacterCodePoint": "027F"}
```
**en-GB-285b** y **en-GB-1146b**  
Cambio de código:  

```
0180    0180
0001    0181
0002    0182
0003    0183
009C    0184
0009    0185
0086    0186
007F    0187
0097    0188
008D    0189
008E    018A
000B    018B
000C    018C
000D    018D
000E    018E
000F    018F
0010    0190
0011    0191
0012    0192
0013    0193
009D    0194
0085    0195
0008    0196
0087    0197
0018    0198
0019    0199
0092    019A
008F    019B
001C    019C
001D    019D
001E    019E
001F    019F
0080    01A0
0081    01A1
0082    01A2
0083    01A3
0084    01A4
000A    01A5
0017    01A6
001B    01A7
0088    01A8
0089    01A9
008A    01AA
008B    01AB
008C    01AC
0005    01AD
0006    01AE
0007    01AF
0090    01B0
0091    01B1
0016    01B2
0093    01B3
0094    01B4
0095    01B5
0096    01B6
0004    01B7
0098    01B8
0099    01B9
009A    01BA
009B    01BB
0014    01BC
0015    01BD
009E    01BE
001A    01BF
009F    027F
```
Mapeo de entrada correspondiente a una AWS DMS tarea:  

```
{"SourceCharacterCodePoint": "0180","TargetCharacterCodePoint": "0180"}
,{"SourceCharacterCodePoint": "0001","TargetCharacterCodePoint": "0181"}
,{"SourceCharacterCodePoint": "0002","TargetCharacterCodePoint": "0182"}
,{"SourceCharacterCodePoint": "0003","TargetCharacterCodePoint": "0183"}
,{"SourceCharacterCodePoint": "009C","TargetCharacterCodePoint": "0184"}
,{"SourceCharacterCodePoint": "0009","TargetCharacterCodePoint": "0185"}
,{"SourceCharacterCodePoint": "0086","TargetCharacterCodePoint": "0186"}
,{"SourceCharacterCodePoint": "007F","TargetCharacterCodePoint": "0187"}
,{"SourceCharacterCodePoint": "0097","TargetCharacterCodePoint": "0188"}
,{"SourceCharacterCodePoint": "008D","TargetCharacterCodePoint": "0189"}
,{"SourceCharacterCodePoint": "008E","TargetCharacterCodePoint": "018A"}
,{"SourceCharacterCodePoint": "000B","TargetCharacterCodePoint": "018B"}
,{"SourceCharacterCodePoint": "000C","TargetCharacterCodePoint": "018C"}
,{"SourceCharacterCodePoint": "000D","TargetCharacterCodePoint": "018D"}
,{"SourceCharacterCodePoint": "000E","TargetCharacterCodePoint": "018E"}
,{"SourceCharacterCodePoint": "000F","TargetCharacterCodePoint": "018F"}
,{"SourceCharacterCodePoint": "0010","TargetCharacterCodePoint": "0190"}
,{"SourceCharacterCodePoint": "0011","TargetCharacterCodePoint": "0191"}
,{"SourceCharacterCodePoint": "0012","TargetCharacterCodePoint": "0192"}
,{"SourceCharacterCodePoint": "0013","TargetCharacterCodePoint": "0193"}
,{"SourceCharacterCodePoint": "009D","TargetCharacterCodePoint": "0194"}
,{"SourceCharacterCodePoint": "0085","TargetCharacterCodePoint": "0195"}
,{"SourceCharacterCodePoint": "0008","TargetCharacterCodePoint": "0196"}
,{"SourceCharacterCodePoint": "0087","TargetCharacterCodePoint": "0197"}
,{"SourceCharacterCodePoint": "0018","TargetCharacterCodePoint": "0198"}
,{"SourceCharacterCodePoint": "0019","TargetCharacterCodePoint": "0199"}
,{"SourceCharacterCodePoint": "0092","TargetCharacterCodePoint": "019A"}
,{"SourceCharacterCodePoint": "008F","TargetCharacterCodePoint": "019B"}
,{"SourceCharacterCodePoint": "001C","TargetCharacterCodePoint": "019C"}
,{"SourceCharacterCodePoint": "001D","TargetCharacterCodePoint": "019D"}
,{"SourceCharacterCodePoint": "001E","TargetCharacterCodePoint": "019E"}
,{"SourceCharacterCodePoint": "001F","TargetCharacterCodePoint": "019F"}
,{"SourceCharacterCodePoint": "0080","TargetCharacterCodePoint": "01A0"}
,{"SourceCharacterCodePoint": "0081","TargetCharacterCodePoint": "01A1"}
,{"SourceCharacterCodePoint": "0082","TargetCharacterCodePoint": "01A2"}
,{"SourceCharacterCodePoint": "0083","TargetCharacterCodePoint": "01A3"}
,{"SourceCharacterCodePoint": "0084","TargetCharacterCodePoint": "01A4"}
,{"SourceCharacterCodePoint": "000A","TargetCharacterCodePoint": "01A5"}
,{"SourceCharacterCodePoint": "0017","TargetCharacterCodePoint": "01A6"}
,{"SourceCharacterCodePoint": "001B","TargetCharacterCodePoint": "01A7"}
,{"SourceCharacterCodePoint": "0088","TargetCharacterCodePoint": "01A8"}
,{"SourceCharacterCodePoint": "0089","TargetCharacterCodePoint": "01A9"}
,{"SourceCharacterCodePoint": "008A","TargetCharacterCodePoint": "01AA"}
,{"SourceCharacterCodePoint": "008B","TargetCharacterCodePoint": "01AB"}
,{"SourceCharacterCodePoint": "008C","TargetCharacterCodePoint": "01AC"}
,{"SourceCharacterCodePoint": "0005","TargetCharacterCodePoint": "01AD"}
,{"SourceCharacterCodePoint": "0006","TargetCharacterCodePoint": "01AE"}
,{"SourceCharacterCodePoint": "0007","TargetCharacterCodePoint": "01AF"}
,{"SourceCharacterCodePoint": "0090","TargetCharacterCodePoint": "01B0"}
,{"SourceCharacterCodePoint": "0091","TargetCharacterCodePoint": "01B1"}
,{"SourceCharacterCodePoint": "0016","TargetCharacterCodePoint": "01B2"}
,{"SourceCharacterCodePoint": "0093","TargetCharacterCodePoint": "01B3"}
,{"SourceCharacterCodePoint": "0094","TargetCharacterCodePoint": "01B4"}
,{"SourceCharacterCodePoint": "0095","TargetCharacterCodePoint": "01B5"}
,{"SourceCharacterCodePoint": "0096","TargetCharacterCodePoint": "01B6"}
,{"SourceCharacterCodePoint": "0004","TargetCharacterCodePoint": "01B7"}
,{"SourceCharacterCodePoint": "0098","TargetCharacterCodePoint": "01B8"}
,{"SourceCharacterCodePoint": "0099","TargetCharacterCodePoint": "01B9"}
,{"SourceCharacterCodePoint": "009A","TargetCharacterCodePoint": "01BA"}
,{"SourceCharacterCodePoint": "009B","TargetCharacterCodePoint": "01BB"}
,{"SourceCharacterCodePoint": "0014","TargetCharacterCodePoint": "01BC"}
,{"SourceCharacterCodePoint": "0015","TargetCharacterCodePoint": "01BD"}
,{"SourceCharacterCodePoint": "009E","TargetCharacterCodePoint": "01BE"}
,{"SourceCharacterCodePoint": "001A","TargetCharacterCodePoint": "01BF"}
,{"SourceCharacterCodePoint": "009F","TargetCharacterCodePoint": "027F"}
```
**en-us-037b** y **en-us-1140b**  
Cambio de código:  

```
0180    0180
0001    0181
0002    0182
0003    0183
009C    0184
0009    0185
0086    0186
007F    0187
0097    0188
008D    0189
008E    018A
000B    018B
000C    018C
000D    018D
000E    018E
000F    018F
0010    0190
0011    0191
0012    0192
0013    0193
009D    0194
0085    0195
0008    0196
0087    0197
0018    0198
0019    0199
0092    019A
008F    019B
001C    019C
001D    019D
001E    019E
001F    019F
0080    01A0
0081    01A1
0082    01A2
0083    01A3
0084    01A4
000A    01A5
0017    01A6
001B    01A7
0088    01A8
0089    01A9
008A    01AA
008B    01AB
008C    01AC
0005    01AD
0006    01AE
0007    01AF
0090    01B0
0091    01B1
0016    01B2
0093    01B3
0094    01B4
0095    01B5
0096    01B6
0004    01B7
0098    01B8
0099    01B9
009A    01BA
009B    01BB
0014    01BC
0015    01BD
009E    01BE
001A    01BF
009F    027F
```
Mapeo de entrada correspondiente a una AWS DMS tarea:  

```
{"SourceCharacterCodePoint": "0180","TargetCharacterCodePoint": "0180"}
,{"SourceCharacterCodePoint": "0001","TargetCharacterCodePoint": "0181"}
,{"SourceCharacterCodePoint": "0002","TargetCharacterCodePoint": "0182"}
,{"SourceCharacterCodePoint": "0003","TargetCharacterCodePoint": "0183"}
,{"SourceCharacterCodePoint": "009C","TargetCharacterCodePoint": "0184"}
,{"SourceCharacterCodePoint": "0009","TargetCharacterCodePoint": "0185"}
,{"SourceCharacterCodePoint": "0086","TargetCharacterCodePoint": "0186"}
,{"SourceCharacterCodePoint": "007F","TargetCharacterCodePoint": "0187"}
,{"SourceCharacterCodePoint": "0097","TargetCharacterCodePoint": "0188"}
,{"SourceCharacterCodePoint": "008D","TargetCharacterCodePoint": "0189"}
,{"SourceCharacterCodePoint": "008E","TargetCharacterCodePoint": "018A"}
,{"SourceCharacterCodePoint": "000B","TargetCharacterCodePoint": "018B"}
,{"SourceCharacterCodePoint": "000C","TargetCharacterCodePoint": "018C"}
,{"SourceCharacterCodePoint": "000D","TargetCharacterCodePoint": "018D"}
,{"SourceCharacterCodePoint": "000E","TargetCharacterCodePoint": "018E"}
,{"SourceCharacterCodePoint": "000F","TargetCharacterCodePoint": "018F"}
,{"SourceCharacterCodePoint": "0010","TargetCharacterCodePoint": "0190"}
,{"SourceCharacterCodePoint": "0011","TargetCharacterCodePoint": "0191"}
,{"SourceCharacterCodePoint": "0012","TargetCharacterCodePoint": "0192"}
,{"SourceCharacterCodePoint": "0013","TargetCharacterCodePoint": "0193"}
,{"SourceCharacterCodePoint": "009D","TargetCharacterCodePoint": "0194"}
,{"SourceCharacterCodePoint": "0085","TargetCharacterCodePoint": "0195"}
,{"SourceCharacterCodePoint": "0008","TargetCharacterCodePoint": "0196"}
,{"SourceCharacterCodePoint": "0087","TargetCharacterCodePoint": "0197"}
,{"SourceCharacterCodePoint": "0018","TargetCharacterCodePoint": "0198"}
,{"SourceCharacterCodePoint": "0019","TargetCharacterCodePoint": "0199"}
,{"SourceCharacterCodePoint": "0092","TargetCharacterCodePoint": "019A"}
,{"SourceCharacterCodePoint": "008F","TargetCharacterCodePoint": "019B"}
,{"SourceCharacterCodePoint": "001C","TargetCharacterCodePoint": "019C"}
,{"SourceCharacterCodePoint": "001D","TargetCharacterCodePoint": "019D"}
,{"SourceCharacterCodePoint": "001E","TargetCharacterCodePoint": "019E"}
,{"SourceCharacterCodePoint": "001F","TargetCharacterCodePoint": "019F"}
,{"SourceCharacterCodePoint": "0080","TargetCharacterCodePoint": "01A0"}
,{"SourceCharacterCodePoint": "0081","TargetCharacterCodePoint": "01A1"}
,{"SourceCharacterCodePoint": "0082","TargetCharacterCodePoint": "01A2"}
,{"SourceCharacterCodePoint": "0083","TargetCharacterCodePoint": "01A3"}
,{"SourceCharacterCodePoint": "0084","TargetCharacterCodePoint": "01A4"}
,{"SourceCharacterCodePoint": "000A","TargetCharacterCodePoint": "01A5"}
,{"SourceCharacterCodePoint": "0017","TargetCharacterCodePoint": "01A6"}
,{"SourceCharacterCodePoint": "001B","TargetCharacterCodePoint": "01A7"}
,{"SourceCharacterCodePoint": "0088","TargetCharacterCodePoint": "01A8"}
,{"SourceCharacterCodePoint": "0089","TargetCharacterCodePoint": "01A9"}
,{"SourceCharacterCodePoint": "008A","TargetCharacterCodePoint": "01AA"}
,{"SourceCharacterCodePoint": "008B","TargetCharacterCodePoint": "01AB"}
,{"SourceCharacterCodePoint": "008C","TargetCharacterCodePoint": "01AC"}
,{"SourceCharacterCodePoint": "0005","TargetCharacterCodePoint": "01AD"}
,{"SourceCharacterCodePoint": "0006","TargetCharacterCodePoint": "01AE"}
,{"SourceCharacterCodePoint": "0007","TargetCharacterCodePoint": "01AF"}
,{"SourceCharacterCodePoint": "0090","TargetCharacterCodePoint": "01B0"}
,{"SourceCharacterCodePoint": "0091","TargetCharacterCodePoint": "01B1"}
,{"SourceCharacterCodePoint": "0016","TargetCharacterCodePoint": "01B2"}
,{"SourceCharacterCodePoint": "0093","TargetCharacterCodePoint": "01B3"}
,{"SourceCharacterCodePoint": "0094","TargetCharacterCodePoint": "01B4"}
,{"SourceCharacterCodePoint": "0095","TargetCharacterCodePoint": "01B5"}
,{"SourceCharacterCodePoint": "0096","TargetCharacterCodePoint": "01B6"}
,{"SourceCharacterCodePoint": "0004","TargetCharacterCodePoint": "01B7"}
,{"SourceCharacterCodePoint": "0098","TargetCharacterCodePoint": "01B8"}
,{"SourceCharacterCodePoint": "0099","TargetCharacterCodePoint": "01B9"}
,{"SourceCharacterCodePoint": "009A","TargetCharacterCodePoint": "01BA"}
,{"SourceCharacterCodePoint": "009B","TargetCharacterCodePoint": "01BB"}
,{"SourceCharacterCodePoint": "0014","TargetCharacterCodePoint": "01BC"}
,{"SourceCharacterCodePoint": "0015","TargetCharacterCodePoint": "01BD"}
,{"SourceCharacterCodePoint": "009E","TargetCharacterCodePoint": "01BE"}
,{"SourceCharacterCodePoint": "001A","TargetCharacterCodePoint": "01BF"}
,{"SourceCharacterCodePoint": "009F","TargetCharacterCodePoint": "027F"}
```
**es-ES-284b** y **es-ES-1145b**  
Cambio de código:  

```
0180    0180
0001    0181
0002    0182
0003    0183
009C    0184
0009    0185
0086    0186
007F    0187
0097    0188
008D    0189
008E    018A
000B    018B
000C    018C
000D    018D
000E    018E
000F    018F
0010    0190
0011    0191
0012    0192
0013    0193
009D    0194
0085    0195
0008    0196
0087    0197
0018    0198
0019    0199
0092    019A
008F    019B
001C    019C
001D    019D
001E    019E
001F    019F
0080    01A0
0081    01A1
0082    01A2
0083    01A3
0084    01A4
000A    01A5
0017    01A6
001B    01A7
0088    01A8
0089    01A9
008A    01AA
008B    01AB
008C    01AC
0005    01AD
0006    01AE
0007    01AF
0090    01B0
0091    01B1
0016    01B2
0093    01B3
0094    01B4
0095    01B5
0096    01B6
0004    01B7
0098    01B8
0099    01B9
009A    01BA
009B    01BB
0014    01BC
0015    01BD
009E    01BE
001A    01BF
009F    027F
```
Mapeo de entrada correspondiente a una AWS DMS tarea:  

```
 {"SourceCharacterCodePoint": "0180","TargetCharacterCodePoint": "0180"}
,{"SourceCharacterCodePoint": "0001","TargetCharacterCodePoint": "0181"}
,{"SourceCharacterCodePoint": "0002","TargetCharacterCodePoint": "0182"}
,{"SourceCharacterCodePoint": "0003","TargetCharacterCodePoint": "0183"}
,{"SourceCharacterCodePoint": "009C","TargetCharacterCodePoint": "0184"}
,{"SourceCharacterCodePoint": "0009","TargetCharacterCodePoint": "0185"}
,{"SourceCharacterCodePoint": "0086","TargetCharacterCodePoint": "0186"}
,{"SourceCharacterCodePoint": "007F","TargetCharacterCodePoint": "0187"}
,{"SourceCharacterCodePoint": "0097","TargetCharacterCodePoint": "0188"}
,{"SourceCharacterCodePoint": "008D","TargetCharacterCodePoint": "0189"}
,{"SourceCharacterCodePoint": "008E","TargetCharacterCodePoint": "018A"}
,{"SourceCharacterCodePoint": "000B","TargetCharacterCodePoint": "018B"}
,{"SourceCharacterCodePoint": "000C","TargetCharacterCodePoint": "018C"}
,{"SourceCharacterCodePoint": "000D","TargetCharacterCodePoint": "018D"}
,{"SourceCharacterCodePoint": "000E","TargetCharacterCodePoint": "018E"}
,{"SourceCharacterCodePoint": "000F","TargetCharacterCodePoint": "018F"}
,{"SourceCharacterCodePoint": "0010","TargetCharacterCodePoint": "0190"}
,{"SourceCharacterCodePoint": "0011","TargetCharacterCodePoint": "0191"}
,{"SourceCharacterCodePoint": "0012","TargetCharacterCodePoint": "0192"}
,{"SourceCharacterCodePoint": "0013","TargetCharacterCodePoint": "0193"}
,{"SourceCharacterCodePoint": "009D","TargetCharacterCodePoint": "0194"}
,{"SourceCharacterCodePoint": "0085","TargetCharacterCodePoint": "0195"}
,{"SourceCharacterCodePoint": "0008","TargetCharacterCodePoint": "0196"}
,{"SourceCharacterCodePoint": "0087","TargetCharacterCodePoint": "0197"}
,{"SourceCharacterCodePoint": "0018","TargetCharacterCodePoint": "0198"}
,{"SourceCharacterCodePoint": "0019","TargetCharacterCodePoint": "0199"}
,{"SourceCharacterCodePoint": "0092","TargetCharacterCodePoint": "019A"}
,{"SourceCharacterCodePoint": "008F","TargetCharacterCodePoint": "019B"}
,{"SourceCharacterCodePoint": "001C","TargetCharacterCodePoint": "019C"}
,{"SourceCharacterCodePoint": "001D","TargetCharacterCodePoint": "019D"}
,{"SourceCharacterCodePoint": "001E","TargetCharacterCodePoint": "019E"}
,{"SourceCharacterCodePoint": "001F","TargetCharacterCodePoint": "019F"}
,{"SourceCharacterCodePoint": "0080","TargetCharacterCodePoint": "01A0"}
,{"SourceCharacterCodePoint": "0081","TargetCharacterCodePoint": "01A1"}
,{"SourceCharacterCodePoint": "0082","TargetCharacterCodePoint": "01A2"}
,{"SourceCharacterCodePoint": "0083","TargetCharacterCodePoint": "01A3"}
,{"SourceCharacterCodePoint": "0084","TargetCharacterCodePoint": "01A4"}
,{"SourceCharacterCodePoint": "000A","TargetCharacterCodePoint": "01A5"}
,{"SourceCharacterCodePoint": "0017","TargetCharacterCodePoint": "01A6"}
,{"SourceCharacterCodePoint": "001B","TargetCharacterCodePoint": "01A7"}
,{"SourceCharacterCodePoint": "0088","TargetCharacterCodePoint": "01A8"}
,{"SourceCharacterCodePoint": "0089","TargetCharacterCodePoint": "01A9"}
,{"SourceCharacterCodePoint": "008A","TargetCharacterCodePoint": "01AA"}
,{"SourceCharacterCodePoint": "008B","TargetCharacterCodePoint": "01AB"}
,{"SourceCharacterCodePoint": "008C","TargetCharacterCodePoint": "01AC"}
,{"SourceCharacterCodePoint": "0005","TargetCharacterCodePoint": "01AD"}
,{"SourceCharacterCodePoint": "0006","TargetCharacterCodePoint": "01AE"}
,{"SourceCharacterCodePoint": "0007","TargetCharacterCodePoint": "01AF"}
,{"SourceCharacterCodePoint": "0090","TargetCharacterCodePoint": "01B0"}
,{"SourceCharacterCodePoint": "0091","TargetCharacterCodePoint": "01B1"}
,{"SourceCharacterCodePoint": "0016","TargetCharacterCodePoint": "01B2"}
,{"SourceCharacterCodePoint": "0093","TargetCharacterCodePoint": "01B3"}
,{"SourceCharacterCodePoint": "0094","TargetCharacterCodePoint": "01B4"}
,{"SourceCharacterCodePoint": "0095","TargetCharacterCodePoint": "01B5"}
,{"SourceCharacterCodePoint": "0096","TargetCharacterCodePoint": "01B6"}
,{"SourceCharacterCodePoint": "0004","TargetCharacterCodePoint": "01B7"}
,{"SourceCharacterCodePoint": "0098","TargetCharacterCodePoint": "01B8"}
,{"SourceCharacterCodePoint": "0099","TargetCharacterCodePoint": "01B9"}
,{"SourceCharacterCodePoint": "009A","TargetCharacterCodePoint": "01BA"}
,{"SourceCharacterCodePoint": "009B","TargetCharacterCodePoint": "01BB"}
,{"SourceCharacterCodePoint": "0014","TargetCharacterCodePoint": "01BC"}
,{"SourceCharacterCodePoint": "0015","TargetCharacterCodePoint": "01BD"}
,{"SourceCharacterCodePoint": "009E","TargetCharacterCodePoint": "01BE"}
,{"SourceCharacterCodePoint": "001A","TargetCharacterCodePoint": "01BF"}
,{"SourceCharacterCodePoint": "009F","TargetCharacterCodePoint": "027F"}
```
**fi\$1FI-278b** y **fi-FI-1143b**  
Cambio de código:  

```
0180    0180
0001    0181
0002    0182
0003    0183
009C    0184
0009    0185
0086    0186
007F    0187
0097    0188
008D    0189
008E    018A
000B    018B
000C    018C
000D    018D
000E    018E
000F    018F
0010    0190
0011    0191
0012    0192
0013    0193
009D    0194
0085    0195
0008    0196
0087    0197
0018    0198
0019    0199
0092    019A
008F    019B
001C    019C
001D    019D
001E    019E
001F    019F
0080    01A0
0081    01A1
0082    01A2
0083    01A3
0084    01A4
000A    01A5
0017    01A6
001B    01A7
0088    01A8
0089    01A9
008A    01AA
008B    01AB
008C    01AC
0005    01AD
0006    01AE
0007    01AF
0090    01B0
0091    01B1
0016    01B2
0093    01B3
0094    01B4
0095    01B5
0096    01B6
0004    01B7
0098    01B8
0099    01B9
009A    01BA
009B    01BB
0014    01BC
0015    01BD
009E    01BE
001A    01BF
009F    027F
```
Mapeo de entrada correspondiente a una AWS DMS tarea:  

```
 {"SourceCharacterCodePoint": "0180","TargetCharacterCodePoint": "0180"}
,{"SourceCharacterCodePoint": "0001","TargetCharacterCodePoint": "0181"}
,{"SourceCharacterCodePoint": "0002","TargetCharacterCodePoint": "0182"}
,{"SourceCharacterCodePoint": "0003","TargetCharacterCodePoint": "0183"}
,{"SourceCharacterCodePoint": "009C","TargetCharacterCodePoint": "0184"}
,{"SourceCharacterCodePoint": "0009","TargetCharacterCodePoint": "0185"}
,{"SourceCharacterCodePoint": "0086","TargetCharacterCodePoint": "0186"}
,{"SourceCharacterCodePoint": "007F","TargetCharacterCodePoint": "0187"}
,{"SourceCharacterCodePoint": "0097","TargetCharacterCodePoint": "0188"}
,{"SourceCharacterCodePoint": "008D","TargetCharacterCodePoint": "0189"}
,{"SourceCharacterCodePoint": "008E","TargetCharacterCodePoint": "018A"}
,{"SourceCharacterCodePoint": "000B","TargetCharacterCodePoint": "018B"}
,{"SourceCharacterCodePoint": "000C","TargetCharacterCodePoint": "018C"}
,{"SourceCharacterCodePoint": "000D","TargetCharacterCodePoint": "018D"}
,{"SourceCharacterCodePoint": "000E","TargetCharacterCodePoint": "018E"}
,{"SourceCharacterCodePoint": "000F","TargetCharacterCodePoint": "018F"}
,{"SourceCharacterCodePoint": "0010","TargetCharacterCodePoint": "0190"}
,{"SourceCharacterCodePoint": "0011","TargetCharacterCodePoint": "0191"}
,{"SourceCharacterCodePoint": "0012","TargetCharacterCodePoint": "0192"}
,{"SourceCharacterCodePoint": "0013","TargetCharacterCodePoint": "0193"}
,{"SourceCharacterCodePoint": "009D","TargetCharacterCodePoint": "0194"}
,{"SourceCharacterCodePoint": "0085","TargetCharacterCodePoint": "0195"}
,{"SourceCharacterCodePoint": "0008","TargetCharacterCodePoint": "0196"}
,{"SourceCharacterCodePoint": "0087","TargetCharacterCodePoint": "0197"}
,{"SourceCharacterCodePoint": "0018","TargetCharacterCodePoint": "0198"}
,{"SourceCharacterCodePoint": "0019","TargetCharacterCodePoint": "0199"}
,{"SourceCharacterCodePoint": "0092","TargetCharacterCodePoint": "019A"}
,{"SourceCharacterCodePoint": "008F","TargetCharacterCodePoint": "019B"}
,{"SourceCharacterCodePoint": "001C","TargetCharacterCodePoint": "019C"}
,{"SourceCharacterCodePoint": "001D","TargetCharacterCodePoint": "019D"}
,{"SourceCharacterCodePoint": "001E","TargetCharacterCodePoint": "019E"}
,{"SourceCharacterCodePoint": "001F","TargetCharacterCodePoint": "019F"}
,{"SourceCharacterCodePoint": "0080","TargetCharacterCodePoint": "01A0"}
,{"SourceCharacterCodePoint": "0081","TargetCharacterCodePoint": "01A1"}
,{"SourceCharacterCodePoint": "0082","TargetCharacterCodePoint": "01A2"}
,{"SourceCharacterCodePoint": "0083","TargetCharacterCodePoint": "01A3"}
,{"SourceCharacterCodePoint": "0084","TargetCharacterCodePoint": "01A4"}
,{"SourceCharacterCodePoint": "000A","TargetCharacterCodePoint": "01A5"}
,{"SourceCharacterCodePoint": "0017","TargetCharacterCodePoint": "01A6"}
,{"SourceCharacterCodePoint": "001B","TargetCharacterCodePoint": "01A7"}
,{"SourceCharacterCodePoint": "0088","TargetCharacterCodePoint": "01A8"}
,{"SourceCharacterCodePoint": "0089","TargetCharacterCodePoint": "01A9"}
,{"SourceCharacterCodePoint": "008A","TargetCharacterCodePoint": "01AA"}
,{"SourceCharacterCodePoint": "008B","TargetCharacterCodePoint": "01AB"}
,{"SourceCharacterCodePoint": "008C","TargetCharacterCodePoint": "01AC"}
,{"SourceCharacterCodePoint": "0005","TargetCharacterCodePoint": "01AD"}
,{"SourceCharacterCodePoint": "0006","TargetCharacterCodePoint": "01AE"}
,{"SourceCharacterCodePoint": "0007","TargetCharacterCodePoint": "01AF"}
,{"SourceCharacterCodePoint": "0090","TargetCharacterCodePoint": "01B0"}
,{"SourceCharacterCodePoint": "0091","TargetCharacterCodePoint": "01B1"}
,{"SourceCharacterCodePoint": "0016","TargetCharacterCodePoint": "01B2"}
,{"SourceCharacterCodePoint": "0093","TargetCharacterCodePoint": "01B3"}
,{"SourceCharacterCodePoint": "0094","TargetCharacterCodePoint": "01B4"}
,{"SourceCharacterCodePoint": "0095","TargetCharacterCodePoint": "01B5"}
,{"SourceCharacterCodePoint": "0096","TargetCharacterCodePoint": "01B6"}
,{"SourceCharacterCodePoint": "0004","TargetCharacterCodePoint": "01B7"}
,{"SourceCharacterCodePoint": "0098","TargetCharacterCodePoint": "01B8"}
,{"SourceCharacterCodePoint": "0099","TargetCharacterCodePoint": "01B9"}
,{"SourceCharacterCodePoint": "009A","TargetCharacterCodePoint": "01BA"}
,{"SourceCharacterCodePoint": "009B","TargetCharacterCodePoint": "01BB"}
,{"SourceCharacterCodePoint": "0014","TargetCharacterCodePoint": "01BC"}
,{"SourceCharacterCodePoint": "0015","TargetCharacterCodePoint": "01BD"}
,{"SourceCharacterCodePoint": "009E","TargetCharacterCodePoint": "01BE"}
,{"SourceCharacterCodePoint": "001A","TargetCharacterCodePoint": "01BF"}
,{"SourceCharacterCodePoint": "009F","TargetCharacterCodePoint": "027F"}
```
**fr-FR-297b** y **fr-FR-1147b**  
Cambio de código:  

```
0180    0180
0001    0181
0002    0182
0003    0183
009C    0184
0009    0185
0086    0186
007F    0187
0097    0188
008D    0189
008E    018A
000B    018B
000C    018C
000D    018D
000E    018E
000F    018F
0010    0190
0011    0191
0012    0192
0013    0193
009D    0194
0085    0195
0008    0196
0087    0197
0018    0198
0019    0199
0092    019A
008F    019B
001C    019C
001D    019D
001E    019E
001F    019F
0080    01A0
0081    01A1
0082    01A2
0083    01A3
0084    01A4
000A    01A5
0017    01A6
001B    01A7
0088    01A8
0089    01A9
008A    01AA
008B    01AB
008C    01AC
0005    01AD
0006    01AE
0007    01AF
0090    01B0
0091    01B1
0016    01B2
0093    01B3
0094    01B4
0095    01B5
0096    01B6
0004    01B7
0098    01B8
0099    01B9
009A    01BA
009B    01BB
0014    01BC
0015    01BD
009E    01BE
001A    01BF
009F    027F
```
Mapeo de entrada correspondiente a una AWS DMS tarea:  

```
{"SourceCharacterCodePoint": "0180","TargetCharacterCodePoint": "0180"}
,{"SourceCharacterCodePoint": "0001","TargetCharacterCodePoint": "0181"}
,{"SourceCharacterCodePoint": "0002","TargetCharacterCodePoint": "0182"}
,{"SourceCharacterCodePoint": "0003","TargetCharacterCodePoint": "0183"}
,{"SourceCharacterCodePoint": "009C","TargetCharacterCodePoint": "0184"}
,{"SourceCharacterCodePoint": "0009","TargetCharacterCodePoint": "0185"}
,{"SourceCharacterCodePoint": "0086","TargetCharacterCodePoint": "0186"}
,{"SourceCharacterCodePoint": "007F","TargetCharacterCodePoint": "0187"}
,{"SourceCharacterCodePoint": "0097","TargetCharacterCodePoint": "0188"}
,{"SourceCharacterCodePoint": "008D","TargetCharacterCodePoint": "0189"}
,{"SourceCharacterCodePoint": "008E","TargetCharacterCodePoint": "018A"}
,{"SourceCharacterCodePoint": "000B","TargetCharacterCodePoint": "018B"}
,{"SourceCharacterCodePoint": "000C","TargetCharacterCodePoint": "018C"}
,{"SourceCharacterCodePoint": "000D","TargetCharacterCodePoint": "018D"}
,{"SourceCharacterCodePoint": "000E","TargetCharacterCodePoint": "018E"}
,{"SourceCharacterCodePoint": "000F","TargetCharacterCodePoint": "018F"}
,{"SourceCharacterCodePoint": "0010","TargetCharacterCodePoint": "0190"}
,{"SourceCharacterCodePoint": "0011","TargetCharacterCodePoint": "0191"}
,{"SourceCharacterCodePoint": "0012","TargetCharacterCodePoint": "0192"}
,{"SourceCharacterCodePoint": "0013","TargetCharacterCodePoint": "0193"}
,{"SourceCharacterCodePoint": "009D","TargetCharacterCodePoint": "0194"}
,{"SourceCharacterCodePoint": "0085","TargetCharacterCodePoint": "0195"}
,{"SourceCharacterCodePoint": "0008","TargetCharacterCodePoint": "0196"}
,{"SourceCharacterCodePoint": "0087","TargetCharacterCodePoint": "0197"}
,{"SourceCharacterCodePoint": "0018","TargetCharacterCodePoint": "0198"}
,{"SourceCharacterCodePoint": "0019","TargetCharacterCodePoint": "0199"}
,{"SourceCharacterCodePoint": "0092","TargetCharacterCodePoint": "019A"}
,{"SourceCharacterCodePoint": "008F","TargetCharacterCodePoint": "019B"}
,{"SourceCharacterCodePoint": "001C","TargetCharacterCodePoint": "019C"}
,{"SourceCharacterCodePoint": "001D","TargetCharacterCodePoint": "019D"}
,{"SourceCharacterCodePoint": "001E","TargetCharacterCodePoint": "019E"}
,{"SourceCharacterCodePoint": "001F","TargetCharacterCodePoint": "019F"}
,{"SourceCharacterCodePoint": "0080","TargetCharacterCodePoint": "01A0"}
,{"SourceCharacterCodePoint": "0081","TargetCharacterCodePoint": "01A1"}
,{"SourceCharacterCodePoint": "0082","TargetCharacterCodePoint": "01A2"}
,{"SourceCharacterCodePoint": "0083","TargetCharacterCodePoint": "01A3"}
,{"SourceCharacterCodePoint": "0084","TargetCharacterCodePoint": "01A4"}
,{"SourceCharacterCodePoint": "000A","TargetCharacterCodePoint": "01A5"}
,{"SourceCharacterCodePoint": "0017","TargetCharacterCodePoint": "01A6"}
,{"SourceCharacterCodePoint": "001B","TargetCharacterCodePoint": "01A7"}
,{"SourceCharacterCodePoint": "0088","TargetCharacterCodePoint": "01A8"}
,{"SourceCharacterCodePoint": "0089","TargetCharacterCodePoint": "01A9"}
,{"SourceCharacterCodePoint": "008A","TargetCharacterCodePoint": "01AA"}
,{"SourceCharacterCodePoint": "008B","TargetCharacterCodePoint": "01AB"}
,{"SourceCharacterCodePoint": "008C","TargetCharacterCodePoint": "01AC"}
,{"SourceCharacterCodePoint": "0005","TargetCharacterCodePoint": "01AD"}
,{"SourceCharacterCodePoint": "0006","TargetCharacterCodePoint": "01AE"}
,{"SourceCharacterCodePoint": "0007","TargetCharacterCodePoint": "01AF"}
,{"SourceCharacterCodePoint": "0090","TargetCharacterCodePoint": "01B0"}
,{"SourceCharacterCodePoint": "0091","TargetCharacterCodePoint": "01B1"}
,{"SourceCharacterCodePoint": "0016","TargetCharacterCodePoint": "01B2"}
,{"SourceCharacterCodePoint": "0093","TargetCharacterCodePoint": "01B3"}
,{"SourceCharacterCodePoint": "0094","TargetCharacterCodePoint": "01B4"}
,{"SourceCharacterCodePoint": "0095","TargetCharacterCodePoint": "01B5"}
,{"SourceCharacterCodePoint": "0096","TargetCharacterCodePoint": "01B6"}
,{"SourceCharacterCodePoint": "0004","TargetCharacterCodePoint": "01B7"}
,{"SourceCharacterCodePoint": "0098","TargetCharacterCodePoint": "01B8"}
,{"SourceCharacterCodePoint": "0099","TargetCharacterCodePoint": "01B9"}
,{"SourceCharacterCodePoint": "009A","TargetCharacterCodePoint": "01BA"}
,{"SourceCharacterCodePoint": "009B","TargetCharacterCodePoint": "01BB"}
,{"SourceCharacterCodePoint": "0014","TargetCharacterCodePoint": "01BC"}
,{"SourceCharacterCodePoint": "0015","TargetCharacterCodePoint": "01BD"}
,{"SourceCharacterCodePoint": "009E","TargetCharacterCodePoint": "01BE"}
,{"SourceCharacterCodePoint": "001A","TargetCharacterCodePoint": "01BF"}
,{"SourceCharacterCodePoint": "009F","TargetCharacterCodePoint": "027F"}
```
**it-IT-280b** e **it-IT-1144b**  
Cambio de código:  

```
0180    0180
0001    0181
0002    0182
0003    0183
009C    0184
0009    0185
0086    0186
007F    0187
0097    0188
008D    0189
008E    018A
000B    018B
000C    018C
000D    018D
000E    018E
000F    018F
0010    0190
0011    0191
0012    0192
0013    0193
009D    0194
0085    0195
0008    0196
0087    0197
0018    0198
0019    0199
0092    019A
008F    019B
001C    019C
001D    019D
001E    019E
001F    019F
0080    01A0
0081    01A1
0082    01A2
0083    01A3
0084    01A4
000A    01A5
0017    01A6
001B    01A7
0088    01A8
0089    01A9
008A    01AA
008B    01AB
008C    01AC
0005    01AD
0006    01AE
0007    01AF
0090    01B0
0091    01B1
0016    01B2
0093    01B3
0094    01B4
0095    01B5
0096    01B6
0004    01B7
0098    01B8
0099    01B9
009A    01BA
009B    01BB
0014    01BC
0015    01BD
009E    01BE
001A    01BF
009F    027F
```
Mapeo de entrada correspondiente a una AWS DMS tarea:  

```
 {"SourceCharacterCodePoint": "0180","TargetCharacterCodePoint": "0180"}
,{"SourceCharacterCodePoint": "0001","TargetCharacterCodePoint": "0181"}
,{"SourceCharacterCodePoint": "0002","TargetCharacterCodePoint": "0182"}
,{"SourceCharacterCodePoint": "0003","TargetCharacterCodePoint": "0183"}
,{"SourceCharacterCodePoint": "009C","TargetCharacterCodePoint": "0184"}
,{"SourceCharacterCodePoint": "0009","TargetCharacterCodePoint": "0185"}
,{"SourceCharacterCodePoint": "0086","TargetCharacterCodePoint": "0186"}
,{"SourceCharacterCodePoint": "007F","TargetCharacterCodePoint": "0187"}
,{"SourceCharacterCodePoint": "0097","TargetCharacterCodePoint": "0188"}
,{"SourceCharacterCodePoint": "008D","TargetCharacterCodePoint": "0189"}
,{"SourceCharacterCodePoint": "008E","TargetCharacterCodePoint": "018A"}
,{"SourceCharacterCodePoint": "000B","TargetCharacterCodePoint": "018B"}
,{"SourceCharacterCodePoint": "000C","TargetCharacterCodePoint": "018C"}
,{"SourceCharacterCodePoint": "000D","TargetCharacterCodePoint": "018D"}
,{"SourceCharacterCodePoint": "000E","TargetCharacterCodePoint": "018E"}
,{"SourceCharacterCodePoint": "000F","TargetCharacterCodePoint": "018F"}
,{"SourceCharacterCodePoint": "0010","TargetCharacterCodePoint": "0190"}
,{"SourceCharacterCodePoint": "0011","TargetCharacterCodePoint": "0191"}
,{"SourceCharacterCodePoint": "0012","TargetCharacterCodePoint": "0192"}
,{"SourceCharacterCodePoint": "0013","TargetCharacterCodePoint": "0193"}
,{"SourceCharacterCodePoint": "009D","TargetCharacterCodePoint": "0194"}
,{"SourceCharacterCodePoint": "0085","TargetCharacterCodePoint": "0195"}
,{"SourceCharacterCodePoint": "0008","TargetCharacterCodePoint": "0196"}
,{"SourceCharacterCodePoint": "0087","TargetCharacterCodePoint": "0197"}
,{"SourceCharacterCodePoint": "0018","TargetCharacterCodePoint": "0198"}
,{"SourceCharacterCodePoint": "0019","TargetCharacterCodePoint": "0199"}
,{"SourceCharacterCodePoint": "0092","TargetCharacterCodePoint": "019A"}
,{"SourceCharacterCodePoint": "008F","TargetCharacterCodePoint": "019B"}
,{"SourceCharacterCodePoint": "001C","TargetCharacterCodePoint": "019C"}
,{"SourceCharacterCodePoint": "001D","TargetCharacterCodePoint": "019D"}
,{"SourceCharacterCodePoint": "001E","TargetCharacterCodePoint": "019E"}
,{"SourceCharacterCodePoint": "001F","TargetCharacterCodePoint": "019F"}
,{"SourceCharacterCodePoint": "0080","TargetCharacterCodePoint": "01A0"}
,{"SourceCharacterCodePoint": "0081","TargetCharacterCodePoint": "01A1"}
,{"SourceCharacterCodePoint": "0082","TargetCharacterCodePoint": "01A2"}
,{"SourceCharacterCodePoint": "0083","TargetCharacterCodePoint": "01A3"}
,{"SourceCharacterCodePoint": "0084","TargetCharacterCodePoint": "01A4"}
,{"SourceCharacterCodePoint": "000A","TargetCharacterCodePoint": "01A5"}
,{"SourceCharacterCodePoint": "0017","TargetCharacterCodePoint": "01A6"}
,{"SourceCharacterCodePoint": "001B","TargetCharacterCodePoint": "01A7"}
,{"SourceCharacterCodePoint": "0088","TargetCharacterCodePoint": "01A8"}
,{"SourceCharacterCodePoint": "0089","TargetCharacterCodePoint": "01A9"}
,{"SourceCharacterCodePoint": "008A","TargetCharacterCodePoint": "01AA"}
,{"SourceCharacterCodePoint": "008B","TargetCharacterCodePoint": "01AB"}
,{"SourceCharacterCodePoint": "008C","TargetCharacterCodePoint": "01AC"}
,{"SourceCharacterCodePoint": "0005","TargetCharacterCodePoint": "01AD"}
,{"SourceCharacterCodePoint": "0006","TargetCharacterCodePoint": "01AE"}
,{"SourceCharacterCodePoint": "0007","TargetCharacterCodePoint": "01AF"}
,{"SourceCharacterCodePoint": "0090","TargetCharacterCodePoint": "01B0"}
,{"SourceCharacterCodePoint": "0091","TargetCharacterCodePoint": "01B1"}
,{"SourceCharacterCodePoint": "0016","TargetCharacterCodePoint": "01B2"}
,{"SourceCharacterCodePoint": "0093","TargetCharacterCodePoint": "01B3"}
,{"SourceCharacterCodePoint": "0094","TargetCharacterCodePoint": "01B4"}
,{"SourceCharacterCodePoint": "0095","TargetCharacterCodePoint": "01B5"}
,{"SourceCharacterCodePoint": "0096","TargetCharacterCodePoint": "01B6"}
,{"SourceCharacterCodePoint": "0004","TargetCharacterCodePoint": "01B7"}
,{"SourceCharacterCodePoint": "0098","TargetCharacterCodePoint": "01B8"}
,{"SourceCharacterCodePoint": "0099","TargetCharacterCodePoint": "01B9"}
,{"SourceCharacterCodePoint": "009A","TargetCharacterCodePoint": "01BA"}
,{"SourceCharacterCodePoint": "009B","TargetCharacterCodePoint": "01BB"}
,{"SourceCharacterCodePoint": "0014","TargetCharacterCodePoint": "01BC"}
,{"SourceCharacterCodePoint": "0015","TargetCharacterCodePoint": "01BD"}
,{"SourceCharacterCodePoint": "009E","TargetCharacterCodePoint": "01BE"}
,{"SourceCharacterCodePoint": "001A","TargetCharacterCodePoint": "01BF"}
,{"SourceCharacterCodePoint": "009F","TargetCharacterCodePoint": "027F"}
```
**nl-BE-500b** y **nl-BE-1148b**  
Cambio de código:  

```
0180    0180
0001    0181
0002    0182
0003    0183
009C    0184
0009    0185
0086    0186
007F    0187
0097    0188
008D    0189
008E    018A
000B    018B
000C    018C
000D    018D
000E    018E
000F    018F
0010    0190
0011    0191
0012    0192
0013    0193
009D    0194
0085    0195
0008    0196
0087    0197
0018    0198
0019    0199
0092    019A
008F    019B
001C    019C
001D    019D
001E    019E
001F    019F
0080    01A0
0081    01A1
0082    01A2
0083    01A3
0084    01A4
000A    01A5
0017    01A6
001B    01A7
0088    01A8
0089    01A9
008A    01AA
008B    01AB
008C    01AC
0005    01AD
0006    01AE
0007    01AF
0090    01B0
0091    01B1
0016    01B2
0093    01B3
0094    01B4
0095    01B5
0096    01B6
0004    01B7
0098    01B8
0099    01B9
009A    01BA
009B    01BB
0014    01BC
0015    01BD
009E    01BE
001A    01BF
009F    027F
```
Mapeo de entrada correspondiente a una AWS DMS tarea:  

```
 {"SourceCharacterCodePoint": "0180","TargetCharacterCodePoint": "0180"}
,{"SourceCharacterCodePoint": "0001","TargetCharacterCodePoint": "0181"}
,{"SourceCharacterCodePoint": "0002","TargetCharacterCodePoint": "0182"}
,{"SourceCharacterCodePoint": "0003","TargetCharacterCodePoint": "0183"}
,{"SourceCharacterCodePoint": "009C","TargetCharacterCodePoint": "0184"}
,{"SourceCharacterCodePoint": "0009","TargetCharacterCodePoint": "0185"}
,{"SourceCharacterCodePoint": "0086","TargetCharacterCodePoint": "0186"}
,{"SourceCharacterCodePoint": "007F","TargetCharacterCodePoint": "0187"}
,{"SourceCharacterCodePoint": "0097","TargetCharacterCodePoint": "0188"}
,{"SourceCharacterCodePoint": "008D","TargetCharacterCodePoint": "0189"}
,{"SourceCharacterCodePoint": "008E","TargetCharacterCodePoint": "018A"}
,{"SourceCharacterCodePoint": "000B","TargetCharacterCodePoint": "018B"}
,{"SourceCharacterCodePoint": "000C","TargetCharacterCodePoint": "018C"}
,{"SourceCharacterCodePoint": "000D","TargetCharacterCodePoint": "018D"}
,{"SourceCharacterCodePoint": "000E","TargetCharacterCodePoint": "018E"}
,{"SourceCharacterCodePoint": "000F","TargetCharacterCodePoint": "018F"}
,{"SourceCharacterCodePoint": "0010","TargetCharacterCodePoint": "0190"}
,{"SourceCharacterCodePoint": "0011","TargetCharacterCodePoint": "0191"}
,{"SourceCharacterCodePoint": "0012","TargetCharacterCodePoint": "0192"}
,{"SourceCharacterCodePoint": "0013","TargetCharacterCodePoint": "0193"}
,{"SourceCharacterCodePoint": "009D","TargetCharacterCodePoint": "0194"}
,{"SourceCharacterCodePoint": "0085","TargetCharacterCodePoint": "0195"}
,{"SourceCharacterCodePoint": "0008","TargetCharacterCodePoint": "0196"}
,{"SourceCharacterCodePoint": "0087","TargetCharacterCodePoint": "0197"}
,{"SourceCharacterCodePoint": "0018","TargetCharacterCodePoint": "0198"}
,{"SourceCharacterCodePoint": "0019","TargetCharacterCodePoint": "0199"}
,{"SourceCharacterCodePoint": "0092","TargetCharacterCodePoint": "019A"}
,{"SourceCharacterCodePoint": "008F","TargetCharacterCodePoint": "019B"}
,{"SourceCharacterCodePoint": "001C","TargetCharacterCodePoint": "019C"}
,{"SourceCharacterCodePoint": "001D","TargetCharacterCodePoint": "019D"}
,{"SourceCharacterCodePoint": "001E","TargetCharacterCodePoint": "019E"}
,{"SourceCharacterCodePoint": "001F","TargetCharacterCodePoint": "019F"}
,{"SourceCharacterCodePoint": "0080","TargetCharacterCodePoint": "01A0"}
,{"SourceCharacterCodePoint": "0081","TargetCharacterCodePoint": "01A1"}
,{"SourceCharacterCodePoint": "0082","TargetCharacterCodePoint": "01A2"}
,{"SourceCharacterCodePoint": "0083","TargetCharacterCodePoint": "01A3"}
,{"SourceCharacterCodePoint": "0084","TargetCharacterCodePoint": "01A4"}
,{"SourceCharacterCodePoint": "000A","TargetCharacterCodePoint": "01A5"}
,{"SourceCharacterCodePoint": "0017","TargetCharacterCodePoint": "01A6"}
,{"SourceCharacterCodePoint": "001B","TargetCharacterCodePoint": "01A7"}
,{"SourceCharacterCodePoint": "0088","TargetCharacterCodePoint": "01A8"}
,{"SourceCharacterCodePoint": "0089","TargetCharacterCodePoint": "01A9"}
,{"SourceCharacterCodePoint": "008A","TargetCharacterCodePoint": "01AA"}
,{"SourceCharacterCodePoint": "008B","TargetCharacterCodePoint": "01AB"}
,{"SourceCharacterCodePoint": "008C","TargetCharacterCodePoint": "01AC"}
,{"SourceCharacterCodePoint": "0005","TargetCharacterCodePoint": "01AD"}
,{"SourceCharacterCodePoint": "0006","TargetCharacterCodePoint": "01AE"}
,{"SourceCharacterCodePoint": "0007","TargetCharacterCodePoint": "01AF"}
,{"SourceCharacterCodePoint": "0090","TargetCharacterCodePoint": "01B0"}
,{"SourceCharacterCodePoint": "0091","TargetCharacterCodePoint": "01B1"}
,{"SourceCharacterCodePoint": "0016","TargetCharacterCodePoint": "01B2"}
,{"SourceCharacterCodePoint": "0093","TargetCharacterCodePoint": "01B3"}
,{"SourceCharacterCodePoint": "0094","TargetCharacterCodePoint": "01B4"}
,{"SourceCharacterCodePoint": "0095","TargetCharacterCodePoint": "01B5"}
,{"SourceCharacterCodePoint": "0096","TargetCharacterCodePoint": "01B6"}
,{"SourceCharacterCodePoint": "0004","TargetCharacterCodePoint": "01B7"}
,{"SourceCharacterCodePoint": "0098","TargetCharacterCodePoint": "01B8"}
,{"SourceCharacterCodePoint": "0099","TargetCharacterCodePoint": "01B9"}
,{"SourceCharacterCodePoint": "009A","TargetCharacterCodePoint": "01BA"}
,{"SourceCharacterCodePoint": "009B","TargetCharacterCodePoint": "01BB"}
,{"SourceCharacterCodePoint": "0014","TargetCharacterCodePoint": "01BC"}
,{"SourceCharacterCodePoint": "0015","TargetCharacterCodePoint": "01BD"}
,{"SourceCharacterCodePoint": "009E","TargetCharacterCodePoint": "01BE"}
,{"SourceCharacterCodePoint": "001A","TargetCharacterCodePoint": "01BF"}
,{"SourceCharacterCodePoint": "009F","TargetCharacterCodePoint": "027F"}
```