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.
# Uso de una base de datos Oracle como fuente para AWS DMS
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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 '';
GRANT READ ON DIRECTORY STANDBY_REDO_DIR TO ;
```
### Uso de una base de datos gestionada por los usuarios en Oracle Cloud Infrastructure (OCI) como fuente para los CDC en AWS DMS
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
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
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
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
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
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
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
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
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
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
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`).
```
=
(DESCRIPTION=
(ADDRESS_LIST =
(ADDRESS=(PROTOCOL = TCP)(HOST = localhost.localdomain)(PORT = 1521))
)
(CONNECT_DATA =
(SERVER = DEDICATED)
(SERVICE_NAME = )
)
)
_ssl=
(DESCRIPTION=
(ADDRESS_LIST =
(ADDRESS=(PROTOCOL = TCPS)(HOST = localhost.localdomain)(PORT = 1522))
)
(CONNECT_DATA =
(SERVER = DEDICATED)
(SERVICE_NAME = )
)
)
```
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
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
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
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
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
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
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
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
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
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
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
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
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.