Schema Conversion Tool

Schema Conversion Tool de AWS
Guía del usuario

Version 1.0
Schema Conversion Tool de AWS Guía del usuario
Schema Conversion Tool de AWS: Guía del usuario

Copyright © 2020 Amazon Web Services, Inc. and/or its affiliates. All rights reserved.
Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's,
in any manner that is likely to cause confusion among customers, or in any manner that disparages or discredits
Amazon. All other trademarks not owned by Amazon are the property of their respective owners, who may or may not
be affiliated with, connected to, or sponsored by Amazon.
Table of Contents
¿Qué es la Herramienta de conversión de esquemas de AWS? ................................................................ 1
Introducción a la conversión de esquemas ..................................................................................... 2
Comentarios .............................................................................................................................. 3
Instalación, verificación y actualización ................................................................................................. 4
Instalación de la AWS SCT ........................................................................................................ 4
Instalación de versiones anteriores ...................................................................................... 5
Verificación de la descarga del archivo de AWS SCT ...................................................................... 6
Verificación de la suma de comprobación del archivo de la AWS SCT ....................................... 6
Verificación de los archivos RPM de AWS SCT en Fedora ....................................................... 7
Verificación de los archivos DEB de AWS SCT en Ubuntu ....................................................... 7
Verificación del archivo MSI de AWS SCT en Microsoft Windows .............................................. 8
Verificación de la aplicación AWS SCT en Mac OS ................................................................ 8
Instalación de los controladores de bases de datos necesarios ......................................................... 8
Instalación de controladores de JDBC en Linux .................................................................... 10
Almacenamiento de rutas a los controladores en la configuración global ................................... 10
Actualización del AWS SCT ...................................................................................................... 11
Uso de la interfaz de usuario de la AWS SCT ....................................................................................... 12
La ventana de proyecto de AWS SCT ........................................................................................ 12
Almacenamiento de perfiles de AWS ........................................................................................... 13
Almacenamiento de las credenciales de AWS ....................................................................... 14
Configuración del perfil predeterminado para un proyecto ....................................................... 16
Almacenamiento de la contraseña de la base de datos ................................................................... 16
Uso de la vista UNION ALL en proyectos con tablas con particiones ................................................ 16
Filtros de árbol de AWS SCT ..................................................................................................... 17
...................................................................................................................................... 17
Importación de una lista de archivos para el filtro de árbol ...................................................... 19
Ocultar esquemas .................................................................................................................... 19
Métodos abreviados de teclado ................................................................................................. 20
El informe de evaluación de la migración de la base de datos ........................................................ 21
Iniciar la SCT .......................................................................................................................... 24
Creación de un proyecto ........................................................................................................... 25
Conversión de su esquema ....................................................................................................... 26
Aplicación del esquema convertido a su instancia de base de datos de destino .................................. 28
Introducción ..................................................................................................................................... 30
Bases de datos de origen para AWS SCT ........................................................................................... 31
Uso de Oracle como origen para Herramienta de conversión de esquemas de AWS ........................... 31
Permisos necesarios para Oracle como origen ..................................................................... 32
Conexión a Oracle como origen ......................................................................................... 32
Oracle a PostgreSQL ....................................................................................................... 35
De Oracle a MySQL ........................................................................................................ 38
De Oracle a Amazon RDS Oracle ...................................................................................... 42
Uso de Microsoft SQL Server como origen para Herramienta de conversión de esquemas de AWS ....... 45
Fuente: Microsoft SQL Server ............................................................................................. 45
Origen: autenticación de Windows con Microsoft SQL Server ................................................... 46
Conexión a SQL Server como origen .................................................................................. 47
De SQL Server a MySQL ................................................................................................. 49
De SQL Server a PostgreSQL ........................................................................................... 50
De SQL Server a Amazon RDS for SQL Server ................................................................... 54
Utilizar MySQL como origen para Herramienta de conversión de esquemas de AWS .......................... 55
Fuente: MySQL ............................................................................................................... 55
Conexión a MySQL como origen ........................................................................................ 55
Utilizar PostgreSQL como origen para Herramienta de conversión de esquemas de AWS .................... 57
Fuente: PostgreSQL ......................................................................................................... 58
Conexión a PostgreSQL como origen ................................................................................. 58
Version 1.0
iii
Uso de Db2 LUW como origen para Herramienta de conversión de esquemas de AWS ....................... 60
Origen: Db2 LUW ............................................................................................................ 60
Conexión a Db2 LUW como origen .................................................................................... 62
De DB2LUW a PostgreSQL .............................................................................................. 64
Uso de Amazon Redshift como origen de Herramienta de conversión de esquemas de AWS ................ 65
Origen: Amazon Redshift .................................................................................................. 65
Conexión a Redshift como origen ....................................................................................... 65
Utilizar Oracle DW como origen para Herramienta de conversión de esquemas de AWS ...................... 67
Fuente: Oracle Data Warehouse ........................................................................................ 67
Conexión a OracleDW como origen .................................................................................... 67
Utilizar Teradata como origen para Herramienta de conversión de esquemas de AWS ........................ 70
Fuente: Teradata ............................................................................................................. 70
Conexión a Teradata como origen ...................................................................................... 70
Utilizar Netezza como origen para Herramienta de conversión de esquemas de AWS ......................... 73
Fuente: Netezza .............................................................................................................. 73
Conexión a Netezza como origen ....................................................................................... 74
Utilizar Greenplum como origen para Herramienta de conversión de esquemas de AWS ..................... 75
Fuente: Greenplum .......................................................................................................... 75
Conexión a Greenplum como origen ................................................................................... 75
Utilizar Vertica como origen para Herramienta de conversión de esquemas de AWS ........................... 77
Fuente: Vertica ................................................................................................................ 77
Conexión a Vertica como origen ........................................................................................ 78
Uso de Microsoft SQL Server DW como origen para Herramienta de conversión de esquemas de
AWS ....................................................................................................................................... 79
Fuente: Microsoft SQL Server Data Warehouse ..................................................................... 80
Conexión a SQLServerDW como origen .............................................................................. 80
Creación de informes de conversión .................................................................................................... 83
Informes de evaluación de migración ........................................................................................... 83
Creación de un informe de evaluación de la migración de la base de datos ............................... 84
Visualización del informe de evaluación .............................................................................. 85
Guardar el informe de evaluación ....................................................................................... 87
Informes de migración de WQF .................................................................................................. 88
Configuración del WQF de AWS ......................................................................................... 89
Preparación para importaciones de lotes .............................................................................. 90
Creación de informes ........................................................................................................ 93
Descripción de las categorías de la carga de trabajo .............................................................. 96
Conversión de esquemas de bases de datos ....................................................................................... 99
Creación de reglas de mapeo .................................................................................................. 101
Creación de reglas de mapeo .......................................................................................... 101
Creación de reglas de mapeo para objetos ........................................................................ 102
Exportación de reglas de mapeo ....................................................................................... 103
Conversión de su esquema ..................................................................................................... 103
Conversión del esquema ................................................................................................. 103
Edición del esquema convertido ....................................................................................... 105
Eliminación de un esquema convertido .............................................................................. 106
Administración de conversiones manuales ................................................................................. 107
Modificar su esquema de origen ....................................................................................... 107
Modificar su esquema de destino ..................................................................................... 108
Actualización de un esquema convertido ................................................................................... 108
Guardado y aplicación de un esquema ..................................................................................... 109
Guardar el esquema convertido en un archivo ..................................................................... 109
Aplicación del esquema convertido ................................................................................... 110
Esquema del paquete de extensión .................................................................................. 111
Comparación de esquemas ..................................................................................................... 112
Objetos transformados relacionados ......................................................................................... 113
Conversión de esquemas de almacén de datos a Amazon Redshift ....................................................... 114
Selección de estrategias y reglas de optimización ....................................................................... 115
Version 1.0
iv
Recopilación o carga de estadísticas ........................................................................................ 116

Creación de reglas de mapeo .................................................................................................. 117
Creación de reglas de mapeo .......................................................................................... 118
Visualización de reglas de mapeo para objetos .................................................................. 119
Exportación de reglas de mapeo ...................................................................................... 119
Conversión de su esquema ...................................................................................................... 119
Conversión del esquema .................................................................................................. 120
Edición del esquema convertido ........................................................................................ 121
Eliminación de un esquema convertido ............................................................................... 122
Administración y personalización de claves ................................................................................ 123
Administración de conversiones manuales ................................................................................. 124
Modificar su esquema de origen ....................................................................................... 124
Modificar su esquema de destino ..................................................................................... 125
Actualización de un esquema convertido ................................................................................... 125
Guardado y aplicación de un esquema ..................................................................................... 126
Guardar el esquema convertido en un archivo .................................................................... 126
Aplicación del esquema convertido ................................................................................... 127
Esquema del paquete de extensión .................................................................................. 128
Bibliotecas Python .......................................................................................................... 129
Optimización de Amazon Redshift ............................................................................................ 129
Optimización de su base de datos de Amazon Redshift ....................................................... 129
Conversión de procesos ETL a AWS Glue .......................................................................................... 131
Requisitos previos ................................................................................................................... 133
AWS Glue Data Catalog .......................................................................................................... 133
Limitaciones ........................................................................................................................... 133
Conversión con AWS Glue en la interfaz de usuario de AWS SCT .................................................. 134
Paso 1: Crear un proyecto nuevo ...................................................................................... 135
Paso 2: Crear un trabajo de AWS Glue .............................................................................. 138
Conversión con la API de Python para AWS Glue ........................................................................ 139
Paso 1: Crear una base de datos ...................................................................................... 139
Paso 2: Crear una conexión ............................................................................................. 139
Paso 3: Crear un rastreador de AWS Glue ......................................................................... 140
Uso de la Herramienta de conversión de esquemas de AWS con el AWS Database Migration Service .......... 143
Uso de un agente de replicación de AWS SCT con AWS DMS ..................................................... 143
Uso de un agente de extracción de datos de AWS SCT con AWS DMS .......................................... 143
Uso de agentes de extracción de datos .............................................................................................. 144
Migración de datos desde un almacén de datos local a Amazon Redshift ......................................... 144
Configuración de requisitos previos .................................................................................... 146
Instalación de agentes ..................................................................................................... 147
Registro de agentes ........................................................................................................ 150
Ocultar y recuperar información de un agente de AWS SCT .................................................. 151
Creación de filtros de extracción de datos ........................................................................... 153
Ordenación de datos ....................................................................................................... 153
Creación, ejecución y monitorización de una tarea de AWS SCT ............................................ 154
Extracción de datos con un dispositivo AWS Snowball .......................................................... 156
Resultado de la tarea de extracción de datos ...................................................................... 162
Uso de particiones virtuales .............................................................................................. 164
Trabajo con LOB ............................................................................................................. 166
Prácticas recomendadas y solución de problemas ................................................................ 167
Migración de datos desde Apache Cassandra a Amazon DynamoDB .............................................. 168
Requisitos previos para migración desde Cassandra a DynamoDB ......................................... 170
Crear un nuevo proyecto de AWS SCT .............................................................................. 172
Crear un centro de datos clon ........................................................................................... 175
Instalar, configurar y ejecutar el agente de extracción de datos .............................................. 181
Migrar datos desde el centro de datos clon a Amazon DynamoDB .......................................... 185
Actividades posteriores a la migración ................................................................................ 189
Conversión de SQL de aplicación ...................................................................................................... 190
Version 1.0
v
Información general de la conversión de SQL de aplicación .......................................................... 190

Creación de proyectos de conversión de aplicaciones .................................................................. 190
Análisis y conversión de su código SQL ..................................................................................... 193
Creación y uso del informe de evaluación ................................................................................... 194
Creación de un informe de evaluación de la aplicación ........................................................ 194
Edición y guardado de su código SQL convertido ....................................................................... 195
Uso del paquete de extensión ......................................................................................................... 196
Uso del esquema de base de datos del paquete de extensión ...................................................... 197
La biblioteca de Python personalizada para el paquete de extensión .............................................. 197
Uso de AWS Services para cargar bibliotecas de Python personalizadas ................................ 197
Aplicación del paquete de extensión ................................................................................. 198
Las funciones de Lambda del paquete de extensión ..................................................................... 199
Uso de AWS Services para simular la funcionalidad de una base de datos .............................. 199
Aplicación del paquete de extensión ................................................................................. 199
Prácticas recomendadas ................................................................................................................. 201
Administración general de la memoria y opciones de desempeño .................................................. 201
Configuración de memoria adicional .......................................................................................... 201
Solución de problemas ................................................................................................................... 202
No se puede cargar objetos de una base de datos de origen de Oracle .......................................... 202
Notas de la versión ......................................................................................................................... 203
Notas de la versión: 632 .......................................................................................................... 203
Notas de la versión– ................................................................................................................ 210
Notas de la versión: 627 – ....................................................................................................... 214
Notas de la versión:– 626 ......................................................................................................... 221
Historial de revisión ......................................................................................................................... 244
Actualizaciones anteriores ........................................................................................................ 247
Version 1.0
vi
¿Qué es la Herramienta de
conversión de esquemas de AWS?
Puede utilizar la Herramienta de conversión de esquemas de AWS (AWS SCT) para convertir su esquema
de base de datos existente de un motor de base de datos a otro. Puede convertir esquemas relacionales
OLTP o esquemas de data warehouse. Su esquema convertido será apto para una instancia de base de
datos MySQL de Amazon Relational Database Service (Amazon RDS), un clúster de base de datos de
Amazon Aurora, una instancia de base de datos PostgreSQL de Amazon RDS o un clúster de Amazon
Redshift. El esquema convertido también puede utilizarse con una base de datos en una instancia Amazon
EC2 o almacenarse como datos en un bucket de Amazon S3.
AWS SCT admite varios estándares del sector, incluido el Estándar federal de procesamiento de la
información (FIPS, Federal Information Processing Standards) para conexiones a un bucket de Amazon S3
o cualquier otro recurso de AWS. AWS SCT también cumple con el Programa federal de administración de
riesgos y autorizaciones (FedRAMP, Federal Risk and Authorization Management Program). Para obtener
más detalles sobre AWS y los esfuerzos de conformidad, consulte Servicios de AWS en el ámbito del
programa de conformidad.
AWS SCT es compatible con las siguientes conversiones de OLTP.
Base de datos de origen Base de datos de destino en Amazon RDS
Microsoft SQL Server (versión 2008 y posteriores) Compatibilidad de Amazon Aurora con
MySQL, Compatibilidad de Amazon Aurora con
PostgreSQL, MariaDB 10.2 y 10.3, Microsoft SQL
Server, MySQL, PostgreSQL
MySQL (versión 5.5 o posteriores) Aurora PostgreSQL, MySQL, PostgreSQL
Puede migrar esquemas y datos de MySQL a un

clúster de base de datos de Aurora MySQL sin
utilizar AWS SCT. Para obtener más información,
consulte Migración de datos a un clúster de base
de datos de Amazon Aurora.
Oracle (versión 10.2 y posteriores) Aurora MySQL, Aurora PostgreSQL, MariaDB 10.2
y 10.3, MySQL, Oracle, PostgreSQL
PostgreSQL (versión 9.1 y posteriores) Aurora MySQL, MySQL, PostgreSQL
IBM Db2 LUW (versiones 9.1, 9.5, 9.7, 10.5 y 11.1) Aurora MySQL, MariaDB 10.2 y 10.3, MySQL,
PostgreSQL, Aurora PostgreSQL
Apache Cassandra (versiones 2.0, 3.0, 3.1.1 y Amazon DynamoDB

3.11.2)
Sybase (16.0 y 15.7) Aurora MySQL, Aurora PostgreSQL, MySQL,

PostgreSQL
AWS SCT es compatible con las siguientes conversiones de data warehouse.
Version 1.0
1
Introducción a la conversión de esquemas
Base de datos de origen Base de datos de destino en Amazon Redshift
Greenplum Database (versión 4.3 y posteriores) Amazon Redshift
Microsoft SQL Server (versión 2008 y posteriores) Amazon Redshift
Netezza (versión 7.0.3 y posteriores) Amazon Redshift
Oracle (versión 10 y posteriores) Amazon Redshift
Teradata (versión 13 y posteriores) Amazon Redshift
Vertica (versión 7.2.2 y posteriores) Amazon Redshift
Introducción a la conversión de esquemas

La AWS SCT proporciona una interfaz de usuario basada en el proyecto para convertir automáticamente
el esquema de la base de datos de origen en un formato compatible con su instancia de Amazon RDS de
destino. Si el esquema de la base de datos de origen no se puede convertir automáticamente, la AWS SCT
facilita orientación sobre cómo puede crear un esquema equivalente en su base de datos de Amazon RDS
de destino.
Para obtener información acerca de cómo instalar AWS SCT, consulte Instalación, verificación y
actualización de Herramienta de conversión de esquemas de AWS (p. 4).
Para obtener una introducción a la interfaz de usuario de AWS SCT, consulte Uso de la interfaz de usuario
de la Herramienta de conversión de esquemas de AWS (p. 12).
Para obtener información acerca del proceso de conversión, consulte Convertir los esquemas de base de
datos utilizando el Herramienta de conversión de esquemas de AWS (p. 99).
Además de convertir su esquema de base de datos existente de un motor de base de datos a otro, AWS
SCT tiene algunas características adicionales que le ayudarán a trasladar sus datos y aplicaciones a la
nube de AWS:
• Puede utilizar agentes de extracción de datos para extraer datos de su almacén de datos para
prepararlos y migrarlos a Amazon Redshift. Para administrar los agentes de extracción de datos,
puede utilizar la AWS SCT. Para obtener más información, consulte Uso de agentes de extracción de
datos (p. 144).
• Puede utilizar la AWS SCT para crear puntos de conexión y tareas de AWS DMS. Puede ejecutar
y monitorizar estas tareas desde la AWS SCT. Para obtener más información, consulte Uso de la
Herramienta de conversión de esquemas de AWS con el AWS Database Migration Service (p. 143).
• En algunos casos, las características de la base de datos de origen no se pueden convertir a

características de Amazon RDS o Amazon Redshift equivalentes. El asistente de paquete de extensión
de la AWS SCT puede ayudarle a instalar funciones de AWS Lambda y bibliotecas Python para emular
las características que no se puede convertir. Para obtener más información, consulte Uso del paquete
de extensión de la Herramienta de conversión de esquemas de AWS (p. 196).
• Puede utilizar AWS SCT para optimizar su base de datos de Amazon Redshift existente. AWS SCT
recomienda claves de ordenación y distribución para optimizar su base de datos. Para obtener más
información, consulte Optimización de Amazon Redshift mediante la Herramienta de conversión de
esquemas de AWS (p. 129).
Version 1.0
2
Comentarios
• Puede utilizar la AWS SCT para copiar su esquema de base de datos local existente a una instancia
de base de datos de Amazon RDS que ejecute el mismo motor. Puede utilizar esta característica para
analizar posibles ahorros de costos en la migración a la nube y en el cambio del tipo de licencia.
• Puede utilizar la AWS SCT para convertir SQL en su código C++, C #, Java u otro tipo de código
de aplicación. Puede ver, analizar, editar y guardar el código SQL convertido. Para obtener más
información, consulte Conversión de SQL de aplicación con la Herramienta de conversión de esquemas
de AWS (p. 190).
Proporcionar opiniones del cliente

Puede expresar sus comentarios sobre la Herramienta de conversión de esquemas de AWS. Puede
archivar un informe de errores, enviar una solicitud de función o proporcionar información general.
Para hacer llegar sus comentarios sobre la AWS SCT.
1. Inicie Herramienta de conversión de esquemas de AWS.

2. Abra el menú Help y seleccione Leave Feedback. Aparecerá el cuadro de diálogo Leave Feedback.
3. En Area, seleccione Information, Bug report o Feature request.
4. En Source database, seleccione su base de datos de origen. Seleccione Any si sus comentarios no se
refieren a una base de datos en particular.
5. En Target database, seleccione su base de datos de destino. Seleccione Any si sus comentarios no se
refieren a una base de datos en particular.
6. En Title, escriba un título para sus comentarios.
7. En Message, escriba sus comentarios.
8. Seleccione Send para enviar sus comentarios.
Version 1.0
3
Instalación de la AWS SCT
Instalación, verificación y
actualización de Herramienta de
conversión de esquemas de AWS
La Herramienta de conversión de esquemas de AWS (AWS SCT) es una aplicación autónoma que
proporciona una interfaz de usuario basada en proyectos. La AWS SCT está disponible para Fedora Linux,
macOS, Microsoft Windows y Ubuntu Linux versión 15.04. AWS SCT solo es compatible con sistemas
operativos de 64 bits. La AWS SCT instala también Java Runtime Environment (JRE) versión 8u45.
Para asegurar que obtenga la versión correcta del archivo de distribución de la AWS SCT, proporcionamos
los pasos de verificación después de descargar el archivo comprimido. Puede verificar el archivo por medio
de los pasos proporcionados.
Temas
• Instalación de la AWS SCT (p. 4)
• Verificación de la descarga del archivo de AWS SCT (p. 6)
• Instalación de los controladores de bases de datos necesarios (p. 8)
• Actualización del AWS SCT (p. 11)
Instalación de la AWS SCT

Para instalar la AWS SCT
1. Utilice el enlace correspondiente a su sistema operativo para descargar el archivo comprimido que
contiene el instalador de la AWS SCT. Todos los archivos comprimidos tienen la extensión .zip.
Cuando extraiga el archivo del instalador de AWS SCT, tendrá el formato adecuado para su sistema
operativo.
• Microsoft Windows
• Apple macOS
• Ubuntu Linux (.deb)
• Fedora Linux (.rpm)
2. Extraiga el archivo instalador de la AWS SCT para su sistema operativo, según se muestra a
continuación.
Sistema operativo Nombre de archivo
Fedora Linux aws-schema-conversion-tool-1.0.build-number.x86_64.rpm
macOS AWS Schema Conversion Tool-1.0.build-number.dmg
Microsoft Windows AWS Schema Conversion Tool-1.0.build-number.msi
Version 1.0
4
Instalación de versiones anteriores
Ubuntu Linux aws-schema-conversion-tool-1.0.build-number.deb
3. Ejecute el archivo instalador de la AWS SCT extraído en el paso anterior. Utilice las instrucciones para
su sistema operativo, que se muestran a continuación.
Sistema operativo Instrucciones de instalación
Fedora Linux Ejecute el siguiente comando en la carpeta en la que haya descargado el

archivo:
sudo yum install aws-schema-conversion-tool-1.0.build-

number.x86_64.rpm
macOS En Finder, localice y extraiga el archivo zip. En la carpeta extraída, abra

AWS Schema Conversion Tool-1.0.build-number.dmg.
Para completar la instalación, arrastre el icono AWS Schema

Conversion Tool.app a la carpeta Applications (Aplicaciones).
Cierre la ventana de instalación, si está abierta. En el Finder, expulse la

unidad de instalación, si está montada.
Microsoft Windows Haga doble clic en el archivo para ejecutar el instalador.
Ubuntu Linux Ejecute el siguiente comando en la carpeta en la que haya descargado el

archivo:
sudo dpkg -i aws-schema-conversion-tool-1.0.build-

number.deb
4. Instale los controladores de Java Database Connectivity (JDBC) para sus motores de base de datos
de origen y destino. Para obtener instrucciones y enlaces de descarga, consulte Instalación de los
controladores de bases de datos necesarios (p. 8).
Instalación de las versiones anteriores de la AWS SCT

Puede descargar e instalar versiones anteriores de la AWS SCT. Utilice el formato siguiente para
descargar una versión anterior. Debe proporcionar la información de versión y sistema operativo con este
formato.
https://d211wdu1froga6.cloudfront.net/builds/1.0/<version>/<OS>/aws-schema-conversion-
tool-1.0.zip
Por ejemplo, para descargar AWS SCT versión 607, haga lo siguiente:
• MacOS: https://d211wdu1froga6.cloudfront.net/builds/1.0/607/MacOS/aws-schema-conversion-
tool-1.0.zip
• Windows: https://d211wdu1froga6.cloudfront.net/builds/1.0/607/Windows/aws-schema-conversion-
tool-1.0.zip
• Ubuntu: https://d211wdu1froga6.cloudfront.net/builds/1.0/607/Ubuntu/aws-schema-conversion-
tool-1.0.zip
Version 1.0
5
Verificación de la descarga del archivo de AWS SCT
• Fedora: https://d211wdu1froga6.cloudfront.net/builds/1.0/607/Fedora/aws-schema-conversion-
tool-1.0.zip
Verificación de la descarga del archivo de AWS

SCT
Existen varias formas de verificar el archivo de distribución de la AWS SCT. La más sencilla es comparar
la suma de comprobación del archivo con la suma de comprobación publicada de AWS. Como nivel de
seguridad adicional, puede utilizar los procedimientos que aparecen a continuación para verificar el archivo
de distribución, en función del sistema operativo en el que instala el archivo.
Esta sección incluye los siguientes temas.
Temas
• Verificación de la suma de comprobación del archivo de la AWS SCT (p. 6)
• Verificación de los archivos RPM de AWS SCT en Fedora (p. 7)
• Verificación de los archivos DEB de AWS SCT en Ubuntu (p. 7)
• Verificación del archivo MSI de AWS SCT en Microsoft Windows (p. 8)
• Verificación de la aplicación AWS SCT en Mac OS (p. 8)
Verificación de la suma de comprobación del archivo

de la AWS SCT
A fin de detectar los errores que podrían haberse presentado al descargar o almacenar el archivo
comprimido de AWS SCT, puede comparar la suma de comprobación del archivo con un valor
proporcionado por AWS. AWS utiliza el algoritmo SHA256 para la suma de comprobación.
Para verificar el archivo de distribución de AWS SCT mediante una suma de comprobación
1. Descargue el archivo de distribución de AWS SCT mediante los enlaces de la sección de instalación.
2. Descargue el archivo de suma de comprobación, llamado sha256Check.txt. Por ejemplo, el archivo
puede tener un aspecto similar al siguiente:
Fedora b4f5f66f91bfcc1b312e2827e960691c269a9002cd1371cf1841593f88cbb5e6
Ubuntu 4315eb666449d4fcd95932351f00399adb6c6cf64b9f30adda2eec903c54eca4
Windows 6e29679a3c53c5396a06d8d50f308981e4ec34bd0acd608874470700a0ae9a23
MacOs ed56d3ab49309e92ac4d2ef439d35449ac1326f470c23dc5866e1bf0a60b0e67
3. Ejecute el comando de validación SHA256 para su sistema operativo en el directorio que contiene el
archivo de distribución. Por ejemplo, el comando para realizar la ejecución en un sistema operativo
Mac es el siguiente:
shasum -a 256 aws-schema-conversion-tool-1.0.latest.zip
4. Compare los resultados del comando con el valor se muestra en el archivo sha256Check.txt. Los dos
valores deben coincidir.
Version 1.0
6
Verificación de los archivos RPM de AWS SCT en Fedora
Verificación de los archivos RPM de AWS SCT en

Fedora
AWS ofrece otro nivel de validación, además de la suma de comprobación del archivo de distribución.
Todos los archivos RPM en el archivo de distribución están firmados por una clave privada de AWS. La
clave pública de GPG se puede consultar en amazon.com.public.gpg-key.
Para verificar los archivos RPM de AWS SCT en Fedora
2. Verificación de la suma de comprobación del archivo de distribución de AWS SCT.
3. Extraiga el contenido del archivo de distribución. Localice el archivo RPM que desea verificar.
4. Descargue la clave pública de GPG desde amazon.com.public.gpg-key
5. Importe la clave pública a su base de datos RPM (asegúrese de obtener los permisos pertinentes) con
el siguiente comando:
sudo rpm --import aws-dms-team@amazon.com.public.gpg-key
6. Para comprobar que la importación se ha realizado correctamente, ejecute el siguiente comando:
rpm -q --qf "%{NAME}-%{VERSION}-%{RELEASE} \n %{SUMMARY} \n" gpg-pubkey-

ea22abf4-5a21d30c
7. Para comprobar la firma de RPM, ejecute el siguiente comando:
rpm --checksig -v aws-schema-conversion-tool-1.0.build number-1.x86_64.rpm
Verificación de los archivos DEB de AWS SCT en

Ubuntu
Todos los archivos DEB en el archivo de distribución están firmados por una firma separada de GPG.
Para verificar los archivos DEB de AWS SCT en Ubuntu
3. Extraiga el contenido del archivo de distribución. Localice el archivo DEB que desea verificar.
4. Descargue la firma separada de aws-schema-conversion-tool-1.0.latest.deb.asc.
5. Descargue la clave pública de GPG desde amazon.com.public.gpg-key.
6. Para importar la clave GPG pública, ejecute el siguiente comando:
gpg --import aws-dms-team@amazon.com.public.gpg-key
7. Para comprobar la firma, ejecute el siguiente comando:
gpg --verify aws-schema-conversion-tool-1.0.latest.deb.asc aws-schema-conversion-

tool-1.0.build number.deb
Version 1.0
7
Verificación del archivo MSI de
AWS SCT en Microsoft Windows
Verificación del archivo MSI de AWS SCT en Microsoft

Windows
AWS ofrece otro nivel de validación, además de la suma de comprobación del archivo de distribución. El
archivo MSI tiene una firma digital que es posible comprobar a fin de garantizar que fue firmado por AWS.
Para verificar el archivo MSI de AWS SCT en Windows
3. Extraiga el contenido del archivo de distribución. Localice el archivo MSI que desea verificar.
4. En Windows Explorer, haga clic con el botón derecho del ratón en el archivo MSI y seleccione
Properties.
5. Elija la pestaña Digital Signatures.
6. Verifique que la firma digital es de Amazon Services LLC.
Verificación de la aplicación AWS SCT en Mac OS

Una vez que ha instalado AWS SCT en Mac OS, puede verificar la aplicación mediante el siguiente
procedimiento.
Para verificar la aplicación AWS SCT en Mac OS
3. Extraiga el contenido del archivo de distribución.
4. Haga doble clic en el archivo DMG.
5. Instalar la AWS SCT.
6. Para verificar la aplicación, ejecute el siguiente comando:
codesign -dvvv /Applications/AWS\ Schema\ Conversion\ Tool.app/
Instalación de los controladores de bases de datos

necesarios
Para que AWS SCT funcione correctamente, debe instalar los controladores de JDBC para los motores de
base de datos de origen y de destino.
Después de descargar los controladores, aportará la ubicación de los archivos de los controladores. Para
obtener más información, consulte Almacenamiento de rutas a los controladores en la configuración
global (p. 10).
Puede descargar los controladores de la base de datos de las siguientes ubicaciones.

Important
Instale la última versión del controlador disponible. Las versiones de la tabla siguiente son
números de versión de ejemplo.
Version 1.0
8
Instalación de los controladores
de bases de datos necesarios
Motor de base Controladores Ubicación de descarga

de datos
Amazon Aurora mysql-connector-java-5.1.6.jar https://www.mysql.com/products/connector/

(compatible
con MySQL)
Amazon Aurora postgresql-9.4-1204-jdbc42.jar https://jdbc.postgresql.org/download.html

(compatible
con
PostgreSQL)
Amazon RedshiftJDBC41-1.1.10.1010.jar https://docs.aws.amazon.com/redshift/latest/mgmt/

Redshift configure-jdbc-connection.html
Base de datos postgresql-9.4-1204-jdbc42.jar https://jdbc.postgresql.org/

Greenplum
Maria DB mariadb-java-client-2.4.0.jar https://mariadb.com/downloads/#connectors
Microsoft SQL sqljdbc4.jar https://www.microsoft.com/en-us/download/

Server details.aspx?displaylang=en&id=11774
MySQL mysql-connector-java-5.1.6.jar https://www.mysql.com/products/connector/
Netezza nzjdbc.jar http://www.ibm.com/support/knowledgecenter/

SSULQD_7.2.1/com.ibm.nz.datacon.doc/
Utilice el software de las c_datacon_plg_overview.html
herramientas del cliente. Instale
la versión del controlador 7.2.1,
que es compatible con la versión
de data warehouse 7.2.0.
Oracle ojdbc7.jar http://www.oracle.com/technetwork/

database/features/jdbc/jdbc-drivers-12c-
Las versiones del controlador 7 y download-1958347.html
posteriores son compatibles.
PostgreSQL postgresql-9.4-1204-jdbc42.jar https://jdbc.postgresql.org/download.html
SAP ASE jconn4.jar Disponible como parte del SDK para SAP Adaptive
(Sybase ASE) Server Enterprise 16 con el producto SAP ASE.
La versión de prueba del SDK se puede descargar
desde https://www.sap.com/developer/trials-
downloads/additional-downloads/sdk-for-sap-
adaptive-server-enterprise-16-13351.html
Teradata terajdbc4.jar https://downloads.teradata.com/download/

connectivity/jdbc-driver
tdgssconfig.jar
Vertica vertica-jdbc-7.2.3-0_all https://my.vertica.com/download/vertica/client-

drivers/
Las versiones del controlador
7.2.0 y posteriores son
compatibles.
Version 1.0
9
Instalación de controladores de JDBC en Linux
Instalación de controladores de JDBC en Linux

Puede seguir estos pasos para instalar los controladores de JDBC en su sistema Linux para usarlos con la
AWS SCT.
Para instalar los controladores de JDBC en su sistema Linux
1. Cree un directorio para almacenar los controladores de JDBC.
PROMPT>sudo mkdir –p /usr/local/jdbc-drivers
2. Instale el controlador de JDBC para el motor de su base de datos con los comandos que se muestran
a continuación.
Motor de base de Comandos de instalación

datos
Amazon Aurora
PROMPT> cd /usr/local/jdbc-drivers
(compatible con PROMPT> sudo tar xzvf /tmp/mysql-connector-java-X.X.X.tar.gz
MySQL)
Amazon Aurora
(compatible con PROMPT> sudo cp -a /tmp/postgresql-X.X.X.jre7.tar .
PostgreSQL)
Microsoft SQL Server

PROMPT> sudo tar xzvf /tmp/sqljdbc_X.X.X_enu.tar.gz
MySQL
PROMPT> sudo tar xzvf /tmp/mysql-connector-java-X.X.X.tar.gz
Oracle
PROMPT> sudo mkdir oracle-jdbc
PROMPT> cd oracle-jdbc
PROMPT> sudo cp -a /tmp/ojdbc7.jar .
PostgreSQL
PROMPT> sudo cp -a /tmp/postgresql-X.X.X.jre7.tar .
Almacenamiento de rutas a los controladores en la

configuración global
Después de descargar e instalar los controladores de JDBC, puede configurar la ubicación de los
controladores globalmente en la configuración de la AWS SCT. Si no configura la ubicación de los
controladores globalmente, la aplicación le pedirá la ubicación de los controladores al conectarse a una
base de datos.
Para actualizar las ubicaciones de los archivos de los controladores
1. En la AWS SCT, elija Settings (Configuración) y, a continuación, elija Global Settings (Configuración
global).
Version 1.0
10
Actualización del AWS SCT
2. En Global settings, seleccione Drivers. Agregue la ruta al archivo del controlador de JDBC para su
motor de base de datos de origen y su motor de base de datos de la instancia de base de datos de
Amazon RDS de destino.
Note
Para Teradata, debe especificar dos controladores separados por un punto y coma.
3. Cuando haya terminado de agregar las rutas de los controladores, seleccione OK.
Actualización del AWS SCT

AWS actualiza periódicamente la AWS SCT con nuevas características y funciones. Si está actualizando
desde una versión anterior, cree un proyecto nuevo de AWS SCT y vuelva a convertir los objetos de la
base de datos que está utilizando.
Puede comprobar si existen actualizaciones para la AWS SCT.
Para buscar actualizaciones de AWS SCT
1. Cuando esté en la AWS SCT, elija Help (Ayuda) y, a continuación, elija Check for Updates
(Comprobar actualizaciones).
2. En el cuadro de diálogo Check for Updates, elija What's New. Si el enlace no aparece, tiene la versión
más reciente.
Version 1.0
11
La ventana de proyecto de AWS SCT
Uso de la interfaz de usuario de

la Herramienta de conversión de
esquemas de AWS
En las siguientes secciones le ayudaremos a trabajar con la interfaz de usuario de AWS SCT. Para
obtener información sobre la instalación de AWS SCT, consulte Instalación, verificación y actualización de
Herramienta de conversión de esquemas de AWS (p. 4).
Temas
• La ventana de proyecto de AWS SCT (p. 12)
• Uso de los perfiles del servicio de AWS en la Herramienta de conversión de esquemas de
AWS (p. 13)
• Almacenamiento de la contraseña de la base de datos (p. 16)
• Uso de la vista UNION ALL en proyectos con tablas con particiones (p. 16)
• Uso de los filtros de árbol de AWS SCT (p. 17)
• Ocultar esquemas en la vista de árbol de la AWS SCT (p. 19)
• Métodos abreviados de teclado de AWS SCT (p. 20)
• Crear y revisar el informe de evaluación de la migración de la base de datos (p. 21)
• Iniciar la Herramienta de conversión de esquemas de AWS (p. 24)
• Creación de un proyecto de Herramienta de conversión de esquemas de AWS (p. 25)
• Conversión de su esquema (p. 26)
• Aplicación del esquema convertido a su instancia de base de datos de destino (p. 28)
La ventana de proyecto de AWS SCT

A continuación se ilustra lo que se puede ver en la AWS SCT al crear un proyecto de migración de
esquema y convertir un esquema posteriormente.
1. En el panel izquierdo, el esquema de la base de datos de origen se presenta en una vista en árbol. Su
esquema de base de datos se "carga en diferido". Dicho de otra manera, al seleccionar un elemento de
la vista en árbol, la AWS SCT obtiene y muestra el esquema actual de su base de datos de origen.
2. En el panel superior central, aparecerán los elementos de acción para los elementos del esquema del
motor de la base de datos de origen que no se hayan podido convertir automáticamente al motor de la
base de datos de destino.
3. En el panel derecho, el esquema de su instancia de base de datos de destino se presenta en una
vista en árbol. Su esquema de base de datos se "carga en diferido". Es decir, en el momento en que
selecciona un elemento de la vista en árbol, la AWS SCT obtiene y muestra el esquema actual de su
base de datos de destino.
Version 1.0
12
Almacenamiento de perfiles de AWS
4. En el panel inferior izquierdo, cuando se elige un elemento de esquema, se muestran las propiedades
que describen el elemento de esquema de origen y el comando SQL para crear ese elemento en la
base de datos de origen.
5. En el panel inferior derecho, cuando se elige un elemento de esquema, se muestran las propiedades
que describen el elemento de esquema de destino y el comando SQL para crear ese elemento en la
base de datos de destino. Puede editar este comando SQL y guardar el comando actualizado con su
proyecto.
Uso de los perfiles del servicio de AWS en la

Herramienta de conversión de esquemas de AWS
Puede almacenar sus credenciales de AWS en la Herramienta de conversión de esquemas de AWS. AWS
SCT utiliza sus credenciales al recurrir a características que se integran con los servicios de AWS. Por
ejemplo, AWS SCT se integra con Amazon S3, AWS Lambda, Amazon Relational Database Service y
AWS Database Migration Service.
Version 1.0
13
Almacenamiento de las credenciales de AWS
AWS SCT le solicita sus credenciales de AWS al obtener acceso a una característica que las necesite.
Puede almacenar sus credenciales en los ajustes globales de la aplicación. Cuando AWS SCT le pida sus
credenciales, puede seleccionar las credenciales almacenadas.
Puede almacenar distintos conjuntos de credenciales de AWS en los ajustes globales de la aplicación. Por
ejemplo, puede almacenar un conjunto de credenciales que utilice en situaciones de prueba y un conjunto
de credenciales diferente que utilice en situaciones de producción. También puede almacenar diferente
credenciales para diferentes regiones de AWS.

Utilice el siguiente procedimiento para almacenar las credenciales de AWS de manera global.
Para almacenar credenciales de AWS

2. Abra el menú Settings y seleccione Global Settings. Aparecerá el cuadro de diálogo Global Settings.
Seleccione AWS Service Profiles como se muestra a continuación.
3. Seleccione Add new AWS Service Profile.

4. Introduzca su información de AWS como sigue.
Opción de AWS SCT Acción
Schema/Database Elija el nombre del esquema y la base de datos que desea utilizar como
Name filtro. En el nombre del esquema, puede introducir “%” para seleccionar
todos los esquemas.
Version 1.0
14
a. En Profile name, escriba un nombre para su perfil.

b. En AWS Access Key, escriba su clave de acceso de AWS.
c. En AWS Secret Key, escriba su clave secreta de AWS.
d. En Region, seleccione la región para su perfil.
e. En S3 Bucket (Bucket de S3), seleccione el bucket de Amazon S3 para su perfil. Solo tiene que
especificar un bucket si está utilizando una característica que se conecte a S3.
f. Seleccione Use FIPS endpoint for S3 si tiene que cumplir con los requisitos de seguridad del
Estándar federal de procesamiento de la información (FIPS, Federal Information Processing
Standard). Hay puntos de enlace de FIPS en las siguientes regiones de AWS:
• Región EE.UU. Este (Norte de Virginia)

• Región EE.UU Este (Ohio)
• EE.UU. Oeste (Norte de California)
• Región EE.UU. Oeste (Oregón)
5. Seleccione Test Connection para comprobar que sus credenciales sean correctas y estén activas.
Aparecerá el cuadro de diálogo Test Connection. Podrá ver el estado de cada uno de los servicios
conectados a su perfil. Pass indica que el perfil puede obtener acceso al servicio correctamente.
Version 1.0
15
Configuración del perfil predeterminado para un proyecto
6. Tras haber configurado su perfil, seleccione Save para guardar su perfil o Cancel para cancelar los
cambios.
7. Seleccione OK para cerrar el cuadro de diálogo Global Settings.
Configuración del perfil predeterminado para un

proyecto
Puede configurar el perfil predeterminado para un proyecto de AWS SCT. Al hacerlo, asociará las
credenciales de AWS almacenadas en el perfil con el proyecto. Con el proyecto abierto, utilice el siguiente
procedimiento para configurar el perfil predeterminado.
Para configurar el perfil predeterminado para un proyecto

2. Abra el menú Settings y seleccione Project Settings. Aparecerá el cuadro de diálogo Current project
settings.
3. Seleccione la pestaña Project Environment.
4. En AWS Service Profile, seleccione el perfil que quiera asociar con el proyecto.
5. Seleccione OK para cerrar el cuadro de diálogo Current project settings. También puede seleccionar
Cancel para cancelar los cambios.
Almacenamiento de la contraseña de la base de

datos
Puede almacenar un certificado SSL o una contraseña de la base de datos en la caché de la AWS SCT.
Para almacenar una contraseña, seleccione Store Password al crear una conexión.
La contraseña se cifra mediante un token generado de forma aleatoria en el archivo seed.dat. A

continuación, la contraseña se almacena con el nombre del usuario en el archivo en la memoria caché. Si
pierde el archivo seed.dat o resulta dañado, puede que la contraseña de la base de datos se descifre de
forma incorrecta. En este caso, la conexión produce un error.
Uso de la vista UNION ALL en proyectos con tablas

con particiones
Si una tabla de origen tiene particiones, AWS SCT crea n tablas de destino, donde n es el número de
particiones de la tabla de origen. AWS SCT crea una vista UNION ALL sobre las tablas de destino para
representar la tabla de origen. Si utiliza un extractor de datos de AWS SCT para migrar los datos, las
particiones de la tabla de origen se extraerán y cargarán en paralelo mediante subtareas independientes.
Para usar la vista UNION ALL en un proyecto
1. Start AWS SCT. Elija un proyecto de almacén de datos (OLAP).

2. Seleccione Settings (Configuración) y después Project settings (Configuración del proyecto).
Aparecerá el cuadro de diálogo Current project settings.
Version 1.0
16
Filtros de árbol de AWS SCT
3. Seleccione Use Union all view (Usar vista UNION ALL).

4. Seleccione OK (Aceptar) para guardar la configuración y cerrar el cuadro de diálogo Current project
settings (Configuración del proyecto actual).
Uso de los filtros de árbol de AWS SCT

Para migrar datos de un origen a un destino, AWS SCT carga todos los metadatos de las bases de datos
de origen y de destino en una estructura de árbol. Esta estructura aparece en la AWS SCT como la vista
de árbol en la ventana del proyecto principal.
Algunas bases de datos puede tener un gran número de objetos en la estructura de árbol. Puede utilizar
filtros de árbol en la AWS SCT para buscar objetos en las estructuras de árbol de origen y de destino.
Cuando utiliza un filtro de árbol, no cambia los objetos que se convierten al convertir la base de datos. El
filtro cambia únicamente lo que se ve en el árbol.
Los filtros de árbol funcionan con objetos que la AWS SCT ha precargado. En otras palabras, la AWS SCT
no carga objetos de la base de datos durante las búsquedas. Este enfoque significa que la estructura de
árbol, por lo general, contiene menos objetos que los que están presentes en la base de datos.
Cuando utilice filtros de árbol, tenga en cuenta lo siguiente:
• El valor predeterminado del filtro es ANY, lo que significa que el filtro utiliza una búsqueda de nombre
para encontrar objetos.
• Al seleccionar uno o varios tipos de objeto, verá solo esos tipos de objetos en el árbol.
• Puede utilizar el filtro enmascarar para mostrar diferentes tipos de símbolos, incluidos Unicode, espacios
y caracteres especiales. El carácter “%” sirve de comodín para cualquier símbolo.
• Después de aplicar un filtro, el recuento solo muestra el número de objetos filtrados.
Para crear un filtro de árbol
1. Abrir un proyecto de AWS SCT existente.

2. Conéctese a la base de datos a la que desea aplicar el filtro de árbol.
3. Elija el icono de filtro.
Note
El icono de deshacer filtro está difuminado porque no hay ningún filtro aplicado en la
actualidad.
4. Introduzca la siguiente información en el cuadro de diálogo Tree Filter. Las opciones en el cuadro de
diálogo son diferentes para cada motor de base de datos.
Version 1.0
17
Filtros de árbol de AWS SCT
Opción de AWS SCT Acción
Schema/Database Elija el nombre del esquema y la base de datos que desea utilizar como
Name filtro. En el nombre del esquema, puede introducir “%” para seleccionar
todos los esquemas.
Nombre del objeto Elija el nombre de objeto si desea buscar por nombre de objeto.
Tree States Seleccione el estado de la tabla. Las opciones incluyen:
• Any (Cualquiera): – Muestra todas las tablas.

• Converted (Convertidas): – Muestra solo las tablas convertidas.
• Not Converted (No convertidas): – Muestra solo las tablas que no se han
convertido.
• Has Actions (Tiene acciones): – Muestra las tablas con acciones
pendientes.
Lista de tipos de objeto Seleccione objetos de la lista de tipos de objeto que puede utilizar como
filtro. Amplíe los nodos del árbol para cargar más objetos a la lista de tipos
de objeto.
5. Seleccione Apply. Después de seleccionar Apply, se activa el icono de deshacer filtro (al lado del
icono de filtro). Utilice este icono si desea eliminar los filtros que aplicó.
6. Seleccione Close para cerrar el cuadro de diálogo.
Version 1.0
18
Importación de una lista de archivos para el filtro de árbol
Al filtrar el esquema que aparece en el árbol, no cambia los objetos que se convierten al convertir su
esquema. El filtro cambia únicamente lo que se ve en el árbol.
Importación de una lista de archivos para el filtro de

árbol
Puede importar un archivo que contenga los nombres o valores que quiere que utilice el filtro de árbol. En
este archivo, se utilizan las siguientes convenciones:
• Object es el tipo de objeto que desea encontrar.

• Database es el nombre de la base de datos donde existe este objeto.
• Schema es el nombre del esquema donde existe este objeto.
• Name es el nombre del objeto.
El archivo que se va a importar debe tener el siguiente formato:
• Object;Database;Schema;Name: – Este formato es obligatorio para los dialectos Microsoft SQL

Server, SQL Data Warehouse y Netezza de SQL.
• Object;Schema;Name: – Utilice este formato para otros dialectos de SQL.
Para importar una lista de archivos para el filtro de árbol
1. Abra un proyecto de la AWS SCT existente, conéctese a la base de datos a la que desea aplicar el
filtro de árbol y, a continuación, elija el icono de filtro.
2. Seleccione la pestaña Import File List.

3. Seleccione Import File.
4. Seleccione un archivo para importar y, luego, seleccione Open.
5. Seleccione Apply y, a continuación, seleccione Close.
Ocultar esquemas en la vista de árbol de la AWS

SCT
Al utilizar la configuración de vista de árbol, especifica qué esquemas y bases de datos desea ver en la
vista de árbol de la AWS SCT. Puede ocultar esquemas vacíos, bases de datos vacías, bases de datos del
sistema y bases de datos y esquemas definidos por el usuario.
Para ocultar bases de datos y esquemas en la vista de árbol
1. Abra un proyecto de AWS SCT.

2. Conéctese al almacén de datos que desea mostrar en la vista de árbol.
3. Seleccione Settings, Global Settings, Tree View.
Version 1.0
19
Métodos abreviados de teclado
4. En la sección Tree View Settings, siga estos pasos:
• Para Hide System Databases/Schemas, seleccione los esquemas y las bases de datos del sistema
por nombre para ocultarlos.
• Para Hide User Defined Databases/Schemas, escriba los nombres de las bases de datos y
esquemas definidos por el usuario que desee ocultar y, a continuación, seleccione Add. Los
nombres no distinguen entre mayúsculas y minúsculas.
• Seleccione Reset to Default para restablecer la vista de árbol a la configuración predeterminada.
5. Seleccione OK.
Métodos abreviados de teclado de AWS SCT

A continuación presentamos los métodos abreviados de teclado que puede utilizar con AWS SCT.
Método abreviado del teclado Descripción
Ctrl+N Crear un nuevo proyecto.
Ctrl+O Abrir un proyecto existente.
Ctrl+S Guardar un proyecto abierto.
Ctrl+W Crear un nuevo proyecto con el asistente.
Ctrl+L Conectarse a la base de datos de origen.
Ctrl+R Conectarse a la base de datos de destino.
Version 1.0
20
El informe de evaluación de la migración de la base de datos
Crear y revisar el informe de evaluación de la

migración de la base de datos
El informe de evaluación de la migración de la base de datos resume todos los elementos de acción del
esquema que no se pueden convertir automáticamente en el motor de su instancia de base de datos de
Amazon RDS de destino. El informe incluye también estimaciones de la cantidad de esfuerzo necesario
para escribir el código equivalente de la instancia de base de datos de destino.
Puede crear (o actualizar) un informe de evaluación de la migración de la base de datos en su proyecto en

cualquier momento utilizando el siguiente procedimiento.
Para crear y ver el informe de evaluación de la migración de la base de datos
1. En el panel de la izquierda que muestra el esquema de la base de datos de origen, elija el objeto del
esquema para el que desea crear un informe de evaluación. Abra el menú contextual (clic secundario)
para el objeto y seleccione Create Report.
Se abrirá la vista del informe de evaluación.

2. Haga clic en la pestaña Action Items.
La pestaña Action Items muestra una lista de elementos que describen el esquema que no puede
convertirse automáticamente. Seleccione uno de los elementos de acción de la lista. AWS SCT resalta
el elemento en el esquema al que se aplica el elemento de acción, como se muestra a continuación.
Version 1.0
21
3. Haga clic en la pestaña Summary.
En la pestaña Summary se muestra la información resumida del informe de evaluación de la migración

de la base de datos. Muestra el número de elementos convertidos automáticamente y el número de
elementos que no se han convertido automáticamente. El resumen también incluye un cálculo del
tiempo que se tardará en crear esquemas en su instancia de base de datos de destino que sean
equivalentes a los de la base de datos de origen.
La sección License Evaluation and Cloud Support contiene información sobre el traslado de sus
esquemas de bases de datos locales existentes a una instancia de base de datos de Amazon RDS
que ejecute el mismo motor. Por ejemplo, si desea cambiar tipos de licencia, esta sección del informe
le indica qué características de su base de datos actual deberían eliminarse.
A continuación se muestra un ejemplo de un resumen de informe de evaluación.
Version 1.0
22
4. Seleccione la pestaña Summary y, después, seleccione Save to PDF. El informe de evaluación de la

migración de la base de datos se guarda como archivo PDF. El archivo PDF contiene tanto el resumen
como información de elementos de acción.
También puede hacer clic en Save to CSV para guardar el informe como un archivo con valores
separados por comas (CSV). El archivo CSV contiene solamente información de elementos de acción.
Version 1.0
23
Iniciar la SCT
Iniciar la Herramienta de conversión de esquemas

de AWS
Para iniciar la Herramienta de conversión de esquemas de AWS, utilice las instrucciones para su sistema
operativo, que se muestran a continuación.
Sistema operativo Instrucciones
Fedora Linux Ejecute el comando siguiente:
/opt/AWSSchemaConversionTool/AWSSchemaConversionTool
Microsoft Windows Haga doble clic en el icono de la aplicación.
Version 1.0
24
Creación de un proyecto
Sistema operativo Instrucciones
Ubuntu Linux Ejecute el comando siguiente:
/opt/AWSSchemaConversionTool/AWSSchemaConversionTool
Creación de un proyecto de Herramienta de

El siguiente procedimiento muestra cómo crear un proyecto Herramienta de conversión de esquemas de
AWS.
Para crear su proyecto

2. Seleccione New Project en el menú File. Aparece el cuadro de diálogo New Project.
3. Agregue la siguiente información preliminar del proyecto.
Para este parámetro Haga lo siguiente
Project Name Escriba un nombre para su proyecto, que se almacenará

localmente en su equipo.
Ubicación Escriba la ubicación del archivo local de su proyecto.
Seleccione Transactional Database (OLTP) o Data Warehouse

(OLAP).
Source DB Engine (OLTP) Seleccione Microsoft SQL Server, MySQL, Oracle o

PostgreSQL.
(OLAP) Seleccione Amazon Redshift, Greenplum, Microsoft SQL

Server DW, Netezza, Oracle DW, Teradata o Vertica.
Target DB Engine (OLTP) Seleccione Amazon Aurora (MySQL compatible), Amazon

Aurora (PostgreSQL compatible), Amazon RDS for Microsoft
Version 1.0
25
Conversión de su esquema

SQL Server, Amazon RDS for MySQL, Amazon RDS for Oracle o
Amazon RDS for PostgreSQL.
(OLAP) Seleccione Amazon Redshift.
4. Elija OK (Aceptar) para crear su proyecto de AWS SCT.
Utilice el siguiente procedimiento para convertir un esquema.
Para convertir un esquema
1. Haga clic en View y, a continuación, seleccione Main View.
2. En el panel de la izquierda que muestra el esquema de la base de datos de origen, seleccione un

objeto del esquema para convertirlo. Abra el menú contextual (clic secundario) para el objeto y
seleccione Convert schema.
Version 1.0
26
3. Cuando la AWS SCT termina de convertir el esquema, puede ver el esquema propuesto en el panel a
la derecha del proyecto.
En este momento, no se aplica ningún esquema a su instancia de base de datos de Amazon RDS
de destino. El esquema planificado es parte de su proyecto. Si selecciona un elemento del esquema
convertido, podrá ver el comando de esquema previsto en el panel de la parte inferior en el centro de
la instancia de base de datos de Amazon RDS de destino.
Puede editar el esquema en esta ventana. El esquema editado se almacena como parte de su
proyecto y estará escrito en la instancia de base de datos de destino cuando decida aplicar su
esquema convertido.
Version 1.0
27
Aplicación del esquema convertido a su
instancia de base de datos de destino
Aplicación del esquema convertido a su instancia

de base de datos de destino
Puede aplicar el esquema de base de datos convertido a su instancia de base de datos de Amazon RDS
de destino. Después de haber aplicado el esquema a su instancia de base de datos de destino, podrá
actualizar el esquema en función de los elementos de acción del informe de evaluación de la migración de
la base de datos.
Warning
Este procedimiento sobrescribe el esquema de destino existente. Tenga cuidado de no

sobrescribir involuntariamente el esquema. Tenga cuidado de no sobrescribir el esquema de su
instancia de base de datos de destino que ya haya modificado, o reemplazará dichos cambios.
Para aplicar el esquema de base de datos convertido a su instancia de base de datos de Amazon
RDS de destino
1. Seleccione el elemento del esquema del panel derecho del proyecto que indique el esquema previsto
para su instancia de base de datos de destino.
2. Abra el menú contextual (clic con el botón secundario) del elemento del esquema y seleccione Apply
to database.
Version 1.0
28
Aplicación del esquema convertido a su
instancia de base de datos de destino
El esquema convertido se aplica a la instancia de base de datos de destino.
Version 1.0
29
Introducción a Herramienta de
Puede utilizar la Herramienta de conversión de esquemas de AWS (AWS SCT) para convertir el esquema
de la base de datos de origen a un esquema para bases de datos hospedadas en Amazon Web Services
(AWS). La aplicación AWS SCT ofrece una interfaz de usuario basada en proyectos. Casi todo el trabajo
que realice con AWS SCT comenzará por los siguientes pasos:
1. Instale AWS SCT. Para obtener más información, consulte Instalación, verificación y actualización de
2. Instale un agente de AWS SCT, si es necesario. Los agentes de AWS SCT solo son necesarios para
determinadas situaciones de migración como, por ejemplo, entre orígenes y destinos heterogéneos.
Para obtener más información, consulte Uso de agentes de extracción de datos (p. 144).
3. Familiarizarse con la interfaz de usuario de AWS SCT. Para obtener más información, consulte Uso de
la interfaz de usuario de la Herramienta de conversión de esquemas de AWS (p. 12).
4. Cree un proyecto de AWS SCT. Conéctese a las bases de datos de origen y destino. Para obtener más
información acerca de la conexión a la base de datos de origen, consulte Bases de datos de origen para
5. Ejecutar y consultar el informe de evaluación de la migración de la base de datos. Para obtener más
información sobre el informe de evaluación, consulte Crear y revisar el informe de evaluación de la
migración de la base de datos (p. 21).
6. Convertir los esquemas de base de datos de origen. Existen varios aspectos de la conversión que
debe tener en cuenta, por ejemplo, qué se debe hacer con los elementos que no se convierten y cómo
mapear los elementos que se deben convertir de una forma concreta. Para obtener más información
acerca de la conversión de un esquema de origen, consulte Convertir los esquemas de base de datos
utilizando el Herramienta de conversión de esquemas de AWS (p. 99).
Si va a convertir un esquema de almacenamiento de datos, también hay aspectos que debe tener
en cuenta antes de realizar la conversión. Para obtener más información, consulte Conversión de
esquemas de almacén de datos a Amazon Redshift utilizando la Herramienta de conversión de
7. Aplicar la conversión de esquema al destino. Para obtener más información acerca de la aplicación
de la conversión de esquemas de origen, consulte Uso de la interfaz de usuario de la Herramienta de
conversión de esquemas de AWS (p. 12).
8. AWS SCT también se puede utilizar para convertir procedimientos almacenados de SQL y otro código
de aplicación. Para obtener más información, consulte Conversión de SQL de aplicación con la
Herramienta de conversión de esquemas de AWS (p. 190)
También puede utilizar AWS SCT para migrar los datos de una base de datos de origen a una base de
datos administrada por Amazon.
Version 1.0
30
Uso de Oracle como origen para Herramienta
de conversión de esquemas de AWS
Bases de datos de origen para

Herramienta de conversión de
esquemas de AWS
Herramienta de conversión de esquemas de AWS (AWS SCT) puede convertir los siguientes esquemas
de base de datos de origen a una base de datos de destino. Seleccione el enlace siguiente para obtener
información sobre permisos necesarios, información de conexión e información sobre lo que puede
convertir AWS SCT para su uso con la base de datos de destino.
Temas
• Uso de Oracle como origen para Herramienta de conversión de esquemas de AWS (p. 31)
• Uso de Microsoft SQL Server como origen para Herramienta de conversión de esquemas de
AWS (p. 45)
• Utilizar MySQL como origen para Herramienta de conversión de esquemas de AWS (p. 55)
• Utilizar PostgreSQL como origen para Herramienta de conversión de esquemas de AWS (p. 57)
• Uso de Db2 LUW como origen para Herramienta de conversión de esquemas de AWS (p. 60)
• Uso de Amazon Redshift como origen de Herramienta de conversión de esquemas de AWS (p. 65)
• Utilizar Oracle DW como origen para Herramienta de conversión de esquemas de AWS (p. 67)
• Utilizar Teradata como origen para Herramienta de conversión de esquemas de AWS (p. 70)
• Utilizar Netezza como origen para Herramienta de conversión de esquemas de AWS (p. 73)
• Utilizar Greenplum como origen para Herramienta de conversión de esquemas de AWS (p. 75)
• Utilizar Vertica como origen para Herramienta de conversión de esquemas de AWS (p. 77)
• Uso de Microsoft SQL Server DW como origen para Herramienta de conversión de esquemas de
AWS (p. 79)
Uso de Oracle como origen para Herramienta de

Puede utilizar AWS SCT para convertir datos de Oracle a los siguientes destinos:
• Amazon RDS for MySQL

• Amazon Aurora (MySQL)
• Amazon RDS for PostgreSQL
• Amazon Aurora (PostgreSQL)
• Amazon RDS for Oracle
Cuando el origen es una base de datos de Oracle, los comentarios pueden convertirse al formato
adecuado, por ejemplo, una base de datos PostgreSQL. AWS SCT puede convertir los comentarios en
Version 1.0
31
Permisos necesarios para Oracle como origen
tablas, vistas y columnas. Los comentarios pueden incluir apóstrofos; AWS SCT duplica los apóstrofos al
convertir instrucciones SQL, del mismo que con los literales de cadena.
Para obtener más información, consulte las siguientes secciones:
Temas
• Permisos necesarios al usar Oracle como base de datos de origen (p. 32)
• Conexión a Oracle como base de datos de origen (p. 32)
• Conversión de Oracle a Amazon RDS for PostgreSQL o Amazon Aurora (PostgreSQL) (p. 35)
• Conversión de Oracle a Amazon RDS for MySQL o Amazon Aurora (MySQL) (p. 38)
• Conversión de Oracle a Amazon RDS for Oracle (p. 42)
Permisos necesarios al usar Oracle como base de

datos de origen
Los privilegios necesarios para Oracle como origen se enumeran a continuación:
• CONNECT
• SELECT_CATALOG_ROLE
• SELECT ANY DICTIONARY
• SELECT on SYS.USER$ TO <sct_user>
Conexión a Oracle como base de datos de origen

Utilice el siguiente procedimiento para conectarse a su base de datos de Oracle de origen con la
Herramienta de conversión de esquemas de AWS.
Para conectarse a una base de datos de Oracle de origen
1. En la Herramienta de conversión de esquemas de AWS, seleccione Connect to Oracle (Conectar a

Oracle).
Aparecerá el cuadro de diálogo Connect to Oracle.
Version 1.0
32
Conexión a Oracle como origen
2. Proporcione la información de conexión de la base de datos de Oracle de origen. Utilice las

instrucciones de la siguiente tabla.
Type Seleccione el tipo de conexión a la base de datos. En función de

su tipo, proporcione la siguiente información adicional:
• SID
• Server name: el nombre DNS o la dirección IP de su servidor
de base de datos de origen.
• Server port: el puerto que utilice para conectarse al servidor
de su base de datos de origen.
• Oracle SID: el ID del sistema (SID) de Oracle. Para encontrar
el SID de Oracle, envíe la siguiente consulta a su base de
datos de Oracle:
SELECT sys_context('userenv','instance_name')
AS SID FROM dual;
• Nombre del servicio
• Service Name: el nombre del servicio de Oracle al que
conectarse.
• TNS Alias
• TNS file path: la ruta al archivo que contiene la información
de conexión del nombre Transparent Network Substrate
(TNS).
• TNS file path: el alias TNS de este archivo que utilizar para
conectarse a la base de datos de origen.
Version 1.0
33
Conexión a Oracle como origen

• TNS Connect Identifier
• TNS identifier: identificador de la información de conexión del
TNS registrado.
User name y Password Escriba el nombre de usuario y la contraseña para conectarse a

su servidor de base de datos de origen.
La primera vez que se conecte a la base de datos de

Oracle, tiene que escribir la ruta al archivo del controlador
de Oracle (ojdbc7.jar). Puede descargar el archivo en
http://www.oracle.com/technetwork/database/features/jdbc/
index-091264.html. Debe registrarse el sitio web gratuito Oracle
Technical Network para completar la descarga. AWS SCT utiliza
el controlador seleccionado para las futuras conexiones de base
de datos de Oracle. La ruta del controlador se puede modificar
mediante la pestaña Drivers (Controladores) en la configuración
global.
Note
AWS SCT utiliza la contraseña para conectarse a su

base de datos de origen solamente cuando crea su
proyecto o selecciona la opción Connect to source
(Conectar a origen) en un proyecto, donde origen es la
base de datos de origen. Para evitar que la contraseña
de su base de datos de origen quede expuesta, la AWS
SCT no la almacena. Si cierra su proyecto de la AWS
SCT y vuelve a abrirlo, se le solicitará la contraseña para
conectarse a su base de datos de origen, según sea
necesario.
Use SSL Seleccione esta opción si desea utilizar SSL para conectarse a
la base de datos. Proporcione la siguiente información adicional,
según proceda, en la pestaña SSL:
• SSL Authentication (Autenticación SSL): seleccione esta opción

para utilizar la autenticación SSL mediante certificado para la
conexión en lugar de nombre de usuario y contraseña.
• Trust Store: la ubicación de un almacén de confianza que
contenga certificados.
• Trust Store Password: contraseña del almacén de confianza.
• Key Store: la ubicación de un almacén de claves que contenga
una clave privada y certificados. Este valor es obligatorio si está
seleccionado SSL Authentication. De lo contrario, es opcional.
• Trust Store Password: contraseña del almacén de claves. Este
valor es obligatorio si está seleccionado SSL Authentication. De
lo contrario, es opcional.
Store Password La AWS SCT crea un almacén seguro para almacenar

certificados SSL y contraseñas de la base de datos. Puede
habilitar esta opción para almacenar la contraseña de la base de
datos y conectarse rápidamente a la base de datos sin necesidad
de introducir la contraseña.
Version 1.0
34
Oracle a PostgreSQL
Oracle Driver Path Escriba la ruta al controlador que quiere usar para conectarse
a la base de datos de origen. Para obtener más información,
consulte Instalación de los controladores de bases de datos
necesarios (p. 8).
Si almacena la ruta al controlador en la configuración global del

proyecto, la ruta del controlador no aparecerá en el cuadro de
diálogo de conexión. Para obtener más información, consulte
Almacenamiento de rutas a los controladores en la configuración
global (p. 10).
3. Seleccione Test Connection para comprobar que pueda conectarse correctamente a su base de datos
de origen.
4. Seleccione OK para conectarse a su base de datos de origen.
Conversión de Oracle a Amazon RDS for PostgreSQL

o Amazon Aurora (PostgreSQL)
AWS SCT puede convertir archivos SQL*Plus a PSQL. El informe de evaluación muestra cómo ha
convertido AWS SCT los archivos SQL*Plus a PSQL. Para convertir archivos SQL*Plus en PSQL, consulte
Conversión de SQL de aplicación con la Herramienta de conversión de esquemas de AWS (p. 190).
Esta sección abarca los siguientes temas:
Temas
• Conversión de pseudocolumnas ROWID de Oracle a PostgreSQL (p. 36)
• Conversión de SQL dinámico para migraciones de Oracle a PostgreSQL. (p. 36)
• Conversión de particiones de Oracle a particiones de PostgreSQL versión 10 (p. 37)
Al convertir objetos del sistema de Oracle a PostgreSQL, AWS SCT convierte lo siguiente:
Objeto del sistema de Descripción Objeto de PostgreSQL

Oracle convertido
V$VERSION Muestra los números de versión de los componentes aws_oracle_ext.v

de biblioteca principal en la base de datos de Oracle $version
V$INSTANCE Una vista que muestra el estado de la instancia actual. aws_oracle_ext.v

$instance
Una vez que AWS SCT migra los objetos del esquema y los datos almacenados, el flujo de trabajo de la
base de datos de origen se puede redireccionar al destino. En la mayoría de los casos, los flujos de trabajo
son números únicos generados por secuencias de bases de datos para mantener las restricciones de
integridad, como las claves principales y las claves únicas de los datos escritos en la base de datos de
destino. Esto significa que los valores nuevos de una secuencia migrada y los valores generados antes de
la migración no deben superponerse.
En los proyectos de migración de Oracle a PostgreSQL, puede asegurarse de que no se superponen. Para
ello, seleccione la opción Populate converted sequences with the last values generated on the source side
(Rellenar las secuencias convertidas con los últimos valores generados en el origen) en la pestaña de
ajustes de conversión de Project Settings (Configuración del proyecto).
Version 1.0
35
Oracle a PostgreSQL
Conversión de pseudocolumnas ROWID de Oracle a PostgreSQL

En una base de datos de Oracle, la pseudocolumna ROWID contiene la dirección de la fila de la tabla. La
pseudocolumna ROWID es exclusiva de Oracle. Por ello, AWS SCT puede convertir la pseudocolumna
ROWID en una columna de datos al convertir a PostgreSQL. Esta conversión permite conservar la
información de ROWID.
Cuando AWS SCT convierte la pseudocolumna ROWID, crea una columna de datos con el tipo de datos
BIGINT. Si no hay una clave primaria, AWS SCT establece la columna ROWID como la clave principal. Si
hay una clave primaria, AWS SCT establece la columna ROWID con una restricción única.
Para crear una columna de datos para la pseudocolumna ROWID de Oracle en un proyecto
1. Inicie AWS SCT. Elija un proyecto cuyo origen sea Oracle.

2. Seleccione Settings (Configuración) y después Project settings (Configuración del proyecto).
Aparecerá el cuadro de diálogo Current project settings.
3. Elija true (verdadero) en Generate row ID (Generar ID de fila).
4. Seleccione OK (Aceptar) para guardar la configuración y cerrar el cuadro de diálogo Current project
settings (Configuración del proyecto actual).
Conversión de SQL dinámico para migraciones de Oracle a

PostgreSQL.
SQL dinámico es una técnica de programación que puede utilizar para ejecutar instrucciones del lenguaje
de definición de datos (DDL) dentro de código PL/SQL. También puede utilizar SQL dinámico para generar
y ejecutar instrucciones SQL en tiempo de ejecución cuando no conoce el texto exacto o los identificadores
de objeto durante el desarrollo. AWS SCT puede convertir instrucciones de SQL dinámico usadas con
bases de datos de Oracle en sus instrucciones equivalentes en PostgreSQL.
Para convertir instrucciones de SQL dinámico en PostgreSQL SQL
1. Cree un proyecto de migración de Oracle a PostgreSQL.

2. Conéctese a bases de datos de origen y destino.
3. Elija un procedimiento almacenado en la vista de árbol de origen de Oracle. El procedimiento debe
incluir referencias al paquete de DBMS_SQL Oracle o tener una instrucción EXECUTE IMMEDIATE.
4. En Actions, elija Convert Schema y confirme que desea reemplazar los objetos, si existen. En la
siguiente captura de pantalla se muestra el procedimiento convertido bajo el procedimiento de Oracle.
Version 1.0
36
Oracle a PostgreSQL
Conversión de particiones de Oracle a particiones de

PostgreSQL versión 10
En PostgreSQL versión 10 y versiones posteriores, se puede especificar cómo se va a dividir una tabla en
partes llamadas particiones. La tabla que se divide se denomina tabla particionada. La especificación de
la tabla contiene el método de particionamiento y una lista de las columnas o expresiones que se utilizan
como clave de partición.
Todas las filas insertadas en una tabla particionada se direccionan a una de las particiones en función
del valor de la clave de partición. Cada partición tiene un subconjunto de datos definido por sus límites de
partición. En la actualidad, los métodos de particionamiento admitidos son los métodos de rango y lista. En
el particionamiento por rango, cada partición se asigna a un rango de claves. En el particionamiento por
lista, cada partición se asigna a una lista de claves.
Cuando AWS SCT convierte un esquema de una base de datos de Oracle en una base de datos de
PostgreSQL, puede emular particiones y subparticiones. Una subpartición de Oracle se convierte en una
partición PostgreSQL que tiene una tabla como expresión de rango principal. La tabla se particiona con
arreglo a la expresión de rango a partir de la subpartición de Oracle.
En la actualidad, AWS SCT admite las particiones en los siguientes casos:
• Rango
• List
Version 1.0
37
De Oracle a MySQL
• Rango-rango
• Lista-lista
• Rango-lista
• Lista-rango
• TIMESTAMP sin zona horaria
Por el contrario, no se admiten los casos siguientes:
• Hash
• Rango-hash
• Lista-hash
• Intervalo
• Referencia
• Fallo en
A continuación, se detallan algunos problemas conocidos que se producen al convertir a PostgreSQL

versión 10:
• Solo las columnas que no son null se pueden particionar por columnas.
• DEFAULT no es un valor de partición posible.
• No se admiten las particiones basadas en TIMESTAMP con zona horaria.
• No se admiten las particiones basadas en una función hash.
• Las columnas de las tablas particionadas no se pueden actualizar porque, al actualizar un valor,
ese valor podría ir a otra partición. AWS SCT solo permite eliminar e insertar columnas en las tablas
particionadas.
• No se permite que las claves tengan como origen o destino tablas particionadas.
Conversión de Oracle a Amazon RDS for MySQL o

Amazon Aurora (MySQL)
A continuación se indican algunos aspectos que se deben tener en cuenta en relación con las
instrucciones GOTO:
• Para cambiar el orden en el que se ejecutan las instrucciones, se puede utilizar una instrucción GOTO
y una etiqueta. Todas las instrucciones PL/SQL que van detrás de una instrucción GOTO se omiten y
el procesamiento continúa en la etiqueta. Las instrucciones GOTO y las etiquetas se pueden utilizar en
cualquier lugar de un procedimiento, lote o bloque de instrucciones. Las instrucciones GOTO también se
pueden anidar.
MySQL no utiliza instrucciones GOTO. Cuando AWS SCT convierte un código que contiene una
instrucción GOTO, convierte esta instrucción para que utilizar en su lugar una instrucción BEGIN...END o
LOOP...END LOOP. En la tabla siguiente, puede ver algunos ejemplos de cómo AWS SCT convierte las
instrucciones GOTO.
Instrucciones GOTO de Oracle e instrucciones de MySQL convertidas
Instrucción de Oracle Instrucción de MySQL
BEGIN BEGIN
.... label1:
statement1; BEGIN
Version 1.0
38
De Oracle a MySQL

.... ....
GOTO label1; statement1;
statement2; ....
.... LEAVE label1;
label1: statement2;
Statement3; ....
.... END;
END Statement3;
....
END
BEGIN BEGIN
.... ....
statement1; statement1;
.... ....
label1: label1:
statement2; LOOP
.... statement2;
GOTO label1; ....
statement3; ITERATE label1;
.... LEAVE label1;
statement4; END LOOP;
.... statement3;
END ....
statement4;
....
END
BEGIN BEGIN
.... ....
.... ....
label1: label1:
statement2; BEGIN
.... statement2;
statement3; ....
.... statement3;
statement4; ....
.... statement4;
END ....
END;
END
Conversión de la instrucción WITH en Oracle a Amazon RDS for

MySQL o Amazon Aurora (MySQL)
Puede utilizar la cláusula WITH (subquery_factoring) en Oracle para asignar un nombre (query_name) a
un bloque subquery. A continuación, puede hacer referencia al bloque subquery en varios lugares de la
consulta especificando el valor de query_name. Si un bloque subquery no contiene enlaces o parámetros
(local, procedimiento, función, paquete), entonces AWS SCT convierte la cláusula en una vista o una tabla
temporal.
La ventaja de convertir la cláusula en una tabla temporal es que las referencias reiteradas a la subquery
pueden ser más eficientes, pues los datos se recuperan fácilmente en la tabla temporal en lugar de que
cada referencia los solicite. Para emular este comportamiento, puede usar más vistas o una tabla temporal.
El nombre de la vista tiene el formato siguiente: <procedure_name>$<subselect_alias>.
Version 1.0
39
De Oracle a MySQL
Instrucciones WITH de Oracle e instrucciones de MySQL convertidas
CREATE PROCEDURE CREATE PROCEDURE

TEST_ORA_PG.P_WITH_SELECT_VARIABLE_01 test_ora_pg.P_WITH_SELECT_VARIABLE_01(IN
(p_state IN NUMBER) par_P_STATE DOUBLE)
AS BEGIN
l_dept_id NUMBER := 1; DECLARE var_l_dept_id DOUBLE DEFAULT 1;
BEGIN DECLARE var$id VARCHAR (8000);
FOR cur IN DECLARE var$state VARCHAR (8000);
(WITH dept_empl(id, name, DECLARE done INT DEFAULT FALSE;
surname, DECLARE cur CURSOR FOR SELECT
lastname, state, dept_id) ID, STATE
AS FROM (SELECT
( ID, NAME, SURNAME, LASTNAME,
SELECT id, name, STATE, DEPT_ID
surname, FROM TEST_ORA_PG.DEPT_EMPLOYEES
lastname, state, WHERE STATE = par_p_state AND
dept_id DEPT_ID = var_l_dept_id) AS dept_empl
FROM ORDER BY ID;
test_ora_pg.dept_employees DECLARE CONTINUE HANDLER FOR NOT FOUND
WHERE state = p_state SET done := TRUE;
AND OPEN cur;
dept_id = l_dept_id)
SELECT id,state read_label:
FROM dept_empl LOOP
ORDER BY id) LOOP FETCH cur INTO var$id, var$state;
NULL;
END LOOP; IF done THEN
LEAVE read_label;
END IF;
BEGIN
END;
END LOOP;
CLOSE cur;
END;
CREATE PROCEDURE CREATE VIEW

TEST_ORA_PG.P_WITH_SELECT_REGULAR_MULT_01 TEST_ORA_PG.`P_WITH_SELECT_REGULAR_MULT_01$dept_empl
AS `(id, name, surname, lastname, state,
BEGIN dept_id)
AS
FOR cur IN ( (SELECT id, name, surname, lastname, state,
WITH dept_empl AS dept_id
( FROM test_ora_pg.dept_employees
SELECT id, name, WHERE state = 1);
surname,
lastname, state, CREATE VIEW
dept_id TEST_ORA_PG.`P_WITH_SELECT_REGULAR_MULT_01$dept
FROM `(deptid, parent_id,deptname)
test_ora_pg.dept_employees AS
WHERE state = 1), (SELECT id deptid, parent_id, name deptname
dept AS FROM test_ora_pg.department);
(SELECT id deptid,
parent_id,
name deptname CREATE PROCEDURE
FROM test_ora_pg.P_WITH_SELECT_REGULAR_MULT_01()
test_ora_pg.department BEGIN
) DECLARE var$ID DOUBLE;
SELECT dept_empl.*,dept.* DECLARE var$NAME VARCHAR (30);
DECLARE var$SURNAME VARCHAR (30);
Version 1.0
40
De Oracle a MySQL

FROM dept_empl, dept DECLARE var$LASTNAME VARCHAR (30);
WHERE dept_empl.dept_id = DECLARE var$STATE DOUBLE;
dept.deptid DECLARE var$DEPT_ID DOUBLE;
) LOOP DECLARE var$deptid DOUBLE;
NULL; DECLARE var$PARENT_ID DOUBLE;
END LOOP; DECLARE var$deptname VARCHAR (200);
DECLARE done INT DEFAULT FALSE;
DECLARE cur CURSOR FOR SELECT
dept_empl.*, dept.*
FROM
TEST_ORA_PG.`P_WITH_SELECT_REGULAR_MULT_01$dept_empl
` AS dept_empl,
TEST_ORA_PG.`P_WITH_SELECT_REGULAR_MULT_01$dept
` AS dept
WHERE dept_empl.DEPT_ID =
dept.DEPTID;
DECLARE CONTINUE HANDLER FOR NOT FOUND
SET done := TRUE;
OPEN cur;
read_label:
LOOP
FETCH cur INTO var$ID, var$NAME, var
$SURNAME,
var$LASTNAME, var$STATE, var$DEPT_ID,
var$deptid,
var$PARENT_ID, var$deptname;
IF done THEN
LEAVE read_label;
END IF;
BEGIN
END;
END LOOP;
CLOSE cur;
END;
call
test_ora_pg.P_WITH_SELECT_REGULAR_MULT_01()
Version 1.0
41
De Oracle a Amazon RDS Oracle
CREATE PROCEDURE CREATE VIEW

TEST_ORA_PG.`P_WITH_SELECT_VAR_CROSS_01$emp
TEST_ORA_PG.P_WITH_SELECT_VAR_CROSS_02(p_state `(id, name, surname, lastname, state,
IN NUMBER) dept_id)
AS AS
l_dept_id NUMBER := 10; (SELECT
BEGIN id, name, surname, lastname,
FOR cur IN ( state, dept_id
WITH emp AS FROM TEST_ORA_PG.DEPT_EMPLOYEES
(SELECT id, name, WHERE DEPT_ID > 10);
surname,
lastname, state,
dept_id CREATE PROCEDURE
FROM
test_ora_pg.dept_employees test_ora_pg.P_WITH_SELECT_VAR_CROSS_02(IN
WHERE dept_id > 10 par_P_STATE DOUBLE)
BEGIN
), DECLARE var_l_dept_id DOUBLE DEFAULT
active_emp AS 10;
( DECLARE var$ID DOUBLE;
SELECT id DECLARE done INT DEFAULT FALSE;
FROM emp DECLARE cur CURSOR FOR SELECT *
WHERE emp.state = FROM (SELECT
p_state ID
) FROM
TEST_ORA_PG.
SELECT *
FROM active_emp `P_WITH_SELECT_VAR_CROSS_01$emp` AS emp
WHERE
) LOOP emp.STATE = par_p_state)
NULL; AS
END LOOP; active_emp;
DECLARE CONTINUE HANDLER FOR NOT FOUND
END; SET done := TRUE;
OPEN cur;
read_label:
LOOP
FETCH cur INTO var$ID;
IF done THEN
LEAVE read_label;
END IF;
BEGIN
END;
END LOOP;
CLOSE cur;
END;
Conversión de Oracle a Amazon RDS for Oracle

Hay algunos aspectos que deben tenerse en cuenta al migrar un esquema y un código de Oracle a
Amazon RDS for Oracle:
• AWS SCT puede añadir objetos de directorio en el árbol de objetos. Los objetos de directorio son
estructuras lógicas, cada una de las cuales representa un directorio físico del sistema de archivos
Version 1.0
42
del servidor. Puede utilizar objetos de directorio con paquetes como DBMS_LOB, UTL_FILE,
DBMS_FILE_TRANSFER, la utilidad DATAPUMP, etc.
• AWS SCT permite convertir espacios de tabla de Oracle en una instancia de base de datos de Amazon
RDS for Oracle. Oracle almacena los datos de forma lógica en espacios de tabla y físicamente en
archivos de datos asociados con el espacio de tabla correspondiente. En Oracle, se puede crear un
espacio de tabla con los nombres de los archivos de datos. Amazon RDS solamente permite usar
archivos administrados por Oracle (OMF) con archivos de datos, archivos log y archivos de control. AWS
SCT crea los archivos de datos necesarios durante la conversión.
• AWS SCT puede convertir funciones y privilegios del nivel del servidor. El motor de base de datos
Oracle utiliza la seguridad basada en roles. Una función es un conjunto de privilegios que se pueden
conceder a un usuario o que se pueden revocar. Una función predefinida de Amazon RDS llamada DBA
normalmente admite todos los privilegios administrativos de un motor de base de datos de Oracle. Los
privilegios que se indican a continuación no están disponibles en la función DBA de las instancias de
base de datos de Amazon RDS que utilizan el motor de Oracle:
• Alter database
• Alter system
• Create any directory
• Grant any privilege
• Grant any role
• Create external job
Puede conceder todos los demás privilegios a una función de usuario de Amazon RDS for Oracle,
incluidos los de filtrado avanzado y de columnas.
• AWS SCT admite la conversión de trabajos de Oracle en trabajos que pueden ejecutarse en Amazon
RDS for Oracle. Existen algunas limitaciones en la conversión, entre las que se incluyen las siguientes:
• No se admiten los trabajos ejecutables.
• No se admiten los trabajos de programación que usan el tipo de datos ANYDATA como un argumento.
• Oracle Real Application Clusters (RAC) One Node es una opción de Oracle Database Enterprise Edition
que se introdujo con Oracle Database 11g versión 2. Amazon RDS for Oracle no admite la característica
RAC. Para obtener una alta disponibilidad, utilice Multi-AZ de Amazon RDS.
En una implementación Multi-AZ, Amazon RDS aprovisiona y mantiene automáticamente una réplica en
espera sincrónica dentro de una zona de disponibilidad diferente. La instancia de base de datos principal
se replica sincrónicamente en las zonas de disponibilidad en una réplica en espera. Esta funcionalidad
proporciona redundancia de datos, elimina los bloqueos de E/S y minimiza los picos de latencia durante
los backups del sistema.
• Oracle Spatial proporciona un esquema y funciones SQL que facilitan el almacenamiento, la
recuperación, la actualización y la consulta de colecciones de datos espaciales en una base de datos
de Oracle. Oracle Locator proporciona capacidades que suelen ser necesarias para admitir aplicaciones
basadas en servicio de Internet e inalámbricas y soluciones de Sistemas de información geográfica (SIG)
basadas en el partner. Oracle Locator es una subred limitada de Oracle Spatial.
Para utilizar las características de Oracle Spatial u Oracle Locator, debe agregar la opción SPATIAL o la
opción LOCATOR (mutuamente excluyentes) al grupo de opciones de la instancia de base de datos.
Existen algunas requisitos previos que debe cumplir para poder usar Oracle Spatial u Oracle Locator en
una instancia de base de datos de Amazon RDS for Oracle:
• La instancia debe usar Oracle Enterprise Edition versión 12.1.0.2.v6 o posterior o la versión
11.2.0.4.v10 o posterior.
• La instancia debe estar dentro de una nube virtual privada (VPC).
• La instancia debe usar la clase de instancia de base de datos que es compatible con la característica
de Oracle. Por ejemplo, Oracle Spatial no se admite para las clases de instancia de base de
datos db.m1.small, db.t1.micro, db.t2.micro o db.t2.small. Para obtener más información, consulte
Compatibilidad de Oracle con las clases de instancias de bases de datos.
Version 1.0
43
• La instancia debe tener habilitada la opción Auto Minor Version Upgrade (Actualización automática
de versiones menores). Amazon RDS actualiza automáticamente su instancia de base de datos a
la versión más reciente de Oracle PSU si hay vulnerabilidades de seguridad con una puntuación de
CVSS superior a 9 u otras vulnerabilidades de seguridad anunciadas. Para obtener más información,
consulte
Configuración de las instancias de base de datos de Oracle .

• Si la versión de su instancia de base de datos es la 11.2.0.4.v10 o posterior, debe instalar la opción
XMLDB. Para obtener más información, consulte
Oracle XML DB .
• Debe tener una licencia de Oracle Spatial de Oracle. Para obtener más información, consulte Oracle
Spatial and Graph en la documentación de Oracle.
• Data Guard se incluye con Oracle Database Enterprise Edition. Para obtener una alta disponibilidad,
utilice la característica Multi-AZ de Amazon RDS.
En una implementación Multi-AZ, Amazon RDS aprovisiona y mantiene automáticamente una réplica en
espera sincrónica dentro de una zona de disponibilidad diferente. La instancia de base de datos principal
se replica sincrónicamente en las zonas de disponibilidad en una réplica en espera. Esta funcionalidad
proporciona redundancia de datos, elimina los bloqueos de E/S y minimiza los picos de latencia durante
los backups del sistema.
• AWS SCT permite convertir objetos de Oracle DBMS_SCHEDULER al migrar a Amazon RDS for Oracle.
El informe de evaluación de AWS SCT indica si un objeto de programación se puede convertir. Para
obtener más información acerca del uso de objetos de programación con Amazon RDS, consulte la
documentación de Amazon RDS.
• En el caso de conversiones de Oracle a Amazon RDS for Oracle, se admiten los enlaces de base de
datos. Un enlace de base de datos es un objeto de esquema en una base de datos que le permite
obtener acceso a los objetos de otra base de datos. No es necesario que la otra base de datos sea de
Oracle. Sin embargo, para obtener acceso a las bases de datos que no son de Oracle, debe utilizar
Oracle Heterogeneous Services.
Una vez creado un enlace de base de datos, puede utilizar el enlace en instrucciones SQL para hacer
referencia a tablas, vistas y objetos PL/SQL en la otra base de datos. Para utilizar un enlace de base de
datos, añada @dblink al nombre de tabla, vista u objeto PL/SQL. Puede consultar una tabla o una vista
de la otra base de datos con la instrucción SELECT. Para obtener más información acerca del uso de
enlaces de base de datos de Oracle, consulte la documentación de Oracle.
Para obtener más información acerca del uso de enlaces de base de datos con Amazon RDS, consulte
la documentación de Amazon RDS.
• El informe de evaluación de AWS SCT proporciona métricas de servidor para la conversión. Estas
métricas acerca de la instancia de Oracle incluyen:
• Capacidad de memoria y computación de la instancia de base de datos de destino.
• Características de Oracle, como Unified Auditing y Real Application Clusters no compatibles que
Amazon RDS no admite.
• Carga de lectura-escritura en disco.
• Rendimiento de disco medio total
• Información del servidor, como nombre de servidor, sistema operativo, alojamiento, nombre y conjunto
de caracteres.
Limitaciones al convertir de Oracle a Amazon RDS for Oracle

Hay que tener en cuenta algunas limitaciones al migrar un esquema y un código de Oracle a Amazon RDS
for Oracle:
Version 1.0
44
Uso de Microsoft SQL Server como origen para
• Una función predefinida de Amazon RDS llamada DBA normalmente admite todos los privilegios
administrativos de un motor de base de datos de Oracle. Los privilegios que se indican a continuación no
están disponibles en la función DBA de las instancias de base de datos de Amazon RDS que utilizan el
motor de Oracle:
• Alter database
• Alter system
• Create any directory
• Grant any privilege
• Grant any role
• Create external job
Todos los demás privilegios se pueden conceder a una función de usuario de Oracle RDS.
• Amazon RDS para Oracle no admite Oracle Unified Auditing. Amazon RDS for Oracle admite las
auditorías tradicionales y detalladas mediante el paquete DBMS_FGA.
• Amazon RDS for Oracle no admite la captura de datos de cambios (CDC). Para realizar la captura
de datos de cambios durante y después de la migración de una base de datos, use AWS Database
Migration Service.
Uso de Microsoft SQL Server como origen para

Puede utilizar AWS SCT para convertir esquemas y código de aplicación de SQL Server a los siguientes
destinos:

• Amazon RDS for SQL Server
Temas
• Permisos necesarios al usar Microsoft SQL Server como origen (p. 45)
• Uso de la autenticación de Windows al utilizar Microsoft SQL Server como origen (p. 46)
• Conexión a SQL Server como origen (p. 47)
• Conversión de SQL Server a MySQL (p. 49)
• Conversión de SQL Server PostgreSQL (p. 50)
• Conversión de SQL Server a Amazon RDS for SQL Server (p. 54)
Permisos necesarios al usar Microsoft SQL Server

como origen
Los privilegios necesarios para Microsoft SQL Server como origen se enumeran a continuación:
• VIEW DEFINITION
• VIEW DATABASE STATE
Version 1.0
45
Origen: autenticación de Windows con Microsoft SQL Server
Repita la concesión para cada base de datos cuyo esquema vaya a convertir.
Uso de la autenticación de Windows al utilizar

Microsoft SQL Server como origen
Si la aplicación se ejecuta en una intranet basada en Windows, es posible que pueda utilizar la
autenticación de Windows para el acceso a las bases de datos. La autenticación de Windows utiliza la
identidad de Windows actual establecida en el subproceso de sistema operativo para obtener acceso a
la base de datos de SQL Server. A continuación, puede mapear la identidad de Windows a una base de
datos de SQL Server y sus permisos. Para conectarse a SQL Server con la autenticación de Windows,
debe especificar la identidad de Windows que utiliza la aplicación. También debe conceder a la identidad
de Windows acceso a la base de datos de SQL Server.
SQL Server tiene dos modos de acceso: autenticación de Windows y mixto. El modo de autenticación
de Windows habilita dicha autenticación y deshabilita la de SQL Server. El modo mixto habilita tanto la
autenticación de Windows como la de SQL Server. La autenticación de Windows siempre está disponible y
no se puede deshabilitar. Para obtener más información acerca de la autenticación de Windows, consulte
la documentación de Microsoft Windows.
A continuación se muestra el ejemplo posible para crear un usuario en TEST_DB
USE [TEST_DB]
CREATE USER [TestUser] FOR LOGIN [TestDomain\TestUser]
GRANT VIEW DEFINITION TO [TestUser]
GRANT VIEW DATABASE STATE TO [TestUser]
Uso de la autenticación de Windows con una conexión JDBC

El controlador JDBC no admite la autenticación de Windows si dicho controlador se utiliza en sistemas
operativos que no son de Windows. Las credenciales de autenticación de Windows, como el nombre de
usuario y la contraseña, al conectarse a SQL Server desde sistemas operativos que no son de Windows.
En estos casos, las aplicaciones deben utilizar la autenticación de SQL Server.
En la cadena de conexión de JDBC, debe especificarse el parámetro integratedSecurity para

conectarse mediante la autenticación de Windows. El controlador JDBC admite la autenticación de
Windows integrada para los sistemas operativos de Windows a través del parámetro de cadena de
conexión integratedSecurity.
Para usar la autenticación integrada
1. Instale el controlador JDBC.

2. Copie el archivo sqljdbc_auth.dll en un directorio de la ruta de sistema de Windows en el equipo
donde está instalado el controlador JDBC.
Los archivos sqljdbc_auth.dll se instalan en la ubicación siguiente:
<directorio de instalación>\sqljdbc_<versión>\<idioma>\auth\
Cuando intenta establecer una conexión a una base de datos de SQL Server con la autenticación de
Windows, podría aparecer un error que indica que el controlador no está configurado para la autenticación
integrada. Este problema se puede resolver con las siguientes acciones:
• Debe declarar dos variables que apunten a la ruta instalada de JDBC:
-nombre de variable: SQLJDBC_HOME; valor de variable: D:\lib\JDBC4.1\enu (donde está sqljdbc4.jar);
Version 1.0
46
Conexión a SQL Server como origen
-nombre de variable: SQLJDBC_AUTH_HOME; valor de variable: D\lib\JDBC4.1\enu\auth\x86 (si ejecuta

un sistema operativo de 32 bits) o D\lib\JDBC4.1\enu\auth\x64 (si ejecuta un sistema operativo de 64
bits). Aquí es donde se encuentra sqljdbc_auth.dll.
• Copie sqljdbc_auth.dll en la carpeta donde se ejecuta JDK/JRE. Puede copiar la carpeta lib, la carpeta
bin, etc. Hemos copiado las siguientes carpetas:
[JDK_INSTALLED_PATH]\bin;
[JDK_INSTALLED_PATH]\jre\bin;
[JDK_INSTALLED_PATH]\jre\lib;
[JDK_INSTALLED_PATH]\lib;
• Asegúrese de que en la carpeta de bibliotecas jdbc solo tiene SQLJDBC4.jar. Quite los demás archivos
sqljdbc*.jar de esa carpeta (o cópielos en otra). Si va a agregar el controlador como parte de su
programa, asegúrese de que agregar solo SQLJDBC4.jar como el controlador que se utilizará.
• Copie el archivo sqljdbc_auth.dll en la carpeta con su aplicación.
Note
Si ejecuta una máquina virtual de Java (JVM) de 32 bits, utilice el archivo sqljdbc_auth.dll de la
carpeta x86, incluso si la versión del sistema operativo es x64. Si ejecuta una JVM de 64 bits en
un procesador x64, utilice el archivo sqljdbc_auth.dll de la carpeta x64.
Al conectarse a una base de datos de SQL Server, puede elegir Windows Authentication (Autenticación
de Windows) o SQL Server Authentication (Autenticación de SQL Server) en la opción Authentication
(Autenticación).

Utilice el siguiente procedimiento para conectarse a su base de datos Microsoft SQL Server de origen con
la Herramienta de conversión de esquemas de AWS.
Para conectarse a una base de datos de Microsoft SQL Server de origen
1. En la Herramienta de conversión de esquemas de AWS, elija Connect to Microsoft SQL Server

(Conectar a Microsoft SQL Server).
Aparecerá el cuadro de diálogo Connect to Microsoft SQL Server.
Version 1.0
47
2. Proporcione la información de conexión a la base de datos de Microsoft SQL Server de origen. Utilice
las instrucciones de la siguiente tabla.
Server name Escriba el nombre DNS o la dirección IP de su servidor de base

de datos de origen.
Server port Escriba el puerto que utilice para conectarse al servidor de su

Instance name Escriba el nombre de la instancia de la base de datos de SQL

Server. Para encontrar el nombre de la instancia, ejecute la
consulta SELECT @@servername; en su base de datos de SQL
Server.

Note

necesario.
Use SSL Seleccione esta opción si desea utilizar capa de conexión

segura (SSL) para conectarse a la base de datos. Proporcione
la siguiente información adicional, según proceda, en la pestaña
SSL:
Version 1.0
48
De SQL Server a MySQL

• Trust Server Certificate: seleccione esta opción para confiar en
el certificado del servidor.

Sql Server Driver Path Escriba la ruta al controlador que quiere usar para conectarse
necesarios (p. 8).

global (p. 10).
de origen.
Conversión de SQL Server a MySQL

Hay algunos aspectos que deben tenerse en cuenta al migrar un esquema de SQL Server a MySQL:
• MySQL no admite la instrucción MERGE. Sin embargo, AWS SCT puede emular la instrucción MERGE
durante la conversión a través de la cláusula INSERT ON DUPLICATE KEY y las instrucciones UPDATE
FROM y DELETE FROM.
Para conseguir una emulación correcta con INSERT ON DUPLICATE KEY, asegúrese de que existe una
restricción o una clave principal únicas en la base de datos MySQL de destino.
• Para cambiar el orden en el que se ejecutan las instrucciones, se puede utilizar una instrucción GOTO y
una etiqueta. Todas las instrucciones Transact-SQL que van detrás de una instrucción GOTO se omiten
y el procesamiento continúa en la etiqueta. Las instrucciones GOTO y las etiquetas se pueden utilizar en
pueden anidar.
MySQL no utiliza instrucciones GOTO. Cuando AWS SCT convierte un código que contiene una
instrucciones GOTO.
Instrucción de SQL Server Instrucción de MySQL
BEGIN BEGIN
.... label1:
statement1; BEGIN
Version 1.0
49
De SQL Server a PostgreSQL
Instrucción de SQL Server Instrucción de MySQL

.... ....
statement2; ....
.... LEAVE label1;
label1: statement2;
Statement3; ....
.... END;
END Statement3;
....
END
BEGIN BEGIN
.... ....
.... ....
label1: label1:
statement2; LOOP
.... statement2;
GOTO label1; ....
statement3; ITERATE label1;
.... LEAVE label1;
.... statement3;
END ....
statement4;
....
END
BEGIN BEGIN
.... ....
.... ....
label1: label1:
statement2; BEGIN
.... statement2;
statement3; ....
.... statement3;
statement4; ....
.... statement4;
END ....
END;
END
• MySQL no admite funciones con valores de tabla compuestas de varias instrucciones. AWS SCT simula
las funciones con valores de tabla durante una conversión creando tablas temporales y reescribiendo
instrucciones para utilizar estas tablas temporales.
Conversión de SQL Server PostgreSQL

Hay algunos aspectos que deben tenerse en cuenta al migrar un esquema de SQL Server a PostgreSQL:
• En PostgreSQL, todos los nombres de objeto de un esquema deben ser único, incluidos los índices. Los
nombres de los índices deben ser únicos en el esquema de la tabla base. En SQL Server, un nombre de
índice puede ser igual en diferentes tablas.
Para garantizar la exclusividad de los índices, AWS SCT brinda la opción de generar nombres de índice
únicos si dichos nombres de índice no lo son. Para ello, seleccione la opción Generate unique index
Version 1.0
50
names (Generar nombres de índice únicos) en las propiedades del proyecto. Esta opción está habilitada
de forma predeterminada. Si esta opción está habilitada, se crean nombres de índice único con el
formato IX_nombre_tabla_nombre_índice. Si esta opción está deshabilitada, los nombres de índice no se
modifican.
• Para cambiar el orden en el que se ejecutan las instrucciones, se puede utilizar una instrucción GOTO y
una etiqueta. Todas las instrucciones Transact-SQL que van detrás de una instrucción GOTO se omiten
y el procesamiento continúa en la etiqueta. Las instrucciones GOTO y las etiquetas se pueden utilizar en
pueden anidar.
PostgreSQL no utiliza instrucciones GOTO. Cuando AWS SCT convierte un código que contiene una
instrucciones GOTO.
Instrucciones GOTO de SQL Server e instrucciones PostgreSQL convertidas
Instrucción de SQL Server Instrucción de PostgreSQL
BEGIN BEGIN
.... label1:
statement1; BEGIN
.... ....
statement2; ....
.... EXIT label1;
label1: statement2;
Statement3; ....
.... END;
END Statement3;
....
END
BEGIN BEGIN
.... ....
.... ....
label1: label1:
statement2; LOOP
.... statement2;
GOTO label1; ....
statement3; CONTINUE label1;
.... EXIT label1;
.... statement3;
END ....
statement4;
....
END
BEGIN BEGIN
.... ....
.... ....
label1: label1:
statement2; BEGIN
.... statement2;
statement3; ....
.... statement3;
statement4; ....
Version 1.0
51
Instrucción de SQL Server Instrucción de PostgreSQL

.... statement4;
END ....
END;
END
• PostgreSQL no admite la instrucción MERGE. AWS SCT emula el comportamiento de una instrucción
MERGE de las siguientes formas:
• Mediante la construcción INSERT ON CONFLICT.
• Mediante la instrucción UPDATE FROM DML, como MERGE sin la cláusula WHEN NOT MATCHED.
• Mediante el uso de CURSOR, como con una cláusula MERGE con DELETE o mediante el uso de una
instrucción de condición compleja MERGE ON.
• AWS SCT puede añadir disparadores de bases de datos al árbol de objetos cuando el destino es
Amazon RDS.
• AWS SCT puede añadir disparadores de nivel de servidor al árbol de objetos cuando el destino es
Amazon RDS.
• AWS SCT puede añadir servidores enlazados al árbol de objetos cuando el destino es Amazon RDS.
• Al migrar desde Microsoft SQL Server a PostgreSQL, la función SUSER_SNAME integrada se convierte
tal y como se indica a continuación:
• SUSER_SNAME: devuelve el nombre de inicio de sesión asociado a un número de identificación de
seguridad (SID).
• SUSER_SNAME(<sid_usuario_servidor>): no admitido.
• SUSER_SNAME() CURRENT_USER: devuelve el nombre de usuario del contexto de ejecución actual.
• SUSER_SNAME (NULL): devuelve NULL.
• Se permite la conversión de funciones con valores de tabla. Las funciones con valores de tabla
devuelven una tabla y pueden tomar el lugar de una tabla en una consulta.
• PATINDEX devuelve la posición inicial de la primera coincidencia de un patrón en una expresión
especificada, o ceros si no se encuentra el patrón, en todos los tipos de datos de texto y caracteres
válidos. Al convertir de SQL Server a Amazon RDS for PostgreSQL, AWS SCT reemplaza el código
de aplicación que usa PATINDEX por aws_sqlserver_ext.patindex<carácter de patrón>, <carácter de
expresión variable>).
• En SQL Server, un tipo de tabla definido por el usuario es un tipo que representa la definición de
la estructura de una tabla. Puede utilizar un tipo de tabla definido por el usuario para declarar los
parámetros de tabla-valor en funciones o procedimientos almacenados o bien para declarar las variables
de tabla que se desea utilizar en un lote o en el cuerpo de una función o procedimiento almacenado.
AWS SCT emula este tipo en PostgreSQL creando una tabla temporal.
Al convertir de SQL Server a PostgreSQL, AWS SCT convierte los objetos de sistema de SQL Server en
objetos reconocibles en PostgreSQL. En la siguiente tabla se muestra cómo se convierten los objetos del
sistema.
>Casos de uso de MS SQL Sustitución de PostgreSQL

Server
SYS.SCHEMAS AWS_SQLSERVER_EXT.SYS_SCHEMAS
SYS.TABLES AWS_SQLSERVER_EXT.SYS_TABLES
SYS.VIEWS AWS_SQLSERVER_EXT.SYS_VIEWS
SYS.ALL_VIEWS AWS_SQLSERVER_EXT.SYS_ALL_VIEWS
SYS.TYPES AWS_SQLSERVER_EXT.SYS_TYPES
Version 1.0
52
>Casos de uso de MS SQL Sustitución de PostgreSQL

Server
SYS.COLUMNS AWS_SQLSERVER_EXT.SYS_COLUMNS
SYS.ALL_COLUMNS AWS_SQLSERVER_EXT.SYS_ALL_COLUMNS
SYS.FOREIGN_KEYS AWS_SQLSERVER_EXT.SYS_FOREIGN_KEYS
SYS.SYSFOREIGNKEYS AWS_SQLSERVER_EXT.SYS_SYSFOREIGNKEYS
SYS.FOREIGN_KEY_COLUMNS
AWS_SQLSERVER_EXT.SYS_FOREIGN_KEY_COLUMNS
SYS.KEY_CONSTRAINTS AWS_SQLSERVER_EXT.SYS_KEY_CONSTRAINTS
SYS.IDENTITY_COLUMNS AWS_SQLSERVER_EXT.SYS_IDENTITY_COLUMNS
SYS.PROCEDURES AWS_SQLSERVER_EXT.SYS_PROCEDURES
SYS.INDEXES AWS_SQLSERVER_EXT.SYS_INDEXES
SYS.SYSINDEXES AWS_SQLSERVER_EXT.SYS_SYSINDEXES
SYS.OBJECTS AWS_SQLSERVER_EXT.SYS_OBJECTS
SYS.ALL_OBJECTS AWS_SQLSERVER_EXT.SYS_ALL_OBJECTS
SYS.SYSOBJECTS AWS_SQLSERVER_EXT.SYS_SYSOBJECTS
SYS.SQL_MODULES AWS_SQLSERVER_EXT.SYS_SQL_MODULES
SYS.DATABASES AWS_SQLSERVER_EXT.SYS_DATABASES
INFORMATION_SCHEMA.SCHEMATA
AWS_SQLSERVER_EXT.INFORMATION_SCHEMA_SCHEMATA
INFORMATION_SCHEMA.VIEWS
AWS_SQLSERVER_EXT.INFORMATION_SCHEMA_VIEWS
INFORMATION_SCHEMA.TABLES
AWS_SQLSERVER_EXT.INFORMATION_SCHEMA_TABLES
INFORMATION_SCHEMA.COLUMNS
AWS_SQLSERVER_EXT.INFORMATION_SCHEMA_COLUMNS
INFORMATION_SCHEMA.CHECK_CONSTRAINTS
AWS_SQLSERVER_EXT.INFORMATION_SCHEMA_CHECK_CONSTRAINTS
INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS
AWS_SQLSERVER_EXT.INFORMATION_SCHEMA_REFERENTIAL_CONSTRAINTS
INFORMATION_SCHEMA.TABLE_CONSTRAINTS
AWS_SQLSERVER_EXT.INFORMATION_SCHEMA_TABLE_CONSTRAINTS
INFORMATION_SCHEMA.KEY_COLUMN_USAGE
AWS_SQLSERVER_EXT.INFORMATION_SCHEMA_KEY_COLUMN_USAGE
INFORMATION_SCHEMA.CONSTRAINT_TABLE_USAGE
AWS_SQLSERVER_EXT.INFORMATION_SCHEMA_CONSTRAINT_TABLE_USAGE
INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE
AWS_SQLSERVER_EXT.INFORMATION_SCHEMA_CONSTRAINT_COLUMN_USAGE
INFORMATION_SCHEMA.ROUTINES
AWS_SQLSERVER_EXT.INFORMATION_SCHEMA_ROUTINES
SYS.SYSPROCESSES AWS_SQLSERVER_EXT.SYS_SYSPROCESSES
sys.system_objects AWS_SQLSERVER_EXT.SYS_SYSTEM_OBJECTS
Version 1.0
53
De SQL Server a Amazon RDS for SQL Server
Conversión de particiones de SQL Server a particiones de

PostgreSQL versión 10
En SQL Server, debe crear particiones con funciones de partición. Cuando una tabla particionada de SQL
Server se convierte en una tabla particionada de PostgreSQL versión 10, debe tenerse en cuenta que
pueden producirse algunos problemas:
• SQL Server le permite particionar una tabla utilizando una columna sin la restricción NOT NULL. En
ese caso, todos los valores NULL van a la partición situada más a la izquierda. PostgreSQL no admite
valores NULL con particiones RANGE.
• SQL Server le permite crear claves principales y claves únicas para tablas particionadas. En el caso
de PostgreSQL, las claves primarias y las claves únicas se crean directamente para cada partición.
Por tanto, la restricción PRIMARY o UNIQUE KEY debe eliminarse de la tabla principal al migrar a
PostgreSQL. Los nombres de clave resultantes tienen el formato
<original_key_name>_<partition_number>.
• SQL Server permite crear restricciones de clave externa que tienen como origen o destino tablas
particionadas. PostgreSQL no admite las claves externas que hacen referencia a tablas particionadas.
Además, PostgreSQL tampoco admite las referencias de clave externa entre una tabla particionada y
otra tabla.
• SQL Server permite crear índices para las tablas particionadas. En PostgreSQL, los índices
deben crearse directamente con cada partición. Por lo tanto, los índices deben eliminarse de sus
tablas principales al migrar a PostgreSQL. Los nombres de índice resultantes tienen el formato
<original_index_name>_<partition_number>.
• PostgreSQL no admite índices particionados.
Conversión de SQL Server a Amazon RDS for SQL

Server
Hay algunos aspectos que deben tenerse en cuenta al migrar un esquema y un código de SQL Server a
Amazon RDS for SQL Server:
• AWS SCT puede convertir el agente de SQL Server para que proporcione programaciones, alertas
y trabajos en una instancia de base de datos de Amazon RDS for SQL Server. Una vez realizada la
conversión, la instancia de base de datos de Amazon RDS for SQL Server puede utilizarse como origen
de datos de SQL Server Reporting Services (SSRS), SQL Server Analysis Services (SSAS) y SQL
Server Integration Services (SSIS). Estos servicios no se pueden ejecutar en la instancia de base de
datos.
• Actualmente, Amazon RDS no admite SQL Server Service Broker ni puntos de enlace de T-SQL
adicionales que requieran ejecutar el comando CREATE ENDPOINT.
• Amazon RDS tiene una compatibilidad limitada con los servidores enlazados. Al convertir el código de
aplicación de SQL Server que utiliza servidores enlazados, AWS SCT convierte el código de aplicación,
pero debe revisar el comportamiento de los objetos que utilizan servidores de enlace antes de ejecutar el
código convertido.
• El informe de evaluación de AWS SCT proporciona métricas de servidor para la conversión. Estas
métricas acerca de la instancia de SQL Server incluyen:
• Uso de la replicación de datos.
• Configuración de Trasvase de registros de SQL Server.
• Uso de AlwaysON. Amazon RDS no admite AlwaysOn.
• Uso de un clúster de conmutación por error.
Version 1.0
54
Utilizar MySQL como origen para Herramienta
• Configuración de Correo electrónico de base de datos. Amazon RDS no admite Correo electrónico de
base de datos.
• Uso de Servicio SQL Server Reporting Services (SSRS). Amazon RDS no admite SSRS. Por
consiguiente, recomendamos instalar SQL Server en una instancia Amazon EC2.
• Uso de SQL Server Analysis Services (SSAS). Amazon RDS no admite SSAS. Por consiguiente,
recomendamos instalar SQL Server en una instancia Amazon EC2.
• Uso de SQL Server Integration Services (SSIS). Amazon RDS no admite SSIS. Por consiguiente,
• Uso de Servicio de búsqueda de texto completo. La búsqueda de texto completo en Amazon RDS
para SQL Server es limitada y no admite la búsqueda semántica.
• Instalación de Data Quality Services (DQS). Amazon RDS no admite DQS. Por consiguiente,
Utilizar MySQL como origen para Herramienta de

Puede utilizar AWS SCT para convertir esquemas y código de aplicación de MySQL a los siguientes
destinos:

Temas
• Privilegios para MySQL como base de datos de origen (p. 55)
• Conexión a MySQL como base de datos de origen (p. 55)
Privilegios para MySQL como base de datos de origen

Los privilegios necesarios para MySQL como origen se enumeran a continuación:
• SELECT ON *.*
• SELECT ON mysql.proc
• SHOW VIEW ON *.*
Conexión a MySQL como base de datos de origen

Utilice el siguiente procedimiento para conectarse a su base de datos MySQL de origen con la Herramienta
de conversión de esquemas de AWS.
Para conectarse a una base de datos de MySQL
1. En la Herramienta de conversión de esquemas de AWS, seleccione Connect to MySQL (Conectar a

MySQL).
Version 1.0
55
Conexión a MySQL como origen
Aparecerá el cuadro de diálogo Connect to MySQL.
2. Proporcione la información de conexión de la base de datos de MySQL de origen. Utilice las


de datos de origen.


Note

necesario.
Version 1.0
56
Utilizar PostgreSQL como origen para

• Require SSL: seleccione esta opción si desea conectar con el
servidor únicamente a través de SSL.
Note
Si selecciona Require SSL, significa que si el servidor

no admite SSL, no puede conectar con el servidor.
Si no selecciona Require SSL y el servidor no admite
SSL, sigue pudiendo conectar con el servidor sin
utilizar SSL. Para obtener más información, consulte
Uso de conexiones seguras.
• Verify Server Certificate: seleccione esta opción para verificar el
certificado del servidor mediante un almacén de confianza.

MySql Driver Path Escriba la ruta al controlador que quiere usar para conectarse
necesarios (p. 8).

global (p. 10).
de origen.
Utilizar PostgreSQL como origen para Herramienta

Puede utilizar AWS SCT para convertir datos de PostgreSQL a los siguientes destinos:

Temas
Version 1.0
57
Fuente: PostgreSQL
• Privilegios para PostgreSQL como base de datos de origen (p. 58)

• Conexión a PostgreSQL como origen (p. 58)
Privilegios para PostgreSQL como base de datos de

origen
Los privilegios necesarios para PostgreSQL como origen se enumeran a continuación:
• CONNECT ON DATABASE <database_name>

• USAGE ON SCHEMA <database_name>
• SELECT ON ALL TABLES IN SCHEMA <database_name>
• SELECT ON ALL SEQUENCES IN SCHEMA <database_name>
Conexión a PostgreSQL como origen

Utilice el siguiente procedimiento para conectarse a su base de datos PostgreSQL de origen con la
Para conectarse a una base de datos de PostgreSQL de origen
1. En la Herramienta de conversión de esquemas de AWS, seleccione Connect to PostgreSQL (Conectar

a PostgreSQL).
Aparecerá el cuadro de diálogo Connect to PostgreSQL.
2. Proporcione la información de conexión de la base de datos PostgreSQL de origen. Utilice las

Version 1.0
58
Conexión a PostgreSQL como origen

de datos de origen.

Base de datos Escriba el nombre de la base de datos PostgreSQL.

Note

necesario.


PostgreSQL Driver Path Escriba la ruta al controlador que quiere usar para conectarse
necesarios (p. 8).

global (p. 10).
de origen.
Version 1.0
59
Uso de Db2 LUW como origen para Herramienta
Uso de Db2 LUW como origen para Herramienta de

Puede utilizar AWS SCT para convertir datos de Db2 LUW a los siguientes destinos. AWS SCT admite
como origen las versiones 9.1, 9.5, 9.7, 10.1, 10.5 y 11.1 de Db2 LUW.

Permisos necesarios al usar Db2 LUW como origen

Los privilegios necesarios para conectarse a una base de datos DB2LUW, comprobar los privilegios
disponibles y leer los metadatos de esquema de un origen se enumeran a continuación:
• Privilegio necesario para establecer una conexión:
GRANT CONNECT ON DATABASE TO USER min_privs;

• Privilegio necesario para ejecutar instrucciones SQL:
GRANT EXECUTE ON PACKAGE NULLID.SYSSH200 TO USER MIN_PRIVS;

• Privilegios necesarios para obtener información de nivel de instancia:
• GRANT EXECUTE ON FUNCTION SYSPROC.ENV_GET_INST_INFO TO USER MIN_PRIVS;
• GRANT SELECT ON SYSIBMADM.ENV_INST_INFO TO USER MIN_PRIVS;
• GRANT SELECT ON SYSIBMADM.ENV_SYS_INFO TO USER MIN_PRIVS;
• Privilegios necesarios para comprobar los privilegios concedidos a través de roles, grupos y autoridades:
• GRANT EXECUTE ON FUNCTION SYSPROC.AUTH_LIST_AUTHORITIES_FOR_AUTHID TO USER
MIN_PRIVS;
• GRANT EXECUTE ON FUNCTION SYSPROC.AUTH_LIST_GROUPS_FOR_AUTHID TO USER
MIN_PRIVS;
• GRANT EXECUTE ON FUNCTION SYSPROC.AUTH_LIST_ROLES_FOR_AUTHID TO USER
MIN_PRIVS;
• GRANT SELECT ON SYSIBMADM.PRIVILEGES TO USER MIN_PRIVS;
• Privilegios necesarios en los catálogos y las tablas del sistema:
• GRANT SELECT ON SYSCAT.ATTRIBUTES TO USER MIN_PRIVS;
• GRANT SELECT ON SYSCAT.CHECKS TO USER MIN_PRIVS;
• GRANT SELECT ON SYSCAT.COLIDENTATTRIBUTES TO USER MIN_PRIVS;
• GRANT SELECT ON SYSCAT.COLUMNS TO USER MIN_PRIVS;
• GRANT SELECT ON SYSCAT.DATAPARTITIONEXPRESSION TO USER MIN_PRIVS;
• GRANT SELECT ON SYSCAT.DATAPARTITIONS TO USER MIN_PRIVS;
• GRANT SELECT ON SYSCAT.DATATYPEDEP TO USER MIN_PRIVS;
• GRANT SELECT ON SYSCAT.DATATYPES TO USER MIN_PRIVS;
• GRANT SELECT ON SYSCAT.HIERARCHIES TO USER MIN_PRIVS;
• GRANT SELECT ON SYSCAT.INDEXCOLUSE TO USER MIN_PRIVS;
• GRANT SELECT ON SYSCAT.INDEXES TO USER MIN_PRIVS;
• GRANT SELECT ON SYSCAT.INDEXPARTITIONS TO USER MIN_PRIVS;
Version 1.0
60
Origen: Db2 LUW
• GRANT SELECT ON SYSCAT.KEYCOLUSE TO USER MIN_PRIVS;

• GRANT SELECT ON SYSCAT.MODULEOBJECTS TO USER MIN_PRIVS;
• GRANT SELECT ON SYSCAT.MODULES TO USER MIN_PRIVS;
• GRANT SELECT ON SYSCAT.NICKNAMES TO USER MIN_PRIVS;
• GRANT SELECT ON SYSCAT.PERIODS TO USER MIN_PRIVS;
• GRANT SELECT ON SYSCAT.REFERENCES TO USER MIN_PRIVS;
• GRANT SELECT ON SYSCAT.ROUTINEPARMS TO USER MIN_PRIVS;
• GRANT SELECT ON SYSCAT.ROUTINES TO USER MIN_PRIVS;
• GRANT SELECT ON SYSCAT.ROWFIELDS TO USER MIN_PRIVS;
• GRANT SELECT ON SYSCAT.SCHEMATA TO USER MIN_PRIVS;
• GRANT SELECT ON SYSCAT.SEQUENCES TO USER MIN_PRIVS;
• GRANT SELECT ON SYSCAT.TABCONST TO USER MIN_PRIVS;
• GRANT SELECT ON SYSCAT.TABLES TO USER MIN_PRIVS;
• GRANT SELECT ON SYSCAT.TRIGGERS TO USER MIN_PRIVS;
• GRANT SELECT ON SYSCAT.VARIABLEDEP TO USER MIN_PRIVS;
• GRANT SELECT ON SYSCAT.VARIABLES TO USER MIN_PRIVS;
• GRANT SELECT ON SYSCAT.VIEWS TO USER MIN_PRIVS;
• GRANT SELECT ON SYSIBM.SYSDUMMY1 TO USER MIN_PRIVS;
• Para ejecutar instrucciones SQL, la cuenta de usuario necesita un privilegio para utilizar al menos una de
las cargas de trabajo habilitadas en la base de datos. Si ninguna de las cargas de trabajo está asignada
al usuario, asegúrese de este puede obtener acceso a la carga de trabajo de usuario predeterminada:
GRANT USAGE ON WORKLOAD SYSDEFAULTUSERWORKLOAD TO USER MIN_PRIVS;
Para ejecutar consultas, debe crear un espacio de tabla temporal del sistema con un tamaño de página 8
K, 16 K y 32 K, si no existen. Para crear los espacios de tabla temporales, ejecute los siguientes scripts:
CREATE BUFFERPOOL BP8K

IMMEDIATE
ALL DBPARTITIONNUMS
SIZE AUTOMATIC
NUMBLOCKPAGES 0
PAGESIZE 8K;
CREATE SYSTEM TEMPORARY TABLESPACE TS_SYS_TEMP_8K

PAGESIZE 8192
BUFFERPOOL BP8K;

IMMEDIATE
ALL DBPARTITIONNUMS
SIZE AUTOMATIC
NUMBLOCKPAGES 0
PAGESIZE 16K;
CREATE SYSTEM TEMPORARY TABLESPACE TS_SYS_TEMP_BP16K

PAGESIZE 16384
BUFFERPOOL BP16K;

IMMEDIATE
ALL DBPARTITIONNUMS
SIZE AUTOMATIC
NUMBLOCKPAGES 0
PAGESIZE 32K; Version 1.0
61
Conexión a Db2 LUW como origen
CREATE SYSTEM TEMPORARY TABLESPACE TS_SYS_TEMP_BP32K

PAGESIZE 32768
BUFFERPOOL BP32K;
Conexión a un origen Db2 LUW

Utilice el siguiente procedimiento para conectarse a su base de datos Db2 LUW de origen con la
Para conectarse a una base de datos de origen de Db2 LUW
1. En Herramienta de conversión de esquemas de AWS, seleccione Connect to Source DB2 LUW

(Conectarse a DB2 LUW de origen).
Aparecerá el cuadro de diálogo Connect to DB2 LUW (Conectarse a DB2 LUW).
2. Proporcione la información de conexión de la base de datos de Db2 LUW de origen. Utilice las

de datos de origen.

Base de datos Escriba el nombre de la base de datos de Db2 LUW.

Version 1.0
62
Conexión a Db2 LUW como origen

Note

necesario.

contenga certificados. Debe añadir esta ubicación en Global
Settings antes de que aparezca aquí.
Para obtener más información sobre la compatibilidad con SSL de

Db2 LUW, consulte Configuración de las opciones de seguridad
para las conexiones.

DB2 LUW Driver Path (Ruta de Escriba la ruta al controlador que quiere usar para conectarse
controladores de DB2 LUW) a la base de datos de origen. Para obtener más información,
necesarios (p. 8).

global (p. 10).
de origen.
Version 1.0
63
De DB2LUW a PostgreSQL
Conversión de DB2 LUW a Amazon RDS for

PostgreSQL o Amazon Aurora (PostgreSQL)
Hay algunos aspectos que deben tenerse en cuenta al migrar de IBM Db2 LUW a ToPostgreSQL:
• AWS SCT puede convertir varias instrucciones de activación que se utilizan con Db2 LUW. Entre estas
instrucciones de activación se incluyen las siguientes:
• Eventos de activación: los eventos de activación INSERT, DELETE y UPDATE especifican que
la acción activada debe ejecutarse siempre que el evento se aplica a la tabla o vista de asuntos.
Se puede especificar cualquier combinación de los eventos INSERT, DELETE y UPDATE, pero
cada evento solamente puede especificarse una vez. AWS SCT permite utilizar tanto uno como
varios eventos de activación. En el caso de los eventos, PostgreSQL tiene prácticamente la misma
funcionalidad.
• Evento OF COLUMN: se puede especificar un nombre de columna desde una tabla base. El
disparador se activa únicamente cuando se actualiza una columna que aparece en la lista de nombres
de columnas. PostgreSQL tiene la misma funcionalidad.
• Disparadores de instrucciones: estos disparadores indican que la acción se aplica una sola vez en
toda la instrucción. Este tipo de granularidad no se puede especificar con los disparadores BEFORE
o INSTEAD OF. Si se especifica, se activará un disparador UPDATE o DELETE aunque no haya
ninguna fila afectada. PostgreSQL también cuenta con esta funcionalidad y la declaración de los
disparadores de instrucciones es idéntica en PostgreSQL y Db2 LUW.
• Cláusulas de referencia: estas cláusulas especifican los nombres de correlación de las variables de
transición y los nombres de las tablas de transición. Los nombres de correlación identifican una fila
concreta del conjunto de filas afectadas por la operación SQL de activación. Los nombres de las tablas
identifican el conjunto completo de filas afectadas. Cada una de las filas afectadas por una operación
SQL de activación está disponible para la acción activada al asignar a las columnas los nombres
de correlación especificados. PostgreSQL no admite esta funcionalidad y solo utiliza el nombre de
correlación NEW u OLD.
• AWS SCT admite los disparadores INSTEAD OF.
Conversión de tablas particionadas de DB2 LUW a tablas

particionadas de PostgreSQL versión 10
AWS SCT puede convertir tablas de Db2 LUW en tablas particionadas de PostgreSQL 10. Existen varias
restricciones al convertir una tabla particionada de Db2 LUW en PostgreSQL:
• Puede crear una tabla particionada con una columna que admita valores null en Db2 LUW y puede
especificar una partición para almacenar los valores NULL. Sin embargo, PostgreSQL no admite valores
NULL con particiones RANGE.
• Db2 LUW puede utilizar una cláusula INCLUSIVE o EXCLUSIVE para establecer los valores límite del
intervalo. PostgreSQL solo admite INCLUSIVE para el límite inicial y EXCLUSIVE para el límite final. El
nombre de la partición convertida tiene el formato <nombre_tabla_original>_<nombre_partición_original>.
• Puede crear claves principales o únicas para tablas particionadas de Db2 LUW. PostgreSQL requiere
que se creen claves primarias o únicas para cada partición directamente. Las restricciones de claves
principales o únicas deben eliminarse de la tabla principal. El nombre de la clave convertida tiene el
formato <nombre_clave_original>_<nombre_partición_original>.
• Puede crear una restricción de clave externa que tenga como origen o destino una tabla particionada de
Db2 LUW. Sin embargo, PostgreSQL no admite referencias de clave externa en tablas particionadas.
PostgreSQL tampoco admite las referencias de clave externa entre una tabla particionada y otra tabla.
• Puede crear un índice en una tabla particionada en Db2 LUW. Sin embargo, PostgreSQL requiere que
se cree un índice para cada partición directamente. Los índices deben eliminarse de la tabla principal. El
nombre del índice convertido tiene el formato <nombre_índice_original>_<nombre_partición_original>.
Version 1.0
64
Uso de Amazon Redshift como origen de
• Debe definir los disparadores de fila en las particiones individuales, no en la tabla particionada. Los
disparadores deben eliminarse de la tabla principal. El nombre del disparador convertido tiene el formato
<nombre_disparador_original>_<nombre_partición_original>.
Uso de Amazon Redshift como origen de

Puede utilizar AWS SCT para convertir datos de Amazon Redshift a los siguientes destinos:
• Amazon Redshift
Privilegios para Amazon Redshift como base de datos

de origen
Los privilegios necesarios para usar Amazon Redshift como origen se enumeran a continuación:
• USAGE ON SCHEMA <schema_name>

• SELECT ON ALL TABLES IN SCHEMA <schema_name>
• SELECT ON PG_CATALOG.PG_STATISTIC
• SELECT ON SVV_TABLE_INFO
• SELECT ON TABLE STV_BLOCKLIST
• SELECT ON TABLE STV_TBL_PERM
Conexión a Redshift como origen

Utilice el siguiente procedimiento para conectarse a su base de datos de origen Amazon Redshift con la
Para conectarse a una base de datos de Amazon Redshift de origen
1. En la Herramienta de conversión de esquemas de AWS, seleccione Connect to Source Amazon

Redshift (Conectarse a de origen).
Aparecerá el cuadro de diálogo Connect to Amazon Redshift (Conectarse a).
Version 1.0
65
Conexión a Redshift como origen
2. Proporcione la información de conexión de la base de datos de Amazon Redshift de origen. Utilice las

de datos de origen.

Base de datos Escriba el nombre de la base de datos de Amazon Redshift.

Note

necesario.

Version 1.0
66
Utilizar Oracle DW como origen para Herramienta

contenga certificados. Debe añadir esta ubicación en Global
Settings antes de que aparezca aquí.
Para obtener más información sobre la compatibilidad con SSL

de Amazon Redshift, consulte Configuración de las opciones de
seguridad para las conexiones.

Redshift Driver Path Escriba la ruta al controlador que quiere usar para conectarse
necesarios (p. 8).

global (p. 10).
de origen.
Utilizar Oracle DW como origen para Herramienta

Puede utilizar AWS SCT para convertir datos de Oracle DW a Amazon Redshift.
conexión a origen, conexión a destino, información de referencia, permisos
Privilegios para Oracle Data Warehouse como origen

Los privilegios necesarios para Oracle Data Warehouse como origen se enumeran a continuación:
• connect
• select_catalog_role
• select any dictionary
Conexión a OracleDW como origen

Utilice el siguiente procedimiento para conectarse a su base de datos de almacén de datos de Oracle de
origen con la Herramienta de conversión de esquemas de AWS.
Version 1.0
67
Para conectarse a una base de datos de Oracle Data Warehouse de origen
1. En la Herramienta de conversión de esquemas de AWS, seleccione Connect to Oracle DW (Conectar

a Oracle DW).
Aparecerá el cuadro de diálogo Connect to Oracle.
2. Proporcione la información de conexión de la base de datos de Oracle Data Warehouse de origen.

Utilice las instrucciones de la siguiente tabla.
Type Seleccione el tipo de conexión a la base de datos. En función de

su tipo, proporcione la siguiente información adicional:
• SID
• Oracle SID: el ID del sistema (SID) de Oracle. Para encontrar
el SID de Oracle, envíe la siguiente consulta a su base de
datos de Oracle:
SELECT sys_context('userenv','instance_name')
AS SID FROM dual;
• Nombre del servicio
Version 1.0
68

• Service Name: el nombre del servicio de Oracle al que
conectarse.
• TNS Alias
• TNS file path: la ruta al archivo que contiene la información
de conexión del nombre Transparent Network Substrate
(TNS).
• TNS file path: el alias TNS de este archivo que utilizar para
conectarse a la base de datos de origen.
• TNS Connect Identifier
• TNS identifier: identificador de la información de conexión del
TNS registrado.

Note

necesario.
• SSL Authentication: seleccione esta opción para utilizar

autenticación SSL para la conexión.
• Key Store: la ubicación de un almacén de claves que contenga
una clave privada y certificados. Este valor es obligatorio si está
seleccionado SSL Authentication. De lo contrario, es opcional.
• Trust Store Password: contraseña del almacén de claves. Este
valor es obligatorio si está seleccionado SSL Authentication. De
lo contrario, es opcional.

Version 1.0
69
Utilizar Teradata como origen para Herramienta
Oracle Driver Path Escriba la ruta al controlador que quiere usar para conectarse
necesarios (p. 8).

global (p. 10).
de origen.
Utilizar Teradata como origen para Herramienta de

Puede utilizar AWS SCT para convertir datos de Teradata a Amazon Redshift.
Privilegios para Teradata como origen

Los privilegios necesarios para Teradata como origen se enumeran a continuación:
• SELECT ON DBC
Conexión a Teradata como origen

Utilice el siguiente procedimiento para conectarse a su base de datos de origen de Teradata con la
Para conectarse a su base de datos Teradata de origen
1. En la Herramienta de conversión de esquemas de AWS, seleccione Connect to Teradata (Conectar a

Teradata).
Aparecerá el cuadro de diálogo Connect to Teradata.
Version 1.0
70
2. Proporcione la información de conexión de la base de datos Teradata de origen. Utilice las


de datos de origen.

Base de datos Escriba el nombre de la base de datos Teradata.

Note

necesario.

Version 1.0
71
Encrypt Data Seleccione esta opción si desea cifrar los datos que intercambie
con la base de datos.
Teradata Driver Path Escriba la ruta al controlador que quiere usar para conectarse
necesarios (p. 8).

global (p. 10).
de origen.
Uso de la autenticación LDAP con un origen Teradata

Para configurar la autenticación LDAP (Lightweight Directory Access Protocol) para los usuarios de
Teradata que ejecutan Microsoft Active Directory en Windows, use el siguiente procedimiento.
En los ejemplos del procedimiento, el dominio de Active Directory es test.local.com. El servidor de

Windows es DC y está configurado con la configuración predeterminada. La cuenta de usuario creada en
Active Directory es test_ldapy la cuenta utiliza la contraseña test_ldap.
1. En el directorio /opt/teradata/tdat/tdgss/site, edite el archivo

TdgssUserConfigFile.xml. Cambie la sección LDAP a lo siguiente.
AuthorizationSupported="no"
LdapServerName="DC.test.local.com"
LdapServerPort="389"
LdapServerRealm="test.local.com"
LdapSystemFQDN="dc= test, dc= local, dc=com"
LdapBaseFQDN="dc=test, dc=local, dc=com"
Aplique los cambios ejecutando la configuración como se indica a continuación.
#cd /opt/teradata/tdgss/bin
#./run_tdgssconfig
2. Pruebe la configuración mediante el siguiente comando.
# /opt/teradata/tdat/tdgss/14.10.03.01/bin/tdsbind -u test_ldap -w test_ldap
El resultado debería ser similar al siguiente.
Version 1.0
72
Utilizar Netezza como origen para Herramienta
LdapGroupBaseFQDN: dc=Test, dc=local, dc=com

LdapUserBaseFQDN: dc=Test, dc=local, dc=com
LdapSystemFQDN: dc= test, dc= local, dc=com
LdapServerName: DC.test.local.com
LdapServerPort: 389
LdapServerRealm: test.local.com
LdapClientUseTls: no
LdapClientTlsReqCert: never
LdapClientMechanism: SASL/DIGEST-MD5
LdapServiceBindRequired: no
LdapClientTlsCRLCheck: none
LdapAllowUnsafeServerConnect: yes
UseLdapConfig: no
AuthorizationSupported: no
FQDN: CN=test, CN=Users, DC=Anthem, DC=local, DC=com
AuthUser: ldap://DC.test.local.com:389/CN=test1,CN=Users,DC=test,DC=local,DC=com
DatabaseName: test
Service: tdsbind
3. Reinicie TPA utilizando el siguiente comando.
#tpareset -f "use updated TDGSSCONFIG GDO"
4. Cree el mismo usuario en la base de datos de Teradata que en Active Directory, tal y como se muestra
a continuación.
CREATE USER test_ldap AS PERM=1000, PASSWORD=test_ldap;

GRANT LOGON ON ALL TO test WITH NULL PASSWORD;
Si cambia la contraseña de usuario en Active Directory para su usuario LDAP, debe especificar esta nueva
contraseña durante la conexión a Teradata en modo LDAP. En el modo DEFAULT, sigue siendo necesario
conectarse a Teradata con el nombre de usuario y una contraseña de LDAP.
Utilizar Netezza como origen para Herramienta de

Puede utilizar AWS SCT para convertir datos de Netezza a Amazon Redshift.
Privilegios para Netezza como origen

Los privilegios necesarios para Netezza como origen se enumeran a continuación:
• SELECT ON SYSTEM.DEFINITION_SCHEMA.SYSTEM VIEW

• SELECT ON SYSTEM.DEFINITION_SCHEMA.SYSTEM TABLE
• SELECT ON SYSTEM.DEFINITION_SCHEMA.MANAGEMENT TABLE
• LIST ON <database_name>
• LIST ON <database_name>.ALL.TABLE
Version 1.0
73
Conexión a Netezza como origen
• LIST ON <database_name>.ALL.EXTERNAL TABLE

• LIST ON <database_name>.ALL.VIEW
• LIST ON <database_name>.ALL.MATERIALIZED VIEW
• LIST ON <database_name>.ALL.PROCEDURE
• LIST ON <database_name>.ALL.SEQUENCE
• LIST ON <database_name>.ALL.FUNCTION
• LIST ON <database_name>.ALL.AGGREGATE
Conexión a Netezza como origen

Utilice el siguiente procedimiento para conectarse a su base de datos de origen de Netezza con la
Para conectarse a una base de datos Netezza de origen
1. En la Herramienta de conversión de esquemas de AWS, seleccione Connect to Netezza (Conectar a

Netezza).
Aparecerá el cuadro de diálogo Connect to Netezza.
2. Proporcione la información de conexión de la base de datos Netezza de origen. Utilice las


de datos de origen.


Version 1.0
74
Utilizar Greenplum como origen para Herramienta

Note

necesario.

Netezza Driver Path Escriba la ruta al controlador que quiere usar para conectarse
necesarios (p. 8).

global (p. 10).
de origen.
Utilizar Greenplum como origen para Herramienta

Puede utilizar AWS SCT para convertir datos de Greenplum a Amazon Redshift.
Privilegios para Greenplum como origen

Los privilegios necesarios para Greenplum como origen se enumeran a continuación:
• CONNECT ON DATABASE <database_name>

Conexión a Greenplum como origen

Utilice el siguiente procedimiento para conectarse a su base de datos de origen de Greenplum con la
Version 1.0
75
Conexión a Greenplum como origen
Para conectarse a una base de datos Greenplum de origen
1. En la Herramienta de conversión de esquemas de AWS, seleccione Connect to Greenplum (Conectar

a Greenplum).
Aparecerá el cuadro de diálogo Connect to Greenplum.
2. Proporcione la información de conexión de la base de datos Greenplum de origen. Utilice las


de datos de origen.

Base de datos Escriba el nombre de la base de datos Greenplum.

Note

Version 1.0
76
Utilizar Vertica como origen para Herramienta

necesario.


Greenplum Driver Path Escriba la ruta al controlador que quiere usar para conectarse
necesarios (p. 8).

global (p. 10).
de origen.
Utilizar Vertica como origen para Herramienta de

Puede utilizar AWS SCT para convertir datos de Vertica a Amazon Redshift.
Privilegios para Vertica como origen

Los privilegios necesarios para Vertica como origen se enumeran a continuación:

• USAGE ON SCHEMA PUBLIC
• GRANT SELECT ON ALL TABLES IN SCHEMA <schema_name>
• SELECT ON ALL SEQUENCES IN SCHEMA <schema_name>
• EXECUTE ON ALL FUNCTIONS IN SCHEMA <schema_name>
• EXECUTE ON PROCEDURE <schema_name.procedure_name(procedure_signature)>
Version 1.0
77
Conexión a Vertica como origen
Conexión a Vertica como origen

Utilice el siguiente procedimiento para conectarse a su base de datos de origen de Vertica con la
Para conectarse a su base de datos Vertica de origen
1. En la Herramienta de conversión de esquemas de AWS, seleccione Connect to Vertica (Conectar a

Vertica).
Aparecerá el cuadro de diálogo Connect to Vertica.
2. Proporcione la información de conexión de la base de datos Vertica de origen. Utilice las instrucciones
de la siguiente tabla.

de datos de origen.

Base de datos Escriba el nombre de la base de datos Vertica.

Version 1.0
78
Uso de Microsoft SQL Server DW como origen para

Note

necesario.
• Trust Store: un almacén de confianza que haya configurado en

la configuración global.
• Key Store: un almacén de claves que haya configurado en la
configuración global.

Vertica Driver Path Escriba la ruta al controlador que quiere usar para conectarse
necesarios (p. 8).

global (p. 10).
de origen.
Uso de Microsoft SQL Server DW como origen para

Puede utilizar AWS SCT para convertir datos de Microsoft SQL Server DW a Amazon Redshift.
Version 1.0
79
Fuente: Microsoft SQL Server Data Warehouse
Privilegios para Microsoft SQL Server Data

Warehouse como origen
Los privilegios necesarios para Microsoft SQL Server Data Warehouse como origen se enumeran a
continuación:
• VIEW DEFINITION
• VIEW DATABASE STATE
• SELECT ON SCHEMA :: <schema_name>
Repita la concesión para cada base de datos cuyo esquema vaya a convertir.
Además, conceda el siguiente privilegio, y ejecute la concesión en la base de datos maestra:
• VIEW SERVER STATE
Conexión a SQLServerDW como origen

Utilice el siguiente procedimiento para conectarse a su base de datos de almacén de datos Microsoft SQL
Server de origen con la Herramienta de conversión de esquemas de AWS.
Para conectarse a una base de datos de Microsoft SQL Server Data Warehouse de origen
1. En la Herramienta de conversión de esquemas de AWS, elija Connect to Microsoft SQL Server DW

(Conectar a Microsoft SQL Server DW).
Aparecerá el cuadro de diálogo Connect to Microsoft SQL Server DW.
Version 1.0
80
2. Proporcione la información de conexión a la base de datos de Microsoft SQL Server Data Warehouse
de origen. Utilice las instrucciones de la siguiente tabla.

de datos de origen.

Instance name Escriba el nombre de la instancia de la base de datos de SQL

Server. Para encontrar el nombre de la instancia, ejecute la
consulta SELECT @@servername; en su base de datos de SQL
Server.

Note

necesario.
Use SSL Seleccione esta opción si desea utilizar capa de conexión

segura (SSL) para conectarse a la base de datos. Proporcione
la siguiente información adicional, según proceda, en la pestaña
SSL:
• Trust Server Certificate: seleccione esta opción para confiar en

el certificado del servidor.
• Trust Store: un almacén de confianza que haya configurado en
la configuración global.

Sql Server Driver Path Escriba la ruta al controlador que quiere usar para conectarse
necesarios (p. 8).

global (p. 10).
Version 1.0
81
de origen.
Version 1.0
82
Informes de evaluación de migración
Creación de informes de conversión

Cuando se programa una conversión de base de datos, resulta útil crear algunos informes que ayuden a
entender todo lo que implica. Puede crear informes usando Herramienta de conversión de esquemas de
AWS o AWS Workload Qualification Framework (AWS WQF).
Puede utilizar AWS SCT para crear un informe de evaluación de la migración de la base de datos. Con
este informe, obtendrá un resumen de sus tareas de conversión del esquema y detalles de elementos que
no se pueden convertir automáticamente a la base de datos de destino. Puede utilizar este informe para
evaluar qué parte del proyecto se puede realizar con Herramienta de conversión de esquemas de AWS, y
qué más tiene que hacer para completar la conversión. Para crear un informe de evaluación, utilice Create
Report (Crear informe) en el menú contextual (clic con el botón derecho) de la base de datos en AWS SCT.
Puede utilizar AWS WQF durante la fase de planificación de la migración para obtener información
acerca de qué nivel de esfuerzo se necesita para migrar los datos y las aplicaciones. WQF es una
aplicación independiente que está integrada con AWS SCT y AWS DMS. Puede utilizarla para crear
informes de inventario e informes de calculadora de costos. Para configurar WQF, vaya a Global Settings
(Configuración global) en la aplicación SCT y configure los controladores de JDBC necesarios para sus
bases de datos de origen. A continuación, inicie WQF y siga las instrucciones en la pantalla que se abre en
AWS Cloud9.
Temas
• Creación de informes de evaluación con Herramienta de conversión de esquemas de AWS (p. 83)
• Creación de informes de migración con Workload Qualification Framework (p. 88)
Creación de informes de evaluación con

Una parte importante de Herramienta de conversión de esquemas de AWS es el informe de evaluación de
la migración de la base de datos que se genera para ayudarle a convertir su esquema. El informe resume
todas las tareas de conversión del esquema y detalla los elementos de acción del esquema que no se
hayan podido convertir al motor de la base de datos de su instancia de destino. Puede ver el informe en la
aplicación. Para ello, expórtelo como un archivo de valores separados por comas (CSV) o PDF.
El informe de evaluación de la migración incluye lo siguiente:
• Resumen ejecutivo
• Evaluación de licencias
• Compatibilidad con la nube, que indica las características de la base de datos de origen no disponibles
en el destino
• Configuración de hardware de origen actual
• Recomendaciones, incluida la conversión de objetos de servidor, sugerencias de backup y cambios en el
servidor enlazado
El informe incluye la siguiente información acerca de una instancia de base de datos de Amazon RDS si ha
seleccionado Amazon RDS en el destino:
Version 1.0
83
Creación de un informe de evaluación
de la migración de la base de datos
• El tamaño de almacenamiento utilizado actualmente y el tamaño máximo de almacenamiento para la

instancia de base de datos.
• El número actual de bases de datos de la instancia de base de datos y el número máximo de bases de
datos permitidas en la instancia de base de datos.
• Una lista de los servicios de base de datos y objetos de servidor que no están disponibles en la instancia
de base de datos.
• Una lista de las bases de datos que participan actualmente en la replicación. Amazon RDS no admite la
replicación.
El informe incluye también estimaciones de la cantidad de esfuerzo necesario para escribir el código
equivalente para su instancia de base de datos de destino que no se pudo convertir automáticamente.
Este campo de complejidad estimada se exporta en la versión PDF del informe de evaluación, pero no se
incluye en la versión CSV.
Si utiliza AWS SCT para migrar su esquema existente a una instancia de base de datos de Amazon RDS,
el informe puede ayudarle a analizar los requisitos para migrar a la nube de AWS y para cambiar el tipo de
licencia.
Puede encontrar más información en los temas siguientes:
Temas
• Creación de un informe de evaluación de la migración de la base de datos (p. 84)
• Visualización del informe de evaluación (p. 85)
• Guardar el informe de evaluación (p. 87)
Creación de un informe de evaluación de la migración

de la base de datos
Utilice el siguiente procedimiento para crear un informe de evaluación de la migración de la base de datos.
Para crear un informe de evaluación de la migración de la base de datos
1. En el panel de la izquierda que muestra el esquema de la base de datos de origen, elija el objeto del
esquema para el que desea crear un informe de evaluación.
2. Abra el menú contextual (clic secundario) para el objeto y seleccione Create Report.
Version 1.0
84
Visualización del informe de evaluación

Tras crear un informe de evaluación, se abrirá la vista del informe de evaluación, mostrando las siguientes
pestañas.
• Resumen
• Elementos de acción
En la pestaña Summary (Resumen) se muestran los elementos convertidos automáticamente o no

convertidos.
La pestaña Action Items (Elementos de acción) muestra los elementos que no se han podido convertir
automáticamente y recomendaciones sobre qué hacer con ellos.
Temas
• Resumen de un informe de evaluación (p. 85)
• Elementos de acción del informe de evaluación (p. 86)
Resumen de un informe de evaluación

En la pestaña Summary se muestra la información resumida del informe de evaluación de la migración de
la base de datos. Muestra los elementos que se hayan convertido automáticamente y los elementos que no
se hayan convertido automáticamente.
Version 1.0
85
Para los elementos del esquema que no se puedan convertir automáticamente al motor de base de datos
de destino, el resumen incluye una estimación del esfuerzo necesario para crear elementos del esquema
en su instancia de base de datos de destino que sean equivalentes a los de su base de datos de origen.
En el informe, el tiempo estimado para convertir estos elementos del esquema se clasifica en los
siguientes grupos:
• Simple: – acciones que se pueden realizar en menos de una hora.

• Medium: – acciones que son más complejas y se pueden realizar en el plazo de una a cuatro horas.
• Significant: – acciones que son muy complejas y requieren más de cuatro horas.
La sección License Evaluation and Cloud Support contiene información sobre el traslado de sus esquemas
de bases de datos locales existentes a una instancia de base de datos de Amazon RDS que ejecute
el mismo motor. Por ejemplo, si desea cambiar tipos de licencia, esta sección del informe le indica qué
características de su base de datos actual deberían eliminarse.
Elementos de acción del informe de evaluación

La vista del informe de evaluación incluye también una pestaña Action Items. Esta pestaña contiene una
lista de los elementos que no se pueden convertir automáticamente en el motor de base de datos de su
instancia de base de datos de Amazon RDS de destino. Si selecciona un elemento de acción de la lista,
AWS SCT resalta el elemento en el esquema al que se aplica el elemento de acción.
El informe también contiene recomendaciones sobre cómo convertir el elemento del esquema de forma
manual. Para obtener más información sobre decidir cómo administrar las conversiones manuales,
consulte Administración de conversiones manuales en la Herramienta de conversión de esquemas de
AWS (p. 107).
Version 1.0
86
Guardar el informe de evaluación
Guardar el informe de evaluación

Puede guardar una copia local del informe de evaluación de la migración de la base de datos en formato
PDF o como un archivo de valores separados por comas (CSV). El archivo CSV contiene solamente
información de elementos de acción. El archivo PDF contiene el resumen de acciones e información de los
elementos de acción, tal y como se muestra en el siguiente ejemplo.
Version 1.0
87
Informes de migración de WQF
Creación de informes de migración con Workload

Qualification Framework
Workload Qualification Framework de AWS (WQF de AWS) es una aplicación independiente que se
incluye en AWS SCT. Puede utilizar WQF para analizar la migración a la nube de AWS. Evalúa y
califica la carga de trabajo para toda la migración, incluida la base de datos y las modificaciones de la
aplicación. WQF le recomienda estrategias y herramientas que puede utilizar para la migración y le ofrece
comentarios que puede utilizar para realizar cambios. También puede identificar acciones que debe
adoptar en una base de datos para completar una migración a Amazon RDS o Amazon Aurora.
Puede utilizar WQF en los siguientes casos de migración:
• Conversión a Amazon RDS para PostgreSQL o Compatibilidad de Aurora con PostgreSQL
Version 1.0
88
Configuración del WQF de AWS
• Oracle a Amazon RDS para MySQL o Compatibilidad de Aurora con MySQL

• Microsoft SQL Server a Amazon RDS PostgreSQL o Aurora PostgreSQL
Puede utilizar WQF durante la fase de planificación de su proceso de migración para determinar lo que
tiene que hacer para migrar sus datos y aplicaciones. SCT accede a su conversión de esquemas; en
cambio, WQF notifica lo siguiente:
• Evaluación de la carga de trabajo según la complejidad, el tamaño y la tecnología utilizada

• Recomendaciones sobre las estrategias de migración
• Recomendaciones sobre las herramientas de migración
• Comentarios sobre qué hacer exactamente
• Evaluación del esfuerzo necesario basándose en el número de personas implicadas en el proyecto de
migración
Temas
• Configuración del WQF de AWS (p. 89)
• Preparación para importaciones de lotes de componentes lógicos y físicos (p. 90)
• Creación de informes de WQF (p. 93)
• Descripción de las categorías de la carga de trabajo (p. 96)
Configuración del WQF de AWS

WQF de AWS viene en una Imagen de Amazon Machine (AMI) preconfigurada con Microsoft Windows
Server, AWS SCT y WQF preinstalados. Puede conectarse a ella utilizando una aplicación de escritorio
remoto.
Utilice el siguiente procedimiento para lanzar la AMI compartida. Antes de comenzar, asegúrese de que
dispone de un par de claves activas almacenadas en un archivo .pem en el disco duro local.
Lanzar la AMI compartida y configurar el WQF
1. Elija una de las siguientes opciones:
• Visite la página Workload Qualification Framework de AWS Marketplace y lance la AMI en su

cuenta.
• Busque Workload Qualification Framework en el Asistente para el lanzamiento de EC2 para buscar
la AMI. A continuación, iníciela en su cuenta.
2. Elija una instancia de tipo m5a.4xlarge o mayor y añada al menos 100 GiB a su almacenamiento.
Necesita su archivo .pem para este paso.
Si no está familiarizado con el lanzamiento de AMI o la creación de instancias de EC2, vea este breve
vídeo de soporte de AWS: How do I launch an EC2 instance from a custom Amazon Machine Image
(AMI) (¿Cómo puedo lanzar una instancia de EC2 desde una Imagen de Amazon Machine (AMI)
personalizada)
3. En la consola de EC2, elija Instances (Instancias). Cuando la instancia esté disponible, abra su
menú contextual (clic con el botón derecho) y elija Get Windows Password (Obtener contraseña de
Windows). Recupere la contraseña utilizando el mismo archivo .pem utilizado en el paso anterior para
configurar la instancia.
4. Conéctese a la instancia usando una aplicación de escritorio remoto. Para obtener más información,
consulte Conexión con su instancia de Windows.
Version 1.0
89
Preparación para importaciones de lotes
Después de configurar SCT y WQF, debe configurar los controladores de la base de datos en SCT antes
de usar WQF. Use el siguiente procedimiento para configurar los controladores.
1. Localice y descargue los controladores de Java Database Connectivity (JDBC) para sus orígenes de
datos. Coloque los archivos .jar en la máquina que tiene SCT y WQF instalados. Para obtener más
información, consulte Instalación de los controladores de bases de datos necesarios (p. 8).
2. Abra SCT y elija Settings (Configuración) y, a continuación, elija Global Settings (Configuración
global).
3. Elija la pestaña Drivers (Controladores).
4. Para cada origen de datos, utilice Browse (Examinar) para desplazarse a la ubicación del archivo .jar.
5. Elija Aceptar para confirmar.
Preparación para importaciones de lotes de

componentes lógicos y físicos
Si analiza varios servidores, puede simplificar el proceso al realizar una importación de lote de los
componentes lógicos y físicos. Para ello, puede reunir información antes de utilizar WQF. De esta manera
no tiene que introducir la información de forma manual para cada servidor en la IU. Esto funciona en
situaciones donde WQF no tiene acceso a los servidores. También puede utilizar este método en el modo
online, donde WQF puede acceder a los servidores.
Para ejecutar el modo del lote, tiene que generar dos archivos:
• Un archivo JSON que contenga componentes lógicos

• Un archivo de valores separados por comas (CSV) que contenga componentes físicos.
Puede utilizar el método que prefiera para crear estos archivos. Para ambos archivos, si ejecuta WQF
totalmente offline, no tiene que proporcionar el nombre de usuario o la contraseña. Esto se debe a que en
el modo offline no se conecta a ningún servidor. En las siguientes secciones, proporcionamos plantillas
para estos archivos.
Note
Existen dos flujos de trabajo independientes para la creación de componentes. Cargue un

archivo .zip de un proyecto de AWS SCT o cargue un análisis de toda la flota con archivos JSON
y CSV. No tiene que hacer ambas opciones.
Plantilla de ejemplo para los componentes lógicos para la

importación de lotes (JSON)
Los siguientes ejemplos muestran el JSON que puede utilizar para los componentes lógicos para la
importación de lotes de WQF en el modo online y offline.
El siguiente ejemplo muestra el JSON que puede utilizar cuando ejecute el WQF en el modo offline.
En el modo offline, puede eliminar username, password y connection-type de su JSON.
También puede añadir un campo adicional a su JSON. El campo adicional se denomina sct-
file y los valores que incluye son la ruta de directorio completa y el nombre del archivo .zip de las
estadísticas generado por la SCT. A continuación se muestra un ejemplo: D:\Temp\WQF\Oracle-
WqfStats-2019-03-09-01-56.zip. Para el modo offline, el ejemplo de JSON es como el siguiente.
{
"name": "component_name",
"description": "My description",
Version 1.0
90
"type": "database",
"properties": {
"number-of-advance-config-features": "123",
"has-proprietary-logic-in-OLAP": "true",
"number-of-hardware-features": "100"
},
"selected-schemas": [
{
"schema": "schema_name"
}
],
"source-dialect": "ORACLE",
"source-connection-config": {
"server": "host",
"server-port": "port",
"sid": "ORCL"
},
"sct-file": "D:\\Temp\\WQF\\Oracle-WqfStats-2019-03-09-01-56.zip"
}
El siguiente ejemplo muestra el JSON que puede utilizar para componentes lógicos cuando ejecute el
WQF en el modo online.
[
{
"name": "component_name",
"description": "My description",
"type": "database",
"properties": {
},
{
}
],
"source-dialect": "ORACLE",
"server": "host",
"sid": "sid",
"username": "user",
"password": "pass",
"connection-type": "SID"
}
},
{
"name": "component_name1",
"description": "My new Description",
"type": "database",
"properties": {
},
{
"database": "db_name",
}
],
"source-dialect": "MSSQL",
Version 1.0
91
"server": "host",
"sid": "",
"username": "user",
"password": "pass"
}
},
{
"name": "component_name2",
"description": "description",
"type": "application",
"properties": {
"source-unavailable": "false",
"number-of-native-code-extensions": 1,
"number-af-advance-config-features": 2,
"number-of-hardware-features": 3
},
"language": "JAVA",
{
"database": "db_name",
}
],
"source-code-path": "path_to_application_files",
"source-dialect": "MSSQL",
"server": "host",
"sid": "",
"username": "user",
"password": "pass"
}
}
]
Plantilla de ejemplo para los componentes físicos para la

importación de lotes (CSV)
Los siguientes ejemplos muestran un archivo .csv que puede utilizar para los componentes físicos.
Si abre este archivo .csv en Microsoft Excel, puede ver los campos indicados. De este modo, podría
facilitar la edición si no exporta sus componentes físicos de forma programada. Como hoja de cálculo, el
archivo tiene un aspecto similar al siguiente.
Note
Si ejecuta en modo offline, tiene que añadir un campo adicional al siguiente CSV. El campo
adicional debería denominarse SCTFILE y los valores que incluye deberían ser la ruta de
directorio completa y el nombre del archivo .zip de las estadísticas generado por la SCT. Un
ejemplo es: D:\Temp\WQF\Oracle-WqfStats-2019-03-09-01-56.zip.
El archivo .csv es el siguiente.
NAME,serverName,port,instanceName/
SID,userName,password,databaseType,description,hasHADRRequirements,hasHeavyGeospatialPayload
component_name,host,port,sid,user,password,Oracle,mycomponent,true,false
El mismo archivo, mostrado en formato de hoja de cálculo, es el siguiente.
Version 1.0
92
Creación de informes
NAME serverName
port instanceName/
userNamepassworddatabaseType
description
hasHADRRequirements
hasHeavyGeospatia
SID
component_name
host port sid user passwordOracle mycomponent
TRUE FALSE
Creación de informes de WQF

Para crear informes de migración con WQF, siga los siguientes pasos:
1. Crear un proyecto de WQF.

2. Añadir una aplicación o aplicaciones al proyecto.
3. Añadir un componente o componentes físicos para cada aplicación del proyecto. De este modo, WQF
recopila información detallada acerca del servidor de su base de datos de origen.
Puede utilizar una instalación local de SCT o un archivo .zip de otra máquina.
4. Añadir un componente lógico o más para cada aplicación del proyecto. De este modo, WQF recopila
información detallada acerca de objetos de base de datos y aplicaciones.
Puede utilizar una instalación local de SCT o un archivo .zip de otra máquina.
5. Generar el inventario y los informes de análisis WQF para planificar el proyecto.
6. Copiar los archivos de informes descargados en una máquina con Microsoft Excel instalado y abrirlos
para obtener información detallada sobre el proyecto de migración.
Puede elegir los siguientes tipos de informes:
• Informes de inventario
Estos informes enumeran la información basada en características y de hardware sobre el servidor de

base de datos desde el que está intentando migrar. Los datos necesarios para este informe se recopilan
utilizando los componentes físicos en el que los usuarios pueden introducir los detalles de un servidor
de base de datos desde el que recopilar información. Puede utilizar la información de este informe para
ayudarle a planificar la migración de un servidor de bases de datos.
• Informes de calculadora de costos
Estos informes categorizan la carga de trabajo que está intentando migrar. Detallan elementos de todos
los componentes lógicos y físicos que se han seleccionado como parte de la aplicación. El informe
incluye un modelo de costos de migración que se puede modificar basándose en los resultados de SCT
y recomendaciones sobre cómo realizar las migraciones por aplicación junto con pasos que hay que
seguir para migrar. El informe de calculadora de costos también incluye un informe de inventario.
Puede ver estos informes en Microsoft Excel o cualquier aplicación que admita el formato Office Open
XML.
Temas
• Inicio de WQF (p. 93)
• Creación y edición de un proyecto de WQF (p. 94)
Inicio de WQF
Después de configurar SCT y WQF, inicie el servicio WQF haciendo doble clic en el icono WQF Start
(Inicio de WQF) en el escritorio. Se abre una serie de ventanas de terminal cuando se inicia WQF.
Version 1.0
93
Después de iniciarse correctamente WQF, utilice Google Chrome (preinstalado en la AMI) y vaya a http://
localhost:4040/ide.html. De este modo, se abre el módulo de WQF en la consola de AWS Cloud9.
Creación y edición de un proyecto de WQF

El proyecto de WQF proporciona una función de contenedor para componentes de aplicaciones, como
bases de datos, máquinas físicas y el código de la aplicación. Puede guardar y regresar al proyecto de
WQF más adelante. Puede mantener varios proyectos de migración a la vez.
Crear o ver un proyecto de migración e informes
1. Para crear un nuevo proyecto, abra WQF e introduzca un nombre descriptivo para su proyecto en
Create new project (Crear nuevo proyecto). A continuación, elija Create.
También puede elegir un proyecto existente a la izquierda.

2. Se muestra una nueva pantalla. Elija una de las siguientes opciones:
• Para iniciar el asistente, elija Create report (Crear informe). Este asistente le guía a través de todos
los pasos necesarios para utilizar la aplicación WQF.
• Para obtener acceso a un informe existente, selecciónelo en la lista. Puede ver, editar o eliminar un
informe o cambiar su tipo de informe.
3. En la pantalla Report (Informe), elija un tipo de informe para Type (Tipo). Introduzca un nombre y una
descripción opcional para su informe.
Elija Next para continuar.

4. En la pestaña Physical Components (Componentes físicos), proporcione datos sobre los componentes
físicos de su sistema de base de datos o flota.
El análisis de componentes físicos ayuda a recopilar información detallada sobre el servidor de la base
de datos de origen para el informe de inventario. Basándose en el uso de características avanzadas,
WQF incluye algunos detalles para calcular categorización general del proyecto de migración. Puede
elegir crear un componente físico único usando SCT (o cargando un archivo .zip de un proyecto de
SCT). También puede cargar detalles de varios componentes físicos como un archivo JSON para
realizar análisis de componentes físicos de toda la flota.
Elija una de las siguientes opciones:
• Para conectarse a nuevos componentes físicos, elija New (Nuevo). Escriba un nombre descriptivo y
una descripción opcional y, a continuación, elija una base de datos de origen. Si desea proporcionar
más información, siga las instrucciones en pantalla. Seleccione Next (Siguiente).
• Para importar un archivo CSV, seleccione Import (Importar). Para obtener más información acerca
del formato del archivo de registro, consulte Plantilla de ejemplo para los componentes físicos para
la importación de lotes (CSV) (p. 92).
En la pantalla Import physical components from CSV file (Importar componentes físicos de archivo
CSV), seleccione Choose (Elegir) para ir a su archivo CSV y, a continuación, elija Save (Guardar).
Seleccione Cancel (Cancelar) para volver a la pantalla Physical Components (Componentes físicos)
sin realizar cambios.
Elija Next (Siguiente) para continuar.

5. En el panel Data Collection (Recopilación de datos) de la pestaña Physical Components
(Componentes físicos), puede seleccionar si cargar sus estructuras de datos desde un archivo de
almacenamiento o desde la base de datos.

Version 1.0
94
• Para importar un archivo ZIP, elija Load from Archive (Cargar desde archivo). Elija Choose (Elegir)
para ir a su archivo CSV, a continuación, seleccione Open (Abrir). Para obtener más información
sobre del formato del archivo de registro, consulte Plantilla de ejemplo para los componentes físicos
para la importación de lotes (CSV) (p. 92).
• Para conectarse a su base de datos (valor predeterminado), elija Load from DB (Cargar desde BD)
e introduzca los detalles de conexión:
• Nombre de servidor o dirección IP
• Puerto de servidor
• Nombre de instancia (opcional)
• Nombre de usuario
• Contraseña
• Habilitar o no la Capa de conexión segura (SSL)
Para realizar la recopilación de datos ahora, elija Get schemas (Obtener esquemas) y elija los
esquemas que incluir y haga clic en Save (Guardar).
Repita este paso hasta que haya cargado todos sus componentes físicos. A continuación elija Next
(Siguiente) para continuar.
6. (Solo para informes de calculadora de costos) En la pestaña Logical Components (Componentes
lógicos), puede cargar los componentes lógicos de su sistema. El análisis de componentes lógicos
ayuda a WQF a recopilar información sobre lo siguiente:
• Objetos de bases de datos: analizar y categorizar complejidad de convertir objetos de la base de

datos para el objetivo de elección
• Código de la aplicación: analizar y categorizar el SQL incrustado en el código de la aplicación para
el objetivo de elección
Puede elegir crear un componente lógico único usando SCT (o cargando un archivo zip de un
proyecto de SCT). Como alternativa, puede cargar detalles de varios componentes lógicos como un
archivo JSON para realizar análisis de componentes lógicos de toda la flota.
• Para conectarse a nuevos componentes físicos, elija New (Nuevo). Escriba un nombre descriptivo
y una descripción opcional y, a continuación, elija un tipo y una base de datos de origen. Si desea
proporcionar más información, siga las instrucciones en pantalla. Seleccione Next (Siguiente).
• Para importar un archivo CSV, seleccione Import (Importar). Para obtener más información sobre
del formato del archivo de registro, consulte Plantilla de ejemplo para los componentes lógicos para
la importación de lotes (JSON) (p. 90).
En la pantalla Import physical components from CSV file (Importar componentes físicos de archivo
CSV), seleccione Choose (Elegir) para ir a su archivo CSV y, a continuación, elija Save (Guardar).
Si desea cerrar esta pantalla sin realizar los cambios, seleccione Cancel (Cancelar) para volver a la
pantalla Physical Components (Componentes físicos).
7. (Solo para informes de calculadora de costos) En el panel Data Collection (Recopilación de datos) de
la pestaña Logical Components (Componentes lógicos), puede seleccionar si cargar sus estructuras
de datos desde un archivo de almacenamiento o desde la base de datos.
• Para importar un archivo ZIP, elija Load from Archive (Cargar desde archivo). Elija Choose (Elegir)
para ir a su archivo CSV, a continuación, seleccione Open (Abrir).
Version 1.0
95
Descripción de las categorías de la carga de trabajo
• Para conectarse a su base de datos (valor predeterminado), elija Load from DB (Cargar desde BD)
e introduzca los detalles de conexión:
• Nombre o IP de servidor
• Puerto de servidor
• Nombre de instancia (opcional)
• Nombre de usuario
• Contraseña
• SSL (habilitar o no habilitar)
Elija Run (Ejecutar) para realizar ahora la recopilación de datos o seleccione Save (Guardar) para
guardar los cambios sin ejecutar el proceso. Si ejecuta en el modo offline, no tiene que ejecutar el
proceso de recopilación de datos ya que todo se encuentra en el archivo de estadísticas generado por
SCT.
Repita este paso hasta que haya cargado todos sus componentes lógicos. A continuación elija Next
(Siguiente) para continuar.
8. (Solo para informes de calculadora de costos) En la pestaña Applications (Aplicaciones), seleccione
los componentes de su aplicación. Escriba un nombre para la aplicación. En el lado izquierdo,
seleccione los componentes que desee incluir. Para eliminar componentes, elíjalos en el lado derecho
a sacarlos de la lista Selected Components (Componentes seleccionados).
Las aplicaciones constan de una combinación de componentes físicos y lógicos. Al analizar estos
de forma conjunta, WQF determina la complejidad de la migración en función de los diferentes
parámetros y detalles recopilados como parte de cada análisis de componente físicos y lógicos.
Elija Save para continuar.

9. En la pestaña Report Configuration (Configuración de informes), elija los componentes que desea
incluir en su informe.
Elija Next (Siguiente) para continuar.

10. En la pestaña Report Configuration (Configuración de informes), guarde el informe eligiendo Save
(Guardar). Si desea cambiar algo antes de guardar, seleccione Previous (Anterior).
11. En la pestaña All Reports (Todos los informes), puede ver todo el informe. Para descargar un informe,
elija Download (Descargar) o Save (Guardar).
El informe descarga en formato Open XML y puede abrirlo en un editor de Open XML como Microsoft
Excel. En el informe, puede ver la categorización con formato, el análisis y las estrategias de
migración. Los informes se generan para cada aplicación y contienen el conjunto de componentes
lógicos y físicos elegido.
12. (Opcional) Para eliminar un informe o un proyecto, elija el informe y, a continuación, elija Delete
(Eliminar).

AWS WQF evalúa su carga de trabajo de migración y clasifica en una categoría de carga de trabajo
que se caracteriza por la forma en que se diseña la base de datos y la aplicación. En función de esta
categorización, WQF analiza los componentes que el sistema utiliza y extrapola el tipo de trabajo necesario
para hacer la migración. En función de este análisis, AWS WQF calcula la facilidad o la dificultad que
puede esperar de la migración. También calcula el tipo de trabajo que supone y el nivel de esfuerzo
requerido.
Temas
• Categoría 1: cargas de trabajo que utilizan ODBC y JDBC (p. 97)
Version 1.0
96
• Categoría 2: cargas de trabajo con escaso uso de características propietarias (p. 97)
• Categoría 3: cargas de trabajo con uso intensivo de características propietarias (p. 97)
• Categoría 4: cargas de trabajo específicas de motor (p. 98)
• Categoría 5: no portable, riesgo inaceptable o cargas de trabajo de"migración directa" (p. 98)
Categoría 1: cargas de trabajo que utilizan ODBC y JDBC

Esta categoría normalmente tiene menos de 50 códigos de procedimientos almacenados personalizados o
tiene procedimientos almacenados simples que se utilizan para los controles de acceso. Las aplicaciones
con estos datos se conectan a la base de datos con Open Database Connectivity (ODBC) o Java Database
Connectivity (JDBC) en lugar de utilizar los controladores de propietarios que tienen extensiones no
estándares. La lógica de aplicación reside en el código fuera de la base de datos (Java, Python, Ruby etc.).
Para estas bases de datos, no existe requisito para apoyar una réplica de lectura o una implementación
Multi-AZ, o estas características se ofrecen a través de tecnologías basadas en replicación.
En esta categoría, los almacenes de datos utilizan un esquema de estrella o copos de nieve con una
capa de informes que utiliza SQL específico del motor, como SQL ANSI, como Amazon QuickSight o
Tableau. La portabilidad a Amazon Redshift es relativamente fácil, ya que el modelo de datos se conserva
y se definen las claves de ordenación mejoradas, las claves de distribución, la compresión y se configura
correctamente la administración de cargas de trabajo (WLM).
La portabilidad de estas cargas de trabajo a Amazon Aurora y Amazon RDS es sencilla. Una migración en
esta categoría normalmente requiere pocas horas por persona.
Categoría 2: cargas de trabajo con escaso uso de características

propietarias
Las cargas de trabajo en esta categoría utilizan una combinación de código de aplicación (Java, Python,
Ruby, etc.) y código de procedimiento almacenado. Los procedimientos almacenados se utilizan cuando
la implantación de la lógica en el código de la aplicación resulta engorrosa. Por lo general, este tipo de
carga de trabajo tiene menos de 200 procedimientos almacenados y no usa características avanzadas de
lenguaje SQL. La migración de esquemas es sencilla, ya que se utilizan estructuras de datos como tablas y
vistas.
En esta categoría, las cargas de trabajo del almacén de datos puede organizarse en tablas y
transformarlos utilizando SQL integrado en procedimientos almacenados simples. Las escrituras en el
almacén de datos pueden tener algunos microlotes o un gran número de actualizaciones, eliminaciones y
transacciones. El almacén de datos también puede utilizar extensiones de procesamiento analítico online
de propietario (OLAP) como CUBE, ROLLUP o PIVOT.
La migración implica cambiar a la lógica de procedimiento almacenada fuera de la base de datos y

rediseñar informes de SQL para abordar la falta de funciones nativas. Estas son relativamente fáciles de
migrar. Es posible que la migración de este tipo de carga de trabajo consuma un número moderado de
horas por persona.
Categoría 3: cargas de trabajo con uso intensivo de

características propietarias
Las cargas de trabajo en esta categoría ser controlan totalmente mediante la lógica avanzada de
procedimiento almacenada o características de propietarios. En el campo, muchas de las cargas de trabajo
de esta categoría tienen hasta 100 000 líneas de código residente de base de datos y características.
Estas cargas de trabajo también usan características avanzadas, como bases de datos privadas virtuales,
ofuscación de columnas, opciones de ajuste y tipos definidos por el usuario. Su conversión en entornos
de ejecución alternativos consumen una gran cantidad de tiempo. Algunas de estas cargas de trabajo
Version 1.0
97
dependen de las características de hardware nativas, como Exadata, Supercluster y PDW. Las cargas de
trabajo de alto rendimiento a menudo se incluyen en esta categoría. Las opciones de ajuste presentes en
código local tienen que convertirse y comprobarse con las opciones disponibles en la base de datos de
destino.
Los almacenes de datos en esta categoría contienen un gran número de procedimientos almacenados y
funciones definidas por el usuario que organizan la extracción, la transformación y operaciones de carga
(ETL) o crean vistas de las operaciones empresariales. Sus procesos de ETL no se pueden expresar
fácilmente en Amazon Redshift, aunque gran parte de la lógica empresarial podría representarse como
vistas. Estos almacenes de datos también pueden tener muchos miles de tablas con un gran número
de transacciones para administrar el flujo de trabajo de ETL. Cuando la migración con Amazon Redshift
como destino, tales cargas de trabajo requieren rediseñar la aplicación para separar la carga de trabajo
transaccional de los informes. Rediseñar también requiere la extracción de la lógica del almacén de datos y
en otra capa de cómputo.
Estas cargas de trabajo son difíciles de migrar y pueden constituir un riesgo importante para el cliente. Es
posible que la migración de esta carga de trabajo consuma un número importante de horas por persona.
Categoría 4: cargas de trabajo específicas de motor

Las cargas de trabajo de esta categoría utilizan marcos de trabajo que solo pueden funcionar con un
motor de base de datos comercial específico. Por ejemplo, los marcos de aplicaciones específicas de base
de datos incluyen Oracle Forms, Oracle Reports, Oracle ADF and Oracle APEX (Application Express) o
aplicaciones que utilizan .NET ActiveRecord de forma generalizada. Migrar estas cargas de trabajo a una
base de datos NoSQL o de código abierto puede requerir una reimplementación completa de la aplicación
para separar la lógica de presentación de la base de datos.
Un almacén de datos en esta categoría podría confiar en gran medida en características de propietario
como Geospatial a escala de petabytes. Estas características pueden contener lógica de propietario en
estructuras de datos OLAP. Las cargas de trabajo podrían tener requisitos de disponibilidad, replicación o
concurrencia de usuarios que no se pueden cumplir con una arquitectura de zona de disponibilidad única.
Podrían tener requisitos de latencia que hacen imposible el uso de Amazon Athena.
Estas cargas de trabajo son muy difícil de migrar. Es posible que la migración de esta carga de trabajo
necesite un número importante de horas por persona. La realización de esta migración también constituye
un riesgo significativo. La migración de esta carga de trabajo puede que no se admita desde la perspectiva
de certificación o soporte de terceros.
Categoría 5: no portable, riesgo inaceptable o cargas de trabajo

de"migración directa"
Las cargas de trabajo en esta categoría podrían implementarse en motores de base de datos que no
tienen equivalente en la nube. Su sistema operativo subyacente podría no ser compatible con AWS.
Por ejemplo, podría utilizar arquitecturas mainframe, Power o RISC. En algunos casos, la base de datos
podría utilizar extensiones de código nativo como Oracle Call Interface para ejecutar la lógica de negocio.
Esta lógica de negocio suele considerarse "heredada" por el cliente, incluso si aún es importante para la
empresa. En algunos casos, los clientes no tienen el código fuente para estos programas. Las cargas de
trabajo de almacén de datos y OLTP comparten los mismos atributos para esta categoría.
Puede migrar estas aplicaciones a Amazon EC2. Podría tener requisitos de emulación o requerir otras
soluciones de terceros. En algunos casos, el riesgo de mover estas cargas de trabajo desde el entorno
existente podría ser demasiado alto para justificarlo. En ese caso, es conveniente mantener la conectividad
de alto rendimiento a la implementación local con una topología de red que admita los requisitos de la
aplicación.
Version 1.0
98
Convertir los esquemas de base de

datos utilizando el Herramienta de
Puede utilizar la Herramienta de conversión de esquemas de AWS (AWS SCT) para convertir sus
esquemas de base de datos existente de un motor de base de datos a otro. La conversión de una base de
datos con la interfaz de usuario de AWS SCT puede ser bastante sencillo, pero hay varios aspectos que
debe tener en cuenta antes de realizar la conversión.
Por ejemplo, puede utilizar AWS SCT para hacer lo siguiente:
• También puede utilizar la AWS SCT para copiar un esquema de base de datos local existente a
una instancia de base de datos de Amazon RDS que ejecute el mismo motor. Puede utilizar esta
característica para analizar posibles ahorros de costos en la migración a la nube y en el cambio del tipo
de licencia.
• En algunos casos, las características de la base de datos de origen no se pueden convertir a
características de Amazon RDS equivalentes. Si aloja y gestiona una base de datos en la plataforma
de Amazon Elastic Compute Cloud (Amazon EC2), puede simular estas características sustituyendo los
servicios de AWS por ellas.
• AWS SCT automatiza gran parte del proceso de conversión de su esquema de base de datos de
procesamiento de transacciones online (OLTP) a una instancia de base de datos MySQL de Amazon
Relational Database Service (Amazon RDS), un clúster de base de datos de Amazon Aurora o una
instancia de base de datos PostgreSQL. Los motores de base de datos de origen y de destino contienen
diferentes características y capacidades, por lo que la AWS SCT intenta crear un esquema equivalente
en su instancia de base de datos de Amazon RDS siempre que sea posible. Si no es posible la
conversión directa, la AWS SCT proporciona una lista de posibles acciones que puede realizar.
Esta sección se incluyen los siguientes temas:
Temas
• Creación de reglas de mapeo en la Herramienta de conversión de esquemas de AWS (AWS
SCT) (p. 101)
• Conversión de su esquema con la Herramienta de conversión de esquemas de AWS (p. 103)
• Administración de conversiones manuales en la Herramienta de conversión de esquemas de
AWS (p. 107)
• Actualización de un esquema convertido en la Herramienta de conversión de esquemas de
AWS (p. 108)
• Guardado y aplicación de un esquema convertido en la Herramienta de conversión de esquemas de
AWS (p. 109)
• Comparación de esquemas de bases de datos (p. 112)
• Búsqueda de objetos transformados relacionados (p. 113)
AWS SCT es compatible con las siguientes conversiones de OLTP.
Version 1.0
99
Base de datos de origen Base de datos de destino en Amazon RDS
Microsoft SQL Server (versión 2008 y posteriores) Amazon Aurora (MySQL o PostgreSQL), Microsoft
SQL Server, MySQL, PostgreSQL
MySQL (versión 5.5 o posteriores) Amazon Aurora (PostgreSQL), MySQL,

PostgreSQL
Puede migrar esquemas y datos de MySQL a

un clúster de base de datos de Amazon Aurora
(MySQL) sin usar la AWS SCT. Para obtener más
información, consulte Migración de datos a un
clúster de base de datos de Amazon Aurora.
Oracle (versión 10.2 y posteriores) Amazon Aurora (MySQL o PostgreSQL), MySQL,

Oracle, PostgreSQL
PostgreSQL (versión 9.1 y posteriores) Amazon Aurora (MySQL), MySQL, PostgreSQL
DB2 LUW (versiones 9.5, 9.7, 10.5 y 11.1) Amazon Aurora (MySQL o PostgreSQL), MySQL,
PostgreSQL
Si desea convertir un esquema de data warehouse, consulte Conversión de esquemas de almacén de

datos a Amazon Redshift utilizando la Herramienta de conversión de esquemas de AWS (p. 114).
Para convertir su esquema de base de datos a Amazon RDS, siga estos pasos de alto nivel. Cada paso es
un enlace a una sección que proporciona más información.
• Creación de reglas de mapeo en la Herramienta de conversión de esquemas de AWS (p. 117) – Antes
de convertir su esquema con AWS SCT, puede configurar reglas que cambien el tipo de datos de las
columnas, mover objetos de un esquema a otro y cambiar los nombres de los objetos.
• Conversión de su esquema con la Herramienta de conversión de esquemas de AWS (p. 103) – AWS
SCT crea una versión local del esquema convertido para que lo revise, pero no se aplica a su instancia
de base de datos de destino hasta que esté listo.
• Creación de informes de evaluación con Herramienta de conversión de esquemas de AWS (p. 83) –
AWS SCT crea un informe de evaluación de la migración de la base de datos en el que se detallen los
elementos del esquema que no se pueden convertir automáticamente. Puede utilizar este informe para
identificar dónde necesita crear un esquema en su instancia de base de datos de Amazon RDS que sea
compatible con su base de datos de origen.
• Administración de conversiones manuales en la Herramienta de conversión de esquemas de
AWS (p. 107): – si tiene elementos del esquema que no se pueden convertir automáticamente, dispone
de dos opciones: actualizar el esquema de origen y, a continuación, volver a convertirlo, o bien crear
elementos de esquema equivalentes en su instancia de base de datos de Amazon RDS de destino.
• Actualización de un esquema convertido en la Herramienta de conversión de esquemas de
AWS (p. 108): – puede actualizar el proyecto de AWS SCT con el esquema más reciente de su base
de datos de origen.
• Guardado y aplicación de un esquema convertido en la Herramienta de conversión de esquemas de
AWS (p. 109): – cuando esté listo, haga que AWS SCT aplique el esquema convertido en su proyecto
local a su instancia de base de datos de Amazon RDS de destino.
Version 1.0
100
Creación de reglas de mapeo
Creación de reglas de mapeo en la Herramienta de

conversión de esquemas de AWS (AWS SCT)
Antes de convertir su esquema con AWS SCT, puede configurar reglas que cambien el tipo de datos de las
columnas, mover objetos de un esquema a otro y cambiar los nombres de los objetos. Por ejemplo, si tiene
un conjunto de tablas en su esquema de origen denominado test_TABLE_NAME, puede configurar una
regla que cambie el prefijo test_ por el prefijo demo_ en el esquema de destino.
Note
Solo puede crear reglas de mapeo si el motor de la base de datos de origen y el de la de destino
son diferentes.
Puede crear reglas de mapeo que realicen las siguientes tareas:
• Cambiar el tipo de datos

• Mover objetos
• Cambiar el nombre de los objetos
• Prefijos: agregar prefijo, eliminar prefijo, sustituir prefijo
• Sufijo: agregar prefijo, eliminar sufijo, sustituir sufijo
Puede crear reglas de mapeo para los siguientes objetos:
• Base de datos
• Esquema
• Tabla
• Columna

Puede crear reglas de mapeo y guardarlas como parte de su proyecto. Con el proyecto abierto, utilice el
siguiente procedimiento para crear reglas de mapeo.
Para crear reglas de mapeo
1. Seleccione Mapping Rules en el menú Settings. Aparecerá el cuadro de diálogo Mapping Rules.
Version 1.0
101
Creación de reglas de mapeo para objetos
2. Seleccione Add new rule. Se agregará una nueva fila a la lista de reglas.
3. Seleccione el icono de edición para configurar su regla.
a. En Name, escriba un nombre para su regla.

b. En For, seleccione el tipo de objeto al que se aplicará la regla.
c. En where, escriba un filtro que se aplicará a los objetos antes de aplicar la norma de mapeo. La
cláusula where se evalúa mediante una cláusula like. Puede especificar un nombre exacto para
seleccionar un objeto o introducir un patrón para seleccionar varios objetos.
Los campos disponibles para la cláusula where son diferentes en función del tipo de objeto. Por
ejemplo, si el tipo de objeto es esquema, solo habrá un campo disponible, para el nombre del
esquema.
d. En Actions, seleccione el tipo de regla de mapeo que quiera crear.
e. En función del tipo de regla, escriba uno o dos valores adicionales. Por ejemplo, para cambiar
el nombre de un objeto, escriba el nuevo nombre del objeto. Para sustituir un prefijo, escriba el
prefijo anterior y el nuevo prefijo.
4. Tras haber configurado su regla de mapeo, seleccione Save para guardar su regla. También puede
seleccionar Cancel para cancelar los cambios.
5. Cuando haya acabado de agregar, editar y eliminar reglas, seleccione Save All para guardar todos los
cambios.
6. Seleccione Close para cerrar el cuadro de diálogo Mapping Rules.
Puede utilizar el icono de alternar para desactivar una regla de mapeo sin eliminarla. También puede
utilizar el icono de copia para duplicar una regla de mapeo existente. Puede utilizar el icono de eliminar
para borrar una regla de mapeo existente. Para guardar los cambios que realice en sus reglas de mapeo,
seleccione Save All.
Visualización de reglas de mapeo para objetos

Tras configurar las reglas de mapeo, puede ver el efecto de las reglas sobre objetos específicos en su
esquema antes de convertir el esquema. En un árbol de esquema de origen, seleccione el objeto que le
interese. En la vista principal, seleccione la pestaña Mapping. La pestaña Mapping se abrirá y mostrará
una lista de todas las reglas de mapeo que están aplicadas al objeto. Puede ver el nombre del objeto en
Version 1.0
102
Exportación de reglas de mapeo
el esquema de origen y el nuevo nombre del objeto en el esquema de destino. Si tiene reglas de tipos de
datos, también verá el tipo de dato de la columna en el esquema de origen y el nuevo tipo de dato de la
columna en el esquema de destino.

Si utiliza AWS Database Migration Service (AWS DMS) para migrar sus datos de la base de datos de
origen a la de destino, puede proporcionar información sobre sus reglas de mapeo a AWS DMS. Para
obtener más información acerca de las tareas, consulte Trabajar con tareas de replicación de AWS
Database Migration Service.
Para exportar reglas de mapeo
1. En la Herramienta de conversión de esquemas de AWS, en el árbol del esquema de origen, abra el

menú contextual (clic secundario) y seleccione Export script for DMS (Exportar script para DMS). Se
abrirá el cuadro de diálogo de guardado.
2. Seleccione la ubicación en la que desee guardar el script y después seleccione Save. Su reglas de
mapeo se guardan como un script JSON que AWS DMS puede consumir.
Conversión de su esquema con la Herramienta de

Tras haber conectado su proyecto tanto a la base de datos de origen como a la instancia de base de datos
Amazon RDS de destino, su proyecto de Herramienta de conversión de esquemas de AWS mostrará el
esquema de su base de datos de origen en el panel izquierdo. El esquema se presentan en un formato de
vista de árbol y cada nodo del árbol se carga progresivamente. Al seleccionar un nodo en la vista de árbol,
AWS SCT solicita la información del esquema de la base de datos de origen en ese momento.
Puede seleccionar elementos del esquema en su base de datos de origen y, después, convertir el
esquema en un esquema equivalente para el motor de la base de datos de su instancia de base de datos
de destino. Puede seleccionar cualquier elemento del esquema en su base de datos de origen para
convertirlo. Si el elemento del esquema que seleccione depende de un elemento principal, AWS SCT
generará también el esquema para el elemento principal. Por ejemplo, si selecciona una columna de una
tabla para convertirla, AWS SCT generará el esquema para la columna, la tabla en la que está la columna
y la base de datos en la que está la tabla.
Conversión del esquema

Para convertir el esquema de la base de datos de origen, elija el objeto del esquema que desea convertir
en el panel izquierdo del proyecto. Abra el menú contextual (clic secundario) para el objeto y seleccione
Convert schema, como se muestra a continuación.
Version 1.0
103
Una vez que haya convertido el esquema de su base de datos de origen, puede elegir los elementos del
esquema en el panel izquierdo de su proyecto y ver el esquema convertido en los paneles centrales de
su proyecto. El panel inferior central muestra las propiedades y el comando SQL para crear el esquema
convertido, como se muestra a continuación.
Version 1.0
104
Edición del esquema convertido
Tras haber convertido el esquema, podrá guardar el proyecto. La información del esquema de su base de
datos de origen se guarda con su proyecto. Esta funcionalidad supone que puede trabajar sin conexión
sin estar conectado a su base de datos de origen. AWS SCT se conecta a su base de datos de origen
para actualizar el esquema en su proyecto si selecciona Refresh from Database (Actualizar desde base
de datos) para su base de datos de origen. Para obtener más información, consulte Actualización de un
esquema convertido en la Herramienta de conversión de esquemas de AWS (p. 108).
Puede crear un informe de evaluación de la migración de la base de datos para los elementos que no
se puedan convertir automáticamente. El informe de evaluación es útil para identificar y solucionar los
elementos del esquema que no se puedan convertir automáticamente. Para obtener más información,
consulte Creación de informes de evaluación con Herramienta de conversión de esquemas de AWS
(p. 83).
Cuando la AWS SCT genera un esquema convertido, no se aplica inmediatamente a la instancia de base
de datos de destino. El esquema convertido se almacena en el entorno local hasta que esté listo para
aplicarlo en la instancia de base de datos de destino. Para obtener más información, consulte Aplicación
del esquema convertido (p. 110).

Puede editar el esquema convertido y guardar los cambios como parte de su proyecto.
Version 1.0
105
Eliminación de un esquema convertido
Para editar el esquema convertido
1. En el panel izquierdo que indica el esquema de la base de datos de origen, seleccione el elemento del
esquema para el que quiera editar el esquema convertido.
2. En el panel inferior central donde se muestra el esquema convertido para el elemento seleccionado,
haga clic en la pestaña SQL.
3. En el texto mostrado para la pestaña SQL, cambie el esquema según sea necesario. El esquema se
guardará automáticamente con su proyecto cuando lo actualice.
Los cambios que realice al esquema convertido se almacenan con su proyecto a medida que realiza las
actualizaciones. Si convierte un nuevo elemento de un esquema desde su base de datos de origen y ha
realizado actualizaciones al esquema previamente convertido para ese elemento, dichas actualizaciones
existentes se verán sustituidas por el elemento del esquema recientemente convertido, en función de su

Hasta aplicar el esquema a su instancia de base de datos de destino, la AWS SCT solo almacena el
esquema convertido localmente en su proyecto. Puede eliminar el esquema planificado de su proyecto si
selecciona el nodo de vista en árbol para su instancia de base de datos de destino y, a continuación, hace
clic en Refresh from Database. Dado que no se ha escrito ningún esquema en su instancia de base de
datos de destino, la actualización desde la base de datos eliminará los elementos del esquema planificado
en su proyecto de la AWS SCT para adaptarse a lo que exista en su instancia de base de datos de destino.
Version 1.0
106
Administración de conversiones manuales
Administración de conversiones manuales en la

El informe de evaluación incluye una lista de los elementos que no se pueden convertir automáticamente
en el motor de base de datos de su instancia de base de datos de Amazon RDS de destino. Para cada
elemento que no se puede convertir, hay un elemento de acción en la pestaña Action Items.
Puede responder a los elementos de acción del informe de evaluación de las siguientes formas:
• Modificar su esquema de base de datos de origen.

• Modificar su esquema de base de datos de destino.
Modificar su esquema de origen

Para algunos elementos, es posible que resulte más fácil modificar el esquema de base de datos en su
esquema de base de datos de origen que lograr que se convierta automáticamente. En primer lugar,
Version 1.0
107
Modificar su esquema de destino
verifique que los nuevos cambios son compatibles con la arquitectura de su aplicación y, a continuación,
actualice el esquema en la base de datos de origen. Por último, actualice su proyecto con la información
de esquema actualizada. Después, puede convertir el esquema actualizado y generar de nuevo el informe
de evaluación de la migración de la base de datos. Los elementos de acción ya no aparecen para los
elementos que hayan cambiado en el esquema de origen.
La ventaja de este proceso es que el esquema actualizado está siempre disponible al actualizar desde la

Para algunos elementos, puede que sea más sencillo aplicar el esquema convertido a la base de datos
de destino y, a continuación, agregar manualmente los elementos de esquema equivalentes a la base de
datos de destino para los elementos que no se hayan podido convertir automáticamente. Puede escribir
todo el esquema que se pueda convertir automáticamente en su instancia de base de datos de destino
aplicando el esquema. Para obtener más información, consulte Guardado y aplicación de un esquema
convertido en la Herramienta de conversión de esquemas de AWS (p. 109).
El esquema que escrito en la instancia de base de datos de destino no contendrá los elementos que no se
hayan podido convertir automáticamente. Después de aplicar esquemas a la instancia de base de datos de
destino, puede crear manualmente esquemas en dicha instancia que sean equivalentes a los de la base de
datos de origen. Los elementos de acción en el informe de evaluación de la migración de la base de datos
contienen sugerencias sobre cómo crear un esquema equivalente.
Warning
Si crea manualmente esquemas en su instancia de base de datos de destino, guarde una copia
de cualquier operación manual que haya realizado. Si aplica el esquema convertido desde su
proyecto a su instancia de base de datos de destino de nuevo, se sobrescribirá el trabajo manual
que haya realizado.
En algunos casos, no podrá crear un esquema equivalente en la instancia de base de datos de destino.
Tal vez tenga que rediseñar una parte de la aplicación y de la base de datos para usar la funcionalidad
disponible en el motor de base de datos para la instancia de base de datos de destino. En otros casos,
puede omitir simplemente el esquema que no se pueda convertir automáticamente.
Actualización de un esquema convertido en la

Puede actualizar el esquema de origen y el esquema de destino en su proyecto de Herramienta de
conversión de esquemas de AWS.
• Source (Origen): – si actualiza el esquema para su base de datos de origen, AWS SCT sustituye el
esquema de su proyecto con el último esquema de su base de datos de origen. Con esta funcionalidad,
puede actualizar su proyecto si se ha modificado el esquema de la base de datos de origen.
• Target (Destino): – si actualiza el esquema para su instancia de base de datos Amazon RDS de destino,
AWS SCT sustituye el esquema de su proyecto por el último esquema de su instancia de base de datos
de destino. Si no ha aplicado ningún esquema a su instancia de base de datos de destino, AWS SCT
elimina el esquema convertido de su proyecto. A continuación, puede convertir el esquema de la base de
datos de origen a una instancia de base de datos de destino limpia.
El esquema en su proyecto de la AWS SCT se actualiza seleccionando Refresh from Database (Actualizar
desde base de datos), como se muestra a continuación.
Version 1.0
108
Guardado y aplicación de un esquema
Guardado y aplicación de un esquema convertido

en la Herramienta de conversión de esquemas de
AWS
Cuando la Herramienta de conversión de esquemas de AWS genera un esquema convertido (tal y
como se muestra en Conversión de su esquema con la Herramienta de conversión de esquemas de
AWS (p. 103)), no aplica inmediatamente el esquema convertido a la instancia de base de datos de
destino. Los esquemas convertidos se almacenan en el entorno local de su proyecto hasta que esté listo
para aplicarlos en la instancia de base de datos de destino. Con esta funcionalidad, puede trabajar con
los elementos de esquema que no se puedan convertir automáticamente en su motor de base de datos
de destino. Para obtener más información sobre elementos que no se pueden convertir automáticamente,
(p. 83).
Si lo desea, puede hacer que la herramienta guarde su esquema convertido en un archivo como script
SQL antes de aplicar el esquema a su instancia de base de datos de destino. También puede hacer que la
herramienta aplique el esquema convertido directamente a su instancia de base de datos de destino.
Guardar el esquema convertido en un archivo

Puede guardar los esquemas convertidos como scripts SQL en un archivo de texto. Al utilizar este
enfoque, puede modificar los scripts SQL generados en la AWS SCT para abordar los elementos que
Version 1.0
109
Aplicación del esquema convertido
no puedan convertirse automáticamente. A continuación, puede ejecutar sus scripts actualizados en su

instancia de base de datos de destino para aplicar el esquema convertido a la base de datos de destino.
Para guardar el esquema convertido como scripts SQL, abra el menú contextual (clic secundario) para el
elemento del esquema y seleccione Save as SQL, como se muestra a continuación.

Cuando esté listo para aplicar el esquema convertido a la instancia de base de datos de Amazon RDS
de destino, elija el elemento del esquema en el panel derecho del proyecto. Abra el menú contextual (clic
con el botón secundario) del elemento del esquema y seleccione Apply to database, como se muestra a
continuación.
Version 1.0
110
Esquema del paquete de extensión

La primera vez que aplique el esquema convertido a su instancia de base de datos de destino, la AWS
SCT agrega un esquema adicional a su instancia de base de datos de destino. Este esquema implementa
las funciones del esquema de la base de datos que son necesarias a la hora de escribir el esquema
convertido en la instancia de base de datos de destino. El esquema se denomina esquema de paquete de
extensión.
No modifique el esquema del paquete de extensión, ya que podría encontrarse resultados imprevistos
en el esquema convertido creado en la instancia de base de datos de destino. Cuando el esquema haya
migrado totalmente a su instancia de base de datos de destino y ya no necesite la AWS SCT, puede
eliminar el esquema del paquete de extensión.
El esquema de paquete de extensión se denomina en función de su base de datos de origen, de la

siguiente manera:
• Microsoft SQL Server: AWS_SQLSERVER_EXT

• MySQL: AWS_MYSQL_EXT
• Oracle: AWS_ORACLE_EXT
• PostgreSQL: AWS_POSTGRESQL_EXT
Para obtener más información, consulte Uso de las funciones de AWS Lambda del paquete de extensión
AWS SCT (p. 199).
Version 1.0
111
Comparación de esquemas
Comparación de esquemas de bases de datos

Si ha realizado cambios en su esquema de origen o de destino después de la migración, puede comparar
los dos esquemas de base de datos mediante AWS SCT. Puede comparar esquemas de versiones iguales
o anteriores al esquema de origen.
Se admiten las siguientes comparaciones de esquemas:
• De Oracle a Oracle, versiones 12.1.0.2.0, 11.1.0.7.0, 11.2.0.1.0, 10

• De SQL Server a SQL Server, versiones 2016, 2014, 2012, 2008 RD2, 2008
• De PostgreSQL a PostgreSQL y Compatibilidad de Aurora con PostgreSQL, versiones 9.6, 9.5.9, 9.5.4
• De MySQL a MySQL, versiones 5.6.36, 5.7.17, 5.5
La configuración de la comparación de esquemas se especifica en la pestaña Compare Schema de la

página Project Settings.
Para comparar esquemas, el usuario selecciona los esquemas y AWS SCT indica los objetos que difieren
entre los dos esquemas y los que no.
Para comparar dos esquemas
1. Abra un proyecto de AWS SCT existente o cree un proyecto y conéctese a los puntos de enlace de
origen y destino.
2. Elija el esquema que desea comparar.
3. Abra el menú contextual (haga clic con el botón secundario) y elija Compare Schema.
AWS SCT indica los objetos que son diferentes entre los dos esquemas añadiendo un círculo negro al
icono del objeto.
Version 1.0
112
Objetos transformados relacionados
Puede aplicar los resultados de la comparación de esquemas a un único objeto, a una única categoría de
objetos o a todo el esquema. Seleccione la casilla situada junto a la categoría, objeto o esquema al que
desee aplicar los resultados.
Búsqueda de objetos transformados relacionados

Después de la conversión de un esquema, en algunos casos AWS SCT podría haber creado varios objetos
para un objeto de esquema en la base de datos de origen. Por ejemplo, cuando se realiza una conversión
de Oracle a PostgreSQL, AWS SCT toma cada disparador de Oracle y lo transforma en un disparador y
una función disparadora en el destino de PostgreSQL. Además, cuando AWS SCT convierte una función
o procedimiento de un paquete de Oracle en PostgreSQL, crea una función equivalente y una función INIT
que debe ejecutarse como un bloque init para que el procedimiento o la función puedan ejecutarse.
El siguiente procedimiento le permite ver todos los objetos relacionados que se han creado después de
una conversión del esquema.
Para ver los objetos relacionados que se crearon durante una conversión de esquema
1. Tras la conversión del esquema, elija el objeto convertido en la vista de árbol de destino.
2. Elija la pestaña Related Converted Objects.
3. Consulte la lista de objetos de destino relacionados.
Version 1.0
113
Conversión de esquemas de
almacén de datos a Amazon
Redshift utilizando la Herramienta de
La Herramienta de conversión de esquemas de AWS automatiza gran parte del proceso de conversión de
su esquema de data warehouse a un esquema de base de datos de Amazon Redshift. Debido a que los
motores de base de datos de origen y de destino pueden tener diferentes características y capacidades,
AWS SCT intenta crear un esquema equivalente en su base de datos de destino siempre que sea posible.
Si no es posible la conversión directa, AWS SCT proporciona un informe de evaluación con una lista de
posibles acciones que puede realizar. Con AWS SCT, puede administrar claves, mapear tipos de datos y
objetos, y crear conversiones manuales.
AWS SCT puede convertir los siguientes esquemas de almacén de datos a Amazon Redshift.
• Greenplum Database (versión 4.3 y posteriores)

• Microsoft SQL Server (versión 2008 y posteriores)
• Netezza (versión 7.0.3 y posteriores)
• Oracle (versión 10 y posteriores)
• Teradata (versión 13 y posteriores)
• Vertica (versión 7.2.2 y posteriores)
Si desea convertir un esquema de base de datos de procesamiento de transacciones online (OLTP),

consulte Convertir los esquemas de base de datos utilizando el Herramienta de conversión de esquemas
de AWS (p. 99).
Para convertir un esquema de almacenamiento de datos, siga estos pasos.
1. Especifique la estrategia de optimización y las reglas, y especifique el mapeo que desea que utilice
AWS SCT. Puede configurar reglas que cambien el tipo de datos de las columnas, mover objetos de un
esquema a otro y cambiar los nombres de los objetos.
Puede especificar la optimización y el mapeo en Settings (Configuración). Para obtener más información
acerca de estrategias de optimización, consulte Selección de estrategias de optimización y reglas de
uso para la Herramienta de conversión de esquemas de AWS (p. 115). Para obtener más información
sobre el mapeo, consulte Creación de reglas de mapeo en la Herramienta de conversión de esquemas
de AWS (p. 117)
2. Proporcione estadísticas del almacén de datos de origen para que AWS SCT pueda optimizar cómo
se convierte su almacén de datos. Puede recopilar estadísticas directamente desde la base de datos o
cargar un archivo de estadísticas existente. Para obtener más información acerca de cómo proporcionar
estadísticas de almacenamiento de datos, consulte Recopilación o carga de estadísticas para la
Version 1.0
114
Selección de estrategias y reglas de optimización
3. Cree un informe de evaluación de la migración de la base de datos en el que se detallen los elementos
del esquema que no se pueden convertir automáticamente. Puede utilizar este informe para identificar
dónde necesita crear manualmente un esquema en su base de datos de destino que sea compatible
con su base de datos de origen. Para obtener más información sobre el informe de evaluación, consulte
Creación de informes de evaluación con Herramienta de conversión de esquemas de AWS (p. 83).
4. Convertir el esquema: la AWS SCT crea una versión local del esquema convertido para que lo revise,
pero no se aplica a su base de datos de destino hasta que esté listo. Para obtener más información
acerca de la conversión, consulte Conversión de su esquema con la Herramienta de conversión de
5. Tras convertir el esquema, puede administrar y editar sus claves. La administración de claves es
la esencia de la conversión de un data warehouse. Para obtener más información acerca de la
administración de claves derivadas, consulte Administración y personalización de claves en la
6. Si tiene elementos del esquema que no se pueden convertir automáticamente, dispone de dos
opciones: actualizar el esquema de origen y, a continuación, volver a convertirlo, o bien crear elementos
de esquema equivalentes en su base de datos de destino. Para obtener más información acerca
de cómo convertir manualmente elementos de esquema, consulte Administración de conversiones
manuales en la Herramienta de conversión de esquemas de AWS (p. 124). Para obtener más
información acerca de cómo actualizar su esquema de origen, consulte Actualización de un esquema
convertido en la Herramienta de conversión de esquemas de AWS (p. 125).
7. Cuando esté listo, puede aplicar el esquema convertido a la base de datos de destino. Para obtener
más información acerca de cómo guardar y aplicar el esquema convertido, consulte Guardado y
aplicación de un esquema convertido en la Herramienta de conversión de esquemas de AWS (p. 126).
Selección de estrategias de optimización y reglas

de uso para la Herramienta de conversión de
esquemas de AWS
Para optimizar cómo convierte la Herramienta de conversión de esquemas de AWS su esquema de
almacén de datos, puede elegir las estrategias y reglas que desea que utilice la herramienta. Tras convertir
su esquema y revisar las claves propuestas, puede ajustar sus reglas o cambiar su estrategia para obtener
los resultados que quiera.
Para seleccionar sus estrategias y reglas de optimización
1. Seleccione Settings y después Project Settings. Aparecerá el cuadro de diálogo Current project
settings.
2. En el panel izquierdo, seleccione Optimization Strategies. Las estrategias de optimización aparecerán
en el panel derecho, con los valores predeterminados seleccionados.
3. En Strategy Sector, seleccione la estrategia de optimización que quiera emplear. Puede elegir entre
las siguientes opciones:
• Usar metadatos y omitir información estadística: – con esta estrategia, solo se usa la información
de los metadatos para decisiones sobre optimización. Por ejemplo, si hay más de un índice en una
tabla de origen, se utiliza el orden de clasificación de la base de datos de origen y el primer índice
se convierte en una clave de distribución.

• Omitir metadatos y usar información estadística: – con esta estrategia, las decisiones de
optimización se derivan solo de la información estadística. Esta estrategia se aplica únicamente a
las tablas y columnas para las que se proporcionan estadísticas. Para obtener más información,
Version 1.0
115
Recopilación o carga de estadísticas
consulte Recopilación o carga de estadísticas para la Herramienta de conversión de esquemas de

AWS (p. 116).

• Usar metadatos y usar información estadística: – con esta estrategia, tanto los metadatos como las
estadísticas se usan para las decisiones de optimización.

4. Tras seleccionar su estrategia de optimización, podrá determinar qué reglas quiere usar. Puede elegir
entre las siguientes opciones:
• Seleccionar clave de distribución y claves de ordenación con metadatos

• Seleccionar tabla de hechos y una dimensión apropiada para la intercalación
• Analizar la cardinalidad de las columnas de índices
• Determinar las tablas y columnas más utilizadas desde la tabla QueryLog
Para cada regla, puede introducir un peso para la clave de ordenación y un peso para la clave de
distribución. AWS SCT utiliza los pesos que elija cuando convierte su esquema. Después, cuando
analice las claves sugeridas, si no está satisfecho con los resultados, puede volver aquí y cambiar la
configuración. Para obtener más información, consulte Administración y personalización de claves en
la Herramienta de conversión de esquemas de AWS (p. 123).
Recopilación o carga de estadísticas para la

Para optimizar cómo convierte la Herramienta de conversión de esquemas de AWS su esquema de
almacén de datos puede proporcionar estadísticas desde su base de datos de origen que la herramienta
podrá utilizar. Puede recopilar estadísticas directamente desde la base de datos o cargar un archivo de
estadísticas existente.
Para facilitar y revisar las estadísticas
1. Abra su proyecto y conéctese a la base de datos de origen.

2. Seleccione un objeto de esquema desde el panel izquierdo de su proyecto y abra el menú contextual
(clic secundario) para el objeto. Seleccione Collect Statistics o Upload Statistics como se muestra a
continuación.
3. Seleccione un objeto de esquema del panel izquierdo de su proyecto y, a continuación, haga clic en la
pestaña Statistics. Puede revisar las estadísticas para el objeto.
Version 1.0
116
Después, cuando analice las claves sugeridas, si no está satisfecho con los resultados, puede
recopilar estadísticas adicionales y repetir el procedimiento. Para obtener más información, consulte
Administración y personalización de claves en la Herramienta de conversión de esquemas de
AWS (p. 123).
Creación de reglas de mapeo en la Herramienta de

Antes de convertir su esquema con la Herramienta de conversión de esquemas de AWS, puede configurar
reglas que cambien el tipo de datos de las columnas, mover objetos de un esquema a otro y cambiar los
nombres de los objetos. Por ejemplo, si tiene un conjunto de tablas en su esquema de origen denominado
test_TABLE_NAME, puede configurar una regla que cambie el prefijo test_ por el prefijo demo_ en el
esquema de destino.
Note
Solo puede crear reglas de mapeo si el motor de la base de datos de origen y el de la de destino
son diferentes.
Version 1.0
117
Puede crear reglas de mapeo que realicen las siguientes tareas:
• Cambiar el tipo de datos

• Mover objetos
• Cambiar el nombre de los objetos
• Prefijos: agregar prefijo, eliminar prefijo, sustituir prefijo
• Sufijo: agregar prefijo, eliminar sufijo, sustituir sufijo
Puede crear reglas de mapeo para los siguientes objetos:
• Base de datos
• Esquema
• Tabla
• Columna

Puede crear reglas de mapeo y guardarlas como parte de su proyecto. Con el proyecto abierto, utilice el
siguiente procedimiento para crear reglas de mapeo.
Para crear reglas de mapeo
1. Seleccione Mapping Rules en el menú Settings. Aparecerá el cuadro de diálogo Mapping Rules. El
panel superior contiene reglas de mapeo (transformación).
2. En el panel Transformation Rules, seleccione Add new rule.

3. Configurar la regla de transformación.
a. En Name, escriba un nombre para su regla.

b. En For, seleccione el tipo de objeto al que se aplicará la regla.
c. En where, escriba un filtro que se aplicará a los objetos antes de aplicar la norma de mapeo. La
cláusula where se evalúa mediante una cláusula like. Puede especificar un nombre exacto para
seleccionar un objeto o introducir un patrón para seleccionar varios objetos.
Version 1.0
118
Los campos disponibles para la cláusula where son diferentes en función del tipo de objeto. Por
ejemplo, si el tipo de objeto es esquema, solo habrá un campo disponible, para el nombre del
esquema.
d. En Actions, seleccione el tipo de regla de mapeo que quiera crear.
e. En función del tipo de regla, escriba uno o dos valores adicionales. Por ejemplo, para cambiar
el nombre de un objeto, escriba el nuevo nombre del objeto. Para sustituir un prefijo, escriba el
prefijo anterior y el nuevo prefijo.
4. Tras haber configurado su regla de mapeo, seleccione Save para guardar su regla. También puede
seleccionar Cancel para cancelar los cambios.
5. Cuando haya acabado de agregar, editar y eliminar reglas, seleccione Save All para guardar todos los
cambios.
6. Seleccione Close para cerrar el cuadro de diálogo Mapping Rules.
Puede utilizar el icono de alternar para desactivar una regla de mapeo sin eliminarla. También puede
utilizar el icono de copia para duplicar una regla de mapeo existente. Puede utilizar el icono de eliminar
para borrar una regla de mapeo existente. Para guardar los cambios que realice en sus reglas de mapeo,
seleccione Save All.

Tras configurar las reglas de mapeo, puede ver el efecto de las reglas sobre objetos específicos en su
esquema antes de convertir el esquema. En un árbol de esquema de origen, seleccione el objeto que le
interese. En la vista principal, seleccione la pestaña Mapping. La pestaña Mapping se abrirá y mostrará
una lista de todas las reglas de mapeo que están aplicadas al objeto. Puede ver el nombre del objeto en
el esquema de origen y el nuevo nombre del objeto en el esquema de destino. Si tiene reglas de tipos de
datos, también verá el tipo de dato de la columna en el esquema de origen y el nuevo tipo de dato de la
columna en el esquema de destino.

Si utiliza AWS Database Migration Service (AWS DMS) para migrar sus datos de la base de datos de
origen a la de destino, puede proporcionar información sobre sus reglas de mapeo a AWS DMS. Para
obtener más información acerca de las tareas, consulte Trabajar con tareas de replicación de AWS
Database Migration Service.
Para exportar reglas de mapeo
1. En la Herramienta de conversión de esquemas de AWS, en el árbol del esquema de origen, abra el

menú contextual (clic secundario) y seleccione Export script for DMS (Exportar script para DMS). Se
abrirá el cuadro de diálogo de guardado.
2. Seleccione la ubicación en la que desee guardar el script y después seleccione Save. Su reglas de
mapeo se guardan como un script JSON que AWS DMS puede consumir.
Conversión de su esquema con la Herramienta de

Tras haber conectado su proyecto tanto a la base de datos de origen como a la base de datos de destino,
su proyecto de Herramienta de conversión de esquemas de AWS mostrará el esquema de su base de
Version 1.0
119
datos de origen en el panel izquierdo. El esquema se presentan en un formato de vista de árbol y cada
nodo del árbol se carga progresivamente. Al seleccionar un nodo en la vista de árbol, AWS SCT solicita la
información del esquema de la base de datos de origen en ese momento.
Puede seleccionar elementos del esquema en su base de datos de origen y, después, convertir el
esquema en un esquema equivalente para el motor de la base de datos de su base de datos de destino.
Puede seleccionar cualquier elemento del esquema en su base de datos de origen para convertirlo. Si el
elemento del esquema que seleccione depende de un elemento principal, AWS SCT generará también el
esquema para el elemento principal. Por ejemplo, si selecciona una columna de una tabla para convertirla,
AWS SCT generará el esquema para la columna, la tabla en la que está la columna y la base de datos en
la que está la tabla.

Para convertir el esquema de la base de datos de origen, elija el objeto del esquema que desea convertir
en el panel izquierdo del proyecto. Abra el menú contextual (clic secundario) para el objeto y seleccione
Convert schema, como se muestra a continuación.
Una vez que haya convertido el esquema de su base de datos de origen, puede elegir los elementos del
esquema en el panel izquierdo de su proyecto y ver el esquema convertido en los paneles centrales de
su proyecto. El panel inferior central muestra las propiedades y el comando SQL para crear el esquema
convertido, como se muestra a continuación.
Version 1.0
120
Tras haber convertido el esquema, podrá guardar el proyecto. La información del esquema de su base de
datos de origen se guarda con su proyecto. Esta funcionalidad supone que puede trabajar sin conexión
sin estar conectado a su base de datos de origen. AWS SCT se conecta a su base de datos de origen
para actualizar el esquema en su proyecto si selecciona Refresh from Database (Actualizar desde base
de datos) para su base de datos de origen. Para obtener más información, consulte Actualización de un
esquema convertido en la Herramienta de conversión de esquemas de AWS (p. 125).
Puede crear un informe de evaluación de la migración de la base de datos para los elementos que no
se puedan convertir automáticamente. El informe de evaluación es útil para identificar y solucionar los
elementos del esquema que no se puedan convertir automáticamente. Para obtener más información,
(p. 83).
Cuando la AWS SCT genera un esquema convertido, no se aplica inmediatamente a la base de datos
de destino. El esquema convertido se almacena en el entorno local hasta que esté listo para aplicarlo
en la base de datos de destino. Para obtener más información, consulte Aplicación del esquema
convertido (p. 127).

Puede editar el esquema convertido y guardar los cambios como parte de su proyecto.
Version 1.0
121
Para editar el esquema convertido
1. En el panel izquierdo que indica el esquema de la base de datos de origen, seleccione el elemento del
esquema para el que quiera editar el esquema convertido.
2. En el panel inferior central donde se muestra el esquema convertido para el elemento seleccionado,
haga clic en la pestaña SQL.
3. En el texto mostrado para la pestaña SQL, cambie el esquema según sea necesario. El esquema se
guardará automáticamente con su proyecto cuando lo actualice.
Los cambios que realice al esquema convertido se almacenan con su proyecto a medida que realiza las
actualizaciones. Si convierte un nuevo elemento de un esquema desde su base de datos de origen y ha
realizado actualizaciones al esquema previamente convertido para ese elemento, dichas actualizaciones
existentes se verán sustituidas por el elemento del esquema recientemente convertido, en función de su

Hasta aplicar el esquema a su base de datos de destino, la AWS SCT solo almacena el esquema
convertido localmente en su proyecto. Puede eliminar el esquema planificado de su proyecto si selecciona
el nodo de vista en árbol para su base de datos de destino y, a continuación, hace clic en Refresh from
Database. Dado que no se ha escrito ningún esquema en su base de datos de destino, la actualización
desde la base de datos eliminará los elementos del esquema planificado en su proyecto de la AWS SCT
para adaptarse a lo que exista en su base de datos de destino.
Version 1.0
122
Administración y personalización de claves
Administración y personalización de claves en la

Tras convertir el esquema con la Herramienta de conversión de esquemas de AWS, puede administrar y
editar sus claves. La administración de claves es la esencia de la conversión de un data warehouse.
Para administrar claves, seleccione una tabla en su base de datos de destino y a continuación seleccione
la pestaña Key Management, como se muestra a continuación.
Version 1.0
123
Administración de conversiones manuales
El panel izquierdo contiene sugerencias claves, e incluye la puntuación de fiabilidad para cada sugerencia.
Puede seleccionar una de las sugerencias, o personalizar la clave editándola en el panel derecho.
Si las opciones de la clave no tienen el aspecto esperado, puede editar sus estrategias de optimización
y volver a intentar la conversión. Para obtener más información, consulte Selección de estrategias de
optimización y reglas de uso para la Herramienta de conversión de esquemas de AWS (p. 115).
Administración de conversiones manuales en la

El informe de evaluación incluye una lista de los elementos que no se pueden convertir automáticamente
en el motor de base de datos de su base de datos de destino. Para cada elemento que no se puede
convertir, hay un elemento de acción en la pestaña Action Items.
Puede responder a los elementos de acción del informe de evaluación de las siguientes formas:
• Modificar su esquema de base de datos de origen.

• Modificar su esquema de base de datos de destino.
Modificar su esquema de origen

Para algunos elementos, es posible que resulte más fácil modificar el esquema de base de datos en su
esquema de base de datos de origen que lograr que se convierta automáticamente. En primer lugar,
verifique que los nuevos cambios son compatibles con la arquitectura de su aplicación y, a continuación,
actualice el esquema en la base de datos de origen. Por último, actualice su proyecto con la información
Version 1.0
124
de esquema actualizada. Después, puede convertir el esquema actualizado y generar de nuevo el informe
de evaluación de la migración de la base de datos. Los elementos de acción ya no aparecen para los
elementos que hayan cambiado en el esquema de origen.
La ventaja de este proceso es que el esquema actualizado está siempre disponible al actualizar desde la

Para algunos elementos, puede que sea más sencillo aplicar el esquema convertido a la base de datos
de destino y, a continuación, agregar manualmente los elementos de esquema equivalentes a la base de
datos de destino para los elementos que no se hayan podido convertir automáticamente. Puede escribir
todo el esquema que se pueda convertir automáticamente en su base de datos de destino aplicando el
esquema. Para obtener más información, consulte Guardado y aplicación de un esquema convertido en la
El esquema que escrito en la base de datos de destino no contendrá los elementos que no se hayan
podido convertir automáticamente. Después de aplicar el esquema a la base de datos de destino, puede
crear manualmente esquemas en dicha base de datos que sean equivalentes a los de la base de datos de
origen. Los elementos de acción en el informe de evaluación de la migración de la base de datos contienen
sugerencias sobre cómo crear un esquema equivalente.
Warning
Si crea manualmente esquemas en su base de datos de destino, guarde una copia de cualquier
operación manual que haya realizado. Si aplica el esquema convertido desde su proyecto a su
base de datos de destino de nuevo, se sobrescribirá el trabajo manual que haya realizado.
En algunos casos, no podrá crear un esquema equivalente en la base de datos de destino. Tal vez tenga
que rediseñar una parte de la aplicación y de la base de datos para usar la funcionalidad disponible en el
motor de base de datos para la base de datos de destino. En otros casos, puede omitir simplemente el
esquema que no se pueda convertir automáticamente.
Actualización de un esquema convertido en la

Puede actualizar el esquema de origen y el esquema de destino en su proyecto de Herramienta de
• Source (Origen): – si actualiza el esquema para su base de datos de origen, AWS SCT sustituye el
esquema de su proyecto con el último esquema de su base de datos de origen. Con esta funcionalidad,
puede actualizar su proyecto si se ha modificado el esquema de la base de datos de origen.

• Target (Destino): – si actualiza el esquema para su base de datos de destino, AWS SCT sustituye el
esquema de su proyecto con el último esquema de su base de datos de destino. Si no ha aplicado
ningún esquema a su base de datos de destino, AWS SCT elimina el esquema convertido de su
proyecto. A continuación, puede convertir el esquema de la base de datos de origen a una base de
datos de destino limpia.
El esquema en su proyecto de la AWS SCT se actualiza seleccionando Refresh from Database (Actualizar
desde base de datos), como se muestra a continuación.
Version 1.0
125
Guardado y aplicación de un esquema
Guardado y aplicación de un esquema convertido

en la Herramienta de conversión de esquemas de
AWS
Cuando la Herramienta de conversión de esquemas de AWS genera un esquema convertido (tal y
como se muestra en Conversión de su esquema con la Herramienta de conversión de esquemas de
AWS (p. 119)), no aplica inmediatamente el esquema convertido a la base de datos de destino. Los
esquemas convertidos se almacenan en el entorno local de su proyecto hasta que esté listo para aplicarlos
en la base de datos de destino. Con esta funcionalidad, puede trabajar con los elementos de esquema
que no se puedan convertir automáticamente en su motor de base de datos de destino. Para obtener más
información sobre elementos que no se pueden convertir automáticamente, consulte Creación de informes
de evaluación con Herramienta de conversión de esquemas de AWS (p. 83).
Si lo desea, puede hacer que la herramienta guarde su esquema convertido en un archivo como script
SQL antes de aplicar el esquema a su base de datos de destino. También puede hacer que la herramienta
aplique el esquema convertido directamente a su base de datos de destino.
Guardar el esquema convertido en un archivo

Puede guardar los esquemas convertidos como scripts SQL en un archivo de texto. Al utilizar este
enfoque, puede modificar los scripts SQL generados en la AWS SCT para abordar los elementos que no
puedan convertirse automáticamente. A continuación, puede ejecutar sus scripts actualizados en su base
de datos de destino para aplicar el esquema convertido a la base de datos de destino.
Version 1.0
126
Para guardar el esquema convertido como scripts SQL, abra el menú contextual (clic secundario) para el
elemento del esquema y seleccione Save as SQL, como se muestra a continuación.

Cuando esté listo para aplicar el esquema convertido a la base de datos de destino, elija el elemento del
esquema en el panel derecho del proyecto. Abra el menú contextual (clic con el botón secundario) del
elemento del esquema y seleccione Apply to database, como se muestra a continuación.
Version 1.0
127

La primera vez que aplique el esquema convertido a su instancia de base de datos de destino, la AWS
SCT agrega un esquema adicional a su instancia de base de datos de destino. Este esquema implementa
las funciones del esquema de la base de datos que son necesarias a la hora de escribir el esquema
convertido en la instancia de base de datos de destino. El esquema se denomina esquema de paquete de
extensión.
No modifique el esquema del paquete de extensión, ya que podría encontrarse resultados imprevistos
en el esquema convertido creado en la instancia de base de datos de destino. Cuando el esquema haya
migrado totalmente a su instancia de base de datos de destino y ya no necesite la AWS SCT, puede
eliminar el esquema del paquete de extensión.
El esquema de paquete de extensión se denomina en función de su base de datos de origen, de la

siguiente manera:
• Greenplum: AWS_GREENPLUM_EXT
• Netezza: AWS_NETEZZA_EXT
• Teradata: AWS_TERADATA_EXT
• Vertica: AWS_VERTICA_EXT
Version 1.0
128
Bibliotecas Python
Para obtener más información, consulte Uso del paquete de extensión de la Herramienta de conversión de
Bibliotecas Python
Para crear funciones personalizadas en Amazon Redshift, utilice el lenguaje Python. Utilice el paquete
de extensión de la AWS SCT para instalar bibliotecas python para su base de datos de Amazon Redshift.
Para obtener más información, consulte Uso del paquete de extensión de la Herramienta de conversión de
Optimización de Amazon Redshift mediante la

Puede utilizar la Herramienta de conversión de esquemas de AWS para optimizar su base de datos de
Amazon Redshift. La Amazon Redshift recomienda claves de ordenación y distribución para optimizar su
base de datos, utilizando su base de datos de Amazon Redshift como origen y una base de datos de AWS
SCT de prueba como destino.
Optimización de su base de datos de Amazon Redshift

Utilice el siguiente procedimiento para optimizar su base de datos de Amazon Redshift.
Para optimizar su base de datos de Amazon Redshift
1. Tome una instantánea manual de su clúster de Amazon Redshift como copia de seguridad. Puede
eliminar la instantánea después de que haya terminado la optimización de su clúster de Amazon
Redshift y probar los cambios efectuados. Para obtener más información, consulte Amazon Redshift
Snapshots.
2. Seleccione un objeto de esquema para convertir en el panel izquierdo del proyecto. Abra el menú
contextual (clic secundario) para el objeto y seleccione Collect Statistics.
AWS SCT utiliza las estadísticas para realizar sugerencias para las claves de ordenación y
distribución.
3. Seleccione un objeto de esquema para optimizar en el panel izquierdo del proyecto. Abra el menú
contextual (clic secundario) para el objeto y seleccione Run Optimization.
AWS SCT realiza sugerencias para las claves de ordenación y distribución.

4. Para revisar las sugerencias, expanda el nodo de tablas de su esquema en el panel izquierdo de su
proyecto y, a continuación, elija una tabla. Seleccione la pestaña Key Management como se muestra a
continuación.
Version 1.0
129
Optimización de su base de datos de Amazon Redshift
El panel izquierdo contiene sugerencias claves, e incluye la puntuación de fiabilidad para cada
sugerencia. Puede seleccionar una de las sugerencias, o personalizar la clave editándola en el panel
derecho.
5. Puede crear un informe que contenga las sugerencias de optimización. Para crear el informe, haga lo
siguiente:
a. Seleccione un objeto de esquema que haya optimizado en el panel izquierdo del proyecto. Abra el
menú contextual (clic secundario) para el objeto y seleccione Create Report.
El informe se abrirá en la ventana principal y aparecerá la pestaña Summary. El número de

objetos con sugerencias de optimización aparecerá en el informe.
b. Seleccione la pestaña Action Items para ver las principales sugerencias en un formato de informe.
c. Puede guardar una copia local del informe de optimización en formato PDF o como un archivo
de valores separados por comas (CSV). El archivo CSV contiene solamente información de
elementos de acción. El archivo PDF contiene tanto el resumen como información de elementos
de acción.
6. Para aplicar las optimizaciones sugeridas en la base de datos, seleccione un objeto en el panel
derecho de su proyecto. Abra el menú contextual (clic con el botón secundario) del objeto y seleccione
Apply to database.
Version 1.0
130
Conversión de procesos ETL a AWS

Glue
Además de migrar su esquema y sus datos con AWS SCT, también puede migrar procesos de extracción,
transformación y carga (ETL). Esto incluye la conversión de la lógica de negocio relacionada con ETL que
se encuentra en los almacenes de datos de origen o en scripts externos que se ejecutan por separado.
Después de la migración, los procesos de ETL se ejecutan en AWS Glue. Debe ejecutar la migración de
ETL en AWS Glue como un proyecto independiente de la conversión de las declaraciones de su lenguaje
de definición de datos (DDL) y de sus datos.
Version 1.0
131
En la actualidad, solo se admiten las conversiones de Oracle ETL y Teradata BTEQ a AWS Glue.
Temas
• Requisitos previos (p. 133)
• Descripción de AWS Glue Data Catalog (p. 133)
• Limitaciones para la conversión con AWS Glue (p. 133)
• Conversión con AWS Glue en la interfaz de usuario de AWS SCT (p. 134)
• Conversión con la API de Python para AWS Glue (p. 139)
Version 1.0
132
Requisitos previos
Requisitos previos
Antes de comenzar, haga lo siguiente:
• Migre las bases de datos de origen que desee migrar a AWS.

• Migre los almacenes de datos de destino a AWS.
• Recopile una lista de todo el código involucrado en su proceso de ETL.
• Recopile una lista de toda la información de conexión necesaria para cada base de datos.
Descripción de AWS Glue Data Catalog

Como parte del proceso de conversión, AWS Glue carga la información sobre las bases de datos de origen
y destino. Además, organiza esta información en categorías, en una estructura que se denomina árbol. La
estructura incluye lo siguiente:
• Conexiones: parámetros de conexión

• Rastreadores: una lista de rastreadores; un rastreador para cada esquema
• Bases de datos: contenedores que incluyen tablas
• Tablas: definiciones de metadatos que representan los datos en las tablas
• Trabajos de ETL: lógica de negocio que realiza el trabajo de ETL
• Disparadores: lógica que controla cuándo se ejecuta un trabajo de ETL en AWS Glue (ya sea bajo
demanda, según el programa o activadas por eventos de trabajo)
El AWS Glue Data Catalog es un índice para las métricas de tiempo de ejecución, esquema y ubicación
de sus datos. Al trabajar con AWS Glue y AWS SCT, AWS Glue Data Catalog incluye referencias a datos
que se utilizan como orígenes y destinos de sus trabajos de ETL en AWS Glue. Para crear su almacén de
datos, debe catalogar estos datos.
Puede usar la información del Data Catalog para crear y monitorizar sus trabajos de ETL. Normalmente,
deberá ejecutar un rastreador para realizar un inventario de los datos incluidos en sus almacenes de datos,
pero existen otras formas de añadir tablas de metadatos en su Data Catalog.
Al definir una tabla en su Data Catalog, puede añadirla a una base de datos. Las bases de datos en AWS
Glue se usan para organizar las tablas.
Limitaciones para la conversión con AWS Glue

Al convertir mediante AWS SCT con AWS Glue se aplican las siguientes limitaciones:
Recurso Límite predeterminado
Número de bases de datos para cada cuenta 10 000
Número de tablas para cada base de datos 100 000
Número de particiones para cada tabla 1 000 000
Número de versiones de tabla para cada tabla 100 000
Version 1.0
133
Conversión con AWS Glue en la
interfaz de usuario de AWS SCT
Número de tablas para cada cuenta 1 000 000
Número de particiones para cada cuenta 10 000 000
Número de versiones de tabla para cada cuenta 1 000 000
Número de conexiones para cada cuenta 1000
Número de rastreadores para cada cuenta 25
Número de trabajos para cada cuenta 25
Número de disparadores para cada cuenta 25
Número de ejecuciones de trabajo simultáneas 30

para cada cuenta
Número de ejecuciones de trabajo simultáneas 3

para cada trabajo
Número de trabajos para cada disparador 10
Número de puntos de enlace de desarrollo para 5

cada cuenta
DPU máximos utilizados por un punto de enlace de 5

desarrollo a la vez
Máximo de unidades de procesamiento de datos 100

(DPU) utilizados por un rol a la vez
Longitud del nombre de la base de datos Sin límite
Para que sea compatible con otros almacenes

de metadatos, como Apache Hive, el nombre se
incorpora en minúsculas.
Note
Si tiene previsto acceder a la base de

datos desde Athena, proporcione un
nombre con solo caracteres alfanuméricos
y guiones bajos.
Longitud del nombre de la conexión Sin límite
Longitud del nombre del rastreador Sin límite
Conversión con AWS Glue en la interfaz de usuario

de AWS SCT
En las siguientes secciones encontrará una descripción del proceso a seguir para convertir ETL utilizando
AWS Glue con AWS SCT. En este ejemplo vamos a convertir una base de datos Oracle a Amazon
Redshift, junto con los procesos ETL utilizados con las bases de datos de origen y los almacenes de datos.
Temas
• Paso 1: Crear un proyecto nuevo (p. 135)
Version 1.0
134
Paso 1: Crear un proyecto nuevo
• Paso 2: Crear un trabajo de AWS Glue (p. 138)

En primer lugar, inicie un nuevo proyecto. Para ello, inicie AWS SCT y elija File (Archivo), New Project
(Nuevo proyecto). Indique un nombre y una ubicación para guardar su nuevo proyecto.
Elija Data warehouse (OLAP) (Almacén de datos, OLAP) y, a continuación, los motores de base de datos
de origen y de destino.
Compruebe que ha activado Use AWS Glue (Usar AWS Glue) en la configuración del proyecto. Para ver la
configuración del proyecto, elija Settings (Configuración) y, a continuación, Project Settings (Configuración
de proyecto).
Version 1.0
135
Para finalizar la preparación de la importación de su ETL, establezca conexiones con sus motores de base
de datos de origen y de destino. Elija los elementos del menú que comienzan con las palabras Connect to
(Conectar con). Estas etiquetas se personalizan en función de los motores de base de datos que eligió al
crear el proyecto. Por ejemplo, si eligió Oracle y Amazon Redshift, el menú mostrará las opciones Connect
to Oracle (Conectar con Oracle) y Connect to Amazon Redshift (Conectar con Amazon Redshift).
Después de elegir la opción de conectarse a su base de datos de origen, escriba la información de

conexión. Sabrá que la conexión ha finalizado cuando SCT muestre una lista con sus objetos de base de
datos.
Después de elegir la opción de conectarse a su base de datos de destino, escriba la información de

conexión. A continuación, elija la pestaña AWS Glue que aparece. Para Copy from AWS profile (Copiar
desde el perfil de AWS), elija el perfil que desea utilizar. El perfil debería rellenar automáticamente la clave
de acceso de AWS, la clave secreta y la carpeta de bucket de Amazon S3. Si no lo hace, indique dicha
información. Después de seleccionar OK (Aceptar), AWS Glue analiza los objetos y carga los metadatos
en el AWS Glue Data Catalog. En la siguiente captura de pantalla se muestra un ejemplo de dicha pantalla.
En el ejemplo, se utiliza Amazon Redshift como nuestra base de datos de destino.
Version 1.0
136
Note
Según la configuración de seguridad, es posible que aparezca un mensaje de advertencia que

indique que su cuenta no tiene privilegios suficientes para algunos de los esquemas del servidor.
Si tiene acceso a los esquemas que está utilizando, puede ignorar este mensaje.
AWS Glue crea una base de datos en el servidor de base de datos de origen y también en el servidor de
base de datos de destino para ayudar en la conversión de ETL. La base de datos en el servidor de destino
contiene el AWS Glue Data Catalog. Para localizar objetos específicos, utilice el botón de búsqueda en los
paneles de origen o destino.
Para ver cómo se convierte un objeto específico, busque un elemento que desee convertir y seleccione
Convert schema (Convertir esquema) desde el menú contextual ( botón derecho del ratón). AWS SCT lo
transformará en un script.
Version 1.0
137
Paso 2: Crear un trabajo de AWS Glue
Cuando se completa la transformación, el script se almacena en el servidor de destino en la carpeta Scripts

del AWS Glue Data Catalog. Puede verlo en el panel de base de datos de origen en la parte derecha de la
pantalla. Para cargar el script a S3, selecciónelo y, a continuación, elija Save to S3 (Guardar en S3) en el
menú contextual (haga clic con el botón derecho del ratón).
Paso 2: Crear un trabajo de AWS Glue

Después de guardar el script en S3, puede seleccionarlo y elegir Configure AWS Glue Job (Configurar
trabajo de AWS Glue) para abrir el asistente para configurar el trabajo de AWS Glue. El asistente facilita
esta configuración.
La primera pestaña, Design Data Flow (Diseñar flujo de datos), le permite elegir una estrategia de
ejecución y la lista de scripts que desea incluir en este trabajo. Puede elegir los parámetros de cada script.
También puede reorganizar los scripts de manera que se ejecuten en el orden correcto.
En el segundo paso, o pestaña, del asistente, puede asignar un nombre al trabajo y configurar
directamente las opciones para AWS Glue. En esta pantalla puede configurar las siguientes opciones:
• Rol de IAM
• Nombres de archivos de script y rutas de archivo
• Cifrar el script mediante el cifrado en el servidor con claves administradas por Amazon S3 (SSE-S3)
• Directorio temporal
• Ruta de la biblioteca Python generada
• Ruta de la biblioteca Python del usuario
• Ruta de los archivos .jar dependientes (ruta para los archivos .jar dependientes)
• Ruta de los archivos a los que se hace referencia
• DPU simultáneas para cada trabajo ejecutado
• Simultaneidad máxima
• Tiempo de espera del trabajo (en minutos)
• Umbral de notificación de retraso (en minutos)
• Número de reintentos
• Configuración de seguridad
• Cifrado en el servidor
En el tercer paso, o pestaña, elija la conexión configurada con el punto de enlace de destino.
Version 1.0
138
Conversión con la API de Python para AWS Glue
Tras finalizar la configuración del trabajo, este se muestra en los trabajos de ETL en el AWS Glue Data
Catalog. Si elige el trabajo, se mostrará la configuración para que pueda revisarla o editarla. Para crear
un nuevo trabajo en AWS Glue, elija Create AWS Glue Job (Crear trabajo de AWS Glue) en el menú
contextual (botón derecho del ratón) del trabajo. Al hacerlo se aplica la definición de esquema. Para
actualizar la visualización, elija Refresh from database (Actualizar desde la base de datos) en el menú
contextual (botón derecho del ratón).
En este momento, podrá ver su trabajo en la consola de AWS Glue. Para ello, inicie sesión en la Consola
de administración de AWS y abra la consola de AWS Glue en https://console.aws.amazon.com/glue/.
Puede probar el nuevo trabajo para asegurarse de que funciona correctamente. Compruebe los datos de la
tabla de origen y, a continuación, verifique que la tabla de destino esté vacía. Ejecute el trabajo y vuelva a
realizar la comprobación. Puede ver los registros de errores desde la consola de AWS Glue.
Conversión con la API de Python para AWS Glue

En las secciones siguientes se describe una conversión que llama a las operaciones de la API de AWS
Glue en Python. Para obtener más información, consulte Program AWS Glue ETL Scripts in Python
(Programar scripts de ETL de en Python) en la Guía para desarrolladores de AWS Glue.
Paso 1: Crear una base de datos

El primer paso consiste en crear una base de datos nueva en un AWS Glue Data Catalog utilizando la
API del SDK de AWS. Al definir una tabla en el Data Catalog, la añade a una base de datos. Las bases de
datos se usan para organizar tablas en AWS Glue.
En el ejemplo siguiente se muestra el método create_database de la API de Python para AWS Glue.
response = client.create_database(
DatabaseInput={
'Name': 'database_name’,
'Description': 'description',
'LocationUri': 'string',
'Parameters': {
'parameter-name': 'parameter value'
}
}
)
Si utiliza Amazon Redshift, el nombre de la base de datos se forma tal y como se indica a continuación.
{redshift_cluster_name}_{redshift_database_name}_{redshift_schema_name}
El nombre completo del clúster de Amazon Redshift de este ejemplo es el siguiente:
rsdbb03.apq1mpqso.us-west-2.redshift.amazonaws.com
A continuación, se muestra un ejemplo de un nombre correcto de la base de datos. En este caso rsdbb03
es el nombre, que es la primera parte del nombre completo del punto de enlace del clúster. La base de
datos se denomina dev y el esquema es ora_glue.
rsdbb03_dev_ora_glue
Paso 2: Crear una conexión

Cree una nueva conexión en un Data Catalog utilizando la API del SDK de AWS.
Version 1.0
139
Paso 3: Crear un rastreador de AWS Glue
En el ejemplo siguiente se muestra el uso del método create_connection de la API de Python para
AWS Glue.
response = client.create_connection(
ConnectionInput={
'Name': 'Redshift_abcde03.aabbcc112233.us-west-2.redshift.amazonaws.com_dev',
'Description': 'Created from SCT',
'ConnectionType': 'JDBC',
'ConnectionProperties': {
'JDBC_CONNECTION_URL': 'jdbc:redshift://aabbcc03.aabbcc112233.us-
west-2.redshift.amazonaws.com:5439/dev',
'USERNAME': 'user_name',
'PASSWORD': 'password'
},
'PhysicalConnectionRequirements': {
'AvailabilityZone': 'us-west-2c',
'SubnetId': 'subnet-a1b23c45',
'SecurityGroupIdList': [
'sg-000a2b3c', 'sg-1a230b4c', 'sg-aba12c3d', 'sg-1abb2345'
]
}
}
)
Los parámetros que se usan en create_connection son los siguientes:
• Name (cadena UTF-8) obligatorio. En Amazon Redshift, el nombre de la conexión se forma tal y como se
indica a continuación: Redshift_{Endpoint-name}_{redshift-database-name}, por ejemplo:
Redshift_abcde03_dev
• Description (cadena UTF-8): su descripción de la conexión.
• ConnectionType (UTF-8) obligatorio: el tipo de conexión. En la actualidad, solo se admite JDBC; SFTP
es incompatible.
• ConnectionProperties (dict) obligatorias: una lista de pares clave-valor utilizados como parámetros
para esta conexión, incluida la URL de conexión de JDBC, el nombre de usuario y la contraseña.
• PhysicalConnectionRequirements (dict): requisitos de conexión física, que incluyen lo siguiente:
• SubnetId (cadena UTF-8): el ID de la subred que utiliza la conexión.
• SecurityGroupIdList (lista): lista de ID de grupo de seguridad que usa la conexión.
• AvailabilityZone (cadena UTF-8) obligatoria: la zona de disponibilidad que contiene el punto de
enlace. Este parámetro ha quedado obsoleto.

A continuación, cree un rastreador de AWS Glue para rellenar el catálogo de AWS Glue. Para obtener más
información, consulte la sección de catalogación de tablas con un rastreador en la Guía del desarrollador
de AWS Glue. El primer paso para añadir un rastreador consiste en crear una nueva base de datos en
un Data Catalog utilizando la API del SDK de AWS. Antes de comenzar, primero debe eliminar cualquier
versión anterior de la misma versión con la operación delete_crawler.
Al crear el rastreador, hay que tener algunas consideraciones en cuenta:
• Para el nombre del rastreador, utilice el formato

<redshift_node_name>_<redshift_database_name>_<redshift_shema_name>, por ejemplo:
abcde03_dev_ora_glue.
• Utilice un rol de IAM que ya existe. Para obtener más información acerca de cómo crear roles de IAM,
consulte Creación de roles de IAM en la Guía del usuario de IAM.
• Utilice el nombre de la base de datos que creó en los pasos anteriores.
Version 1.0
140
• Utilice el parámetro ConnectionName, que es obligatorio.

• Para el parámetro path, utilice la ruta al destino de JDBC, por ejemplo: dev/ora_glue/%.
En el siguiente ejemplo se elimina un rastreador existente y, a continuación, se crea uno nuevo con la API
de Python para AWS Glue.
response = client.delete_crawler(
Name='crawler_name'
)
response = client.create_crawler(
Name='crawler_name',
Role= ‘IAM_role’,
DatabaseName='database_name’,
Description='string',
Targets={
'S3Targets': [
{
'Path': 'string',
'Exclusions': [
'string',
]
},
],
'JdbcTargets': [
{
'ConnectionName': ‘ConnectionName’,
'Path': ‘Include_path’,
'Exclusions': [
'string',
]
},
]
},
Schedule='string',
Classifiers=[
'string',
],
TablePrefix='string',
SchemaChangePolicy={
'UpdateBehavior': 'LOG'|'UPDATE_IN_DATABASE',
'DeleteBehavior': 'LOG'|'DELETE_FROM_DATABASE'|'DEPRECATE_IN_DATABASE'
},
Configuration='string'
)
Después de crear el rastreador, ejecute un rastreador que se conecte a uno o varios almacenes de datos,
determine las estructuras de datos y escriba tablas en el Data Catalog. Puede ejecutar su rastreador de
manera programada, tal y como se muestra a continuación.
response = client.start_crawler(
Name='string'
)
Debido a que estamos utilizando Amazon Redshift, nuestro objetivo en este ejemplo, los tipos de datos de
Amazon Redshift se asignan al tipo de datos Glue de la siguiente forma después de ejecutar el rastreador.
Tipo de datos de Amazon Redshift Tipo de datos de AWS Glue
smalint smallint
Version 1.0
141
integer int
bigint bigint
decimal decimal(18,0)
decimal(p,s) decimal(p,s)
real double
double precision double
booleano booleano
char string
varchar string
varchar(n) string
fecha fecha
timestamp timestamp
timestamptz timestamp
Version 1.0
142
Uso de un agente de replicación
de AWS SCT con AWS DMS
Uso de la Herramienta de conversión

de esquemas de AWS con el AWS
Database Migration Service
Uso de un agente de replicación de AWS SCT con
AWS DMS
Para migraciones de bases de datos de gran tamaño, puede utilizar un agente de replicación de AWS
SCT para copiar los datos de la base de datos local en Amazon S3 o en un dispositivo Amazon Snowball.
El agente de replicación funciona con AWS DMS y el agente de replicación puede funcionar en segundo
plano mientras AWS SCT está cerrado.
Cuando se trabaja con Amazon Snowball, el agente de AWS SCT extrae los datos en el dispositivo
Amazon Snowball. El dispositivo se envía a AWS y los datos se cargan en un bucket de Amazon S3.
Durante este tiempo, el agente de AWS SCT sigue en ejecución. A continuación, el agente obtiene los
datos de Amazon S3 y los copia en el punto de enlace de destino.
Uso de un agente de extracción de datos de AWS

SCT con AWS DMS
AWS SCT proporciona un agente de extracción de datos para facilitar las migraciones de Apache
Cassandra a Amazon DynamoDB. Cassandra y DynamoDB son bases de datos NoSQL, pero difieren en
la arquitectura del sistema y en la representación de los datos. AWS SCT proporciona flujos de trabajo
basados en asistente para la automatización del proceso de migración de Cassandra a DynamoDB e
integra con AWS Database Migration Service (AWS DMS) para realizar la migración real.
Version 1.0
143
Migración de datos desde un almacén
de datos local a Amazon Redshift
Uso de agentes de extracción de

datos
En algunas situaciones de migración, las bases de datos de origen y de destino son muy diferentes entre
sí y requieren una transformación de datos adicional. AWS SCT es ampliable, de modo que puede tratar
estas situaciones con un agente—, un programa externo que está integrado con la AWS SCT, pero que
lleva a cabo la transformación de datos en otro lugar (como, por ejemplo, una instancia Amazon EC2).
Además, un agente de AWS SCT puede interactuar con otros servicios de AWS en su nombre—, tales
como la creación y la administración de tareas de AWS Database Migration Service.
En los siguientes temas se describen estas situaciones de forma más detallada y se explica cómo utilizar
los agentes de la AWS SCT durante el proceso de migración.
Temas
• Migración de datos desde un almacén de datos local a Amazon Redshift (p. 144)
• Migración de datos desde Apache Cassandra a Amazon DynamoDB (p. 168)
Migración de datos desde un almacén de datos

local a Amazon Redshift
Puede utilizar un agente de AWS SCT para extraer datos desde su almacén de datos local y migrarlos a
Amazon Redshift. El agente extrae los datos y los carga en Amazon S3 o en un dispositivo AWS Snowball.
A continuación, puede utilizar AWS SCT para copiar los datos en Amazon Redshift.
Amazon S3 es un servicio de almacenamiento y de recuperación. Para almacenar un objeto en Amazon

S3, debe cargar en un bucket de Amazon S3 el archivo que quiera almacenar. Al cargar un archivo, puede
configurar permisos en el objeto y también en cualquier metadato.
Las migraciones de datos a gran escala pueden incluir muchos terabytes de información y pueden verse
ralentizadas por el desempeño de la red y la gran cantidad de datos que hay que mover. AWS Snowball
es un servicio de AWS que puede utilizar para transferir datos a la nube a velocidades superiores a las
de la red mediante un dispositivo propiedad de AWS. Un dispositivo AWS Snowball puede contener hasta
80 TB de datos y un dispositivo AWS Snowball Edge puede contener hasta 100 TB. Usa el cifrado de 256
bits y un Módulo de plataforma segura (TPM) estándar del sector diseñado para garantizar la seguridad y
la cadena de custodia completa de los datos. AWS SCT funciona con dispositivos AWS Snowball y AWS
Snowball Edge, que se denominarán dispositivos AWS Snowball en el resto de esta guía.
Cuando se utiliza AWS SCT y un dispositivo AWS Snowball, los datos se migran en dos etapas. En primer
lugar, se utiliza AWS SCT para procesar los datos a nivel local y, a continuación, se mueven al dispositivo
AWS Snowball. A continuación, se envía el dispositivo a AWS mediante el proceso de AWS Snowball y
AWS carga automáticamente los datos en un bucket de Amazon S3. Después, cuando los datos están
disponibles en Amazon S3, se usa AWS SCT para migrar los datos a Amazon Redshift. Los agentes de
extracción de datos pueden trabajar en segundo plano mientras la AWS SCT está cerrada.
En el siguiente diagrama se muestran los escenarios admitidos.
Version 1.0
144
Migración de datos desde un almacén
de datos local a Amazon Redshift
En la actualidad, los agentes de extracción de datos se admiten para los siguientes data warehouses de
origen:
• Greenplum Database (versión 4.3 y posteriores)

• Microsoft SQL Server (versión 2008 y posteriores)
• Netezza (versión 7.0.3 y posteriores)
• Oracle (versión 10 y posteriores)
• Teradata (versión 13 y posteriores)
• Vertica (versión 7.2.2 y posteriores)
Puede conectarse a puntos de enlace de FIPS para Amazon Redshift si tiene que cumplir con los
requisitos de seguridad del Estándar federal de procesamiento de la información. Hay puntos de enlace de
FIPS en las siguientes regiones de AWS:
• Región EE.UU. Este (Norte de Virginia) (redshift-fips.us-east-1.amazonaws.com)

• Región EE.UU Este (Ohio) (redshift-fips.us-east-2.amazonaws.com)
• EE.UU. Oeste (Norte de California) (redshift-fips.us-west-1.amazonaws.com)
• Región EE.UU. Oeste (Oregón) (redshift-fips.us-west-2.amazonaws.com)
Utilice la información en los temas siguientes para aprender a trabajar con los agentes de extracción de
datos.
Temas
• Configuración de requisitos previos para Amazon S3 y seguridad para los agentes de extracción de
datos (p. 146)
• Instalación de agentes de extracción (p. 147)
• Registro de agentes de extracción con la Herramienta de conversión de esquemas de AWS (p. 150)
Version 1.0
145
Configuración de requisitos previos
• Ocultar y recuperar información de un agente de AWS SCT (p. 151)

• Creación de filtros de extracción de datos en la Herramienta de conversión de esquemas de
AWS (p. 153)
• Ordenación de datos antes de la migración con la AWS SCT (p. 153)
• Creación, ejecución y monitorización de una tarea de extracción de datos de AWS SCT (p. 154)
• Extracción de datos con un dispositivo AWS Snowball (p. 156)
• Resultado de la tarea de extracción de datos (p. 162)
• Uso de particiones virtuales con Herramienta de conversión de esquemas de AWS (p. 164)
• Migración de LOBs a Amazon Redshift (p. 166)
• Prácticas recomendadas y solución de problemas de agentes de extracción de datos (p. 167)
Configuración de requisitos previos para Amazon S3 y

seguridad para los agentes de extracción de datos
Antes de trabajar con los agentes de extracción de datos, almacene la información de su bucket de
Amazon S3 y configure los almacenes de confianza y de claves de la capa de conexión segura (SSL).
Configuración de Amazon S3
Después de que sus agentes extraigan los datos, los cargarán en el bucket de Amazon S3. Antes
de continuar, debe proporcionar las credenciales para conectarse a su cuenta de AWS y a su bucket
de Amazon S3. Puede almacenar la información de sus credenciales y su bucket en un perfil en la
configuración de la aplicación global y, a continuación, asociar el perfil con su proyecto de AWS SCT. Si
fuera necesario, seleccione Global Settings para crear un nuevo perfil. Para obtener más información,
consulte Uso de los perfiles del servicio de AWS en la Herramienta de conversión de esquemas de
AWS (p. 13).
Configuración de seguridad
La Herramienta de conversión de esquemas de AWS y los agentes de extracción pueden comunicarse a
través de la capa de conexión segura (SSL). Para habilitar la SSL, configure un almacén de confianza y un
almacén de claves.
Para configurar una comunicación segura con el agente de extracción

2. Abra el menú Settings y seleccione Global Settings. Aparecerá el cuadro de diálogo Global settings.
Seleccione la pestaña Security como se muestra a continuación.
Version 1.0
146
Instalación de agentes
3. Seleccione Generate Trust and Key Store o haga clic en Select existing Trust and Key Store.
Si selecciona Generate Trust and Key Store, a continuación tendrá que especificar el nombre y
la contraseña de los almacenes de confianza y de claves y la ruta a la ubicación de los archivos
generados. Utilizará estos archivos en pasos posteriores.
Si selecciona Select existing Trust and Key Store, después especificará la contraseña y el nombre del
archivo para los almacenes de confianza y de claves. Utilizará estos archivos en pasos posteriores.
4. Tras haber especificado el almacén de confianza y el almacén de claves, seleccione OK para cerrar el
cuadro de diálogo Global Settings.
Instalación de agentes de extracción

Le recomendamos que instale varios agentes de extracción en equipos individuales, independientes del
equipo en el que se esté ejecutando la Herramienta de conversión de esquemas de AWS.
En la actualidad, los agentes de extracción son compatibles con los siguientes sistemas operativos:
• macOS
• Microsoft Windows
• Red Hat Enterprise Linux (RHEL) 6.0
• Ubuntu Linux (versión 14.04 y posteriores)
Version 1.0
147
Utilice el siguiente procedimiento para instalar agentes de extracción. Repita este procedimiento para cada
equipo en el que desee instalar un agente de extracción.
Para instalar un agente de extracción
1. Si aún no ha descargado el archivo del instalador de la AWS SCT, siga las instrucciones de
Instalación, verificación y actualización de Herramienta de conversión de esquemas de AWS (p. 4)
para descargarlo. El archivo .zip que contiene el archivo del instalador de la AWS SCT también
contiene el archivo del instalador del agente de extracción.
2. Localice el archivo del instalador para su agente de extracción en una subcarpeta llamada agentes. El
archivo correcto para el sistema operativo del equipo en el que quiera instalar el agente de extracción
se muestra a continuación.
macOS aws-schema-conversion-tool-extractor-1.0.build-
number.dmg
Microsoft Windows aws-schema-conversion-tool-extractor-1.0.build-

number.msi
RHEL aws-schema-conversion-tool-extractor-1.0.build-
number.x86_64.rpm
Ubuntu Linux aws-schema-conversion-tool-extractor-1.0.build-

number.deb
3. Para instalar el agente de extracción en un equipo independiente, copie el archivo del instalador en el
nuevo equipo.
4. Ejecute el archivo del instalador. Utilice las instrucciones para su sistema operativo, que se muestran a
continuación.
Sistema operativo Instrucciones de instalación
macOS En Finder, abra aws-schema-conversion-tool-

extractor-1.0.build-number.dmg.
Arrastre aws-schema-conversion-tool-extractor-1.0.build-
number.dmg a la carpeta Applications.
Microsoft Windows Haga doble clic en el archivo para ejecutar el instalador.
RHEL Ejecute el siguiente comando en la carpeta en la que haya descargado o

movido el archivo:
sudo rpm -ivh aws-schema-conversion-tool-

extractor-1.0.build-number.x86_64.rpm
Ubuntu Linux Ejecute el siguiente comando en la carpeta en la que haya descargado o

movido el archivo:
sudo dpkg -i aws-schema-conversion-tool-

extractor-1.0.build-number.deb
5. Instale los controladores de Java Database Connectivity (JDBC) para el motor de base de datos de
origen. Para obtener instrucciones y enlaces de descarga, consulte Instalación de los controladores
de bases de datos necesarios (p. 8). Siga las instrucciones para el motor de base de datos de origen,
no solo para el motor de base de datos de destino.
Version 1.0
148
6. Copie los almacenes SSL de confianza y de claves (.zip o archivos individuales) que generó en el
procedimiento anterior. Si copia el archivo .zip a un nuevo equipo, extraiga los archivos individuales
del archivo .zip en el nuevo equipo.
Puede colocar los archivos en cualquier lugar que desee. No obstante, tenga en cuenta las
ubicaciones, ya que en un futuro procedimiento le dirá al agente dónde encontrar los archivos.
Siga con la instalación de su agente de extracción completando el procedimiento de la sección siguiente.
Configuración de agentes de extracción

Utilice el siguiente procedimiento para configurar agentes de extracción. Repita este procedimiento para
cada equipo en que tenga instalado un agente de extracción.
Para configurar su agente de extracción
• Desde la ubicación en la que haya instalado el agente, ejecute el programa de instalación. Para RHEL
y Ubuntu, el archivo se llamará sct-extractor-setup.sh. Para macOS y Microsoft Windows,
el archivo se llamará AWS SCT Data Extractor Agent y podrá hacer doble clic sobre él para
ejecutarlo.
El programa de instalación le pedirá información. Para cada solicitud, aparecerá un valor

predeterminado. Puede aceptar el valor predeterminado o introducir un valor nuevo. Debe especificar
la siguiente información:
• El motor del data warehouse.

• El número de puerto en el que escucha el agente.
• La ubicación en la que haya instalado los controladores de JDBC.
• La carpeta de trabajo. Sus datos extraídos se guardarán en una subcarpeta de esta ubicación. La
carpeta de trabajo puede estar en un equipo distinto al del agente, y una única carpeta de trabajo se
puede compartir entre varios agentes en diferentes equipos.
• La ubicación del archivo de almacén de claves.
• La contraseña del almacén de claves.
• La ubicación del archivo del almacén de confianza.
• La contraseña del almacén de confianza.
El programa de instalación actualiza el archivo de configuración para el agente de extracción. El archivo

de configuración se denomina Settings.properties y se encuentra en la ubicación en la que haya
instalado el agente de extracción. A continuación se muestra un archivo de configuración de ejemplo.
port=8888
vendor=ORACLE
driver.jars=<driver path>/Install/Drivers/ojdbc7.jar
location=<output path>/dmt/8888/out
extractor.log.folder=<log path>/dmt/8888/log
extractor.storage.folder=<storage path>/dmt/8888/storage
extractor.start.fetch.size=20000
extractor.out.file.size=10485760
ssl.option=OFF
#ssl.option=ON
#ssl.keystore.path=<key store path>/dmt/8888/vault/keystore
#ssl.truststore.path=<trust store path>/dmt/8888/vault/truststore
Version 1.0
149
Registro de agentes
Iniciar agentes de extracción

Utilice el siguiente procedimiento para iniciar agentes de extracción. Repita este procedimiento para cada
equipo en que tenga instalado un agente de extracción.
Los agentes de extracción actúan en escucha. Cuando inicia un agente con este procedimiento, el agente
comienza a escuchar para obtener instrucciones. Enviará a los agentes instrucciones para extraer los
datos de su data warehouse en una sección posterior.
Para iniciar su agente de extracción
• En el equipo en el que haya instalado el agente de extracción, ejecute el comando que aparezca a
continuación para su sistema operativo.
Sistema operativo Comando de inicio
macOS Ejecute el archivo StartAgent.command.
Microsoft Windows Haga doble clic en el archivo de lotes StartAgent.bat.
RHEL Ejecute el siguiente comando en la ruta de la carpeta en la que haya

instalado el agente:
sudo initctl start sct-extractor
Ubuntu Linux Ejecute el siguiente comando en la ruta de la carpeta en la que haya

instalado el agente. Utilice el comando adecuado para su versión de
Ubuntu.
Ubuntu 14.04: sudo initctl start sct-extractor
Ubuntu 15.04 y posteriores: sudo systemctl start sct-extractor
Para comprobar el estado del agente, ejecute el mismo comando, pero sustituya start por status.
Para detener un agente, ejecute el mismo comando, pero sustituya start por stop.
Registro de agentes de extracción con la Herramienta

Puede administrar los agentes de extracción mediante la AWS SCT. Los agentes de extracción actúan en
escucha. Cuando reciben instrucciones de la AWS SCT, extraen los datos de su almacén de datos.
Utilice el siguiente procedimiento para registrar los agentes de extracción con su proyecto de la AWS SCT.
Para registrar un agente de extracción
1. Inicie la Herramienta de conversión de esquemas de AWS y abra un proyecto.

2. Abra el menú View y seleccione Data Migration View. Aparecerá la pestaña Agents. Si ha registrado
agentes anteriormente, aparecerán en una cuadrícula en la parte superior de la pestaña, como se
muestra a continuación.
Version 1.0
150
Ocultar y recuperar información de un agente de AWS SCT
3. Elija Register. Aparecerá el cuadro de diálogo New Agent Registration.

Note
Después de registrar un agente con un proyecto de la AWS SCT, no puede registrar el mismo
agente con otro proyecto diferente. Si ya no utiliza un agente en un proyecto de la AWS SCT,
puede anularlo. A continuación, puede registrarlo con otro proyecto diferente.
4. Introduzca la información en el cuadro de diálogo New Agent Registration:
a. En Description, escriba la descripción del agente.

b. En Host Name, escriba el nombre de host o la dirección IP del equipo del agente.
c. En Port, escriba el número de puerto en el que esté escuchando el agente.
d. Elija Register (Registrar) para registrar el agente con su proyecto de AWS SCT.
5. Repita los pasos anteriores para registrar múltiples agentes con su proyecto de la AWS SCT.
Ocultar y recuperar información de un agente de AWS

SCT
Un agente de AWS SCT cifra una importante cantidad de información, por ejemplo, las contraseñas de los
almacenes de claves y de confianza del usuario, las cuentas de base de datos, la información de la cuenta
de AWS y elementos similares. Hace esto utilizando un archivo especial llamado seed.dat. De forma
predeterminada, el agente crea este archivo en la carpeta de trabajo del usuario que configura el agente
por primera vez.
Como diferentes usuarios pueden configurar y ejecutar el agente, la ruta de seed.dat se almacena en el
parámetro {extractor.private.folder} del archivo settings.properties. Cuando se inicia el
agente, puede utilizar esta ruta para encontrar el archivo seed.dat y obtener acceso a la información del
almacén de claves y confianza de la base de datos correspondiente.
Version 1.0
151
Ocultar y recuperar información de un agente de AWS SCT
Es posible que necesite recuperar las contraseñas que un agente ha almacenado en estos casos:
• Si el usuario pierde el archivo seed.dat y la ubicación y el puerto del agente de la AWS SCT no han
cambiado.
• Si el usuario pierde el archivo seed.dat y la ubicación y el puerto del agente de la AWS SCT han
cambiado. En este caso, el cambio suele ocurrir porque el agente se ha migrado a otro host o puerto y la
información del archivo seed.dat ya no es válida.
En estos casos, si se inicia un agente sin SSL, este se inicia y después obtiene acceso al almacenamiento
del agente creado con anterioridad. A continuación adopta el estado Waiting for recovery.
No obstante, en estos casos, si se inicia un agente con SSL, no puede reiniciarlo. Esto se debe a
que el agente no puede descifrar las contraseñas para los certificados almacenados en el archivo
settings.properties. En este tipo de inicio, el agente no se puede iniciar. Se escribe un error similar
al siguiente en el archivo log: "El agente no se pudo iniciar con el modo SSL habilitado. Vuelva configurar
el agente. Motivo: La contraseña de keystore es incorrecta".
Para solucionar este problema, cree un nuevo agente y configúrelo de forma que use las contraseñas
existentes para obtener acceso a los certificados SSL. Para ello, siga el procedimiento que se indica a
continuación.
Después de realizar este procedimiento, el agente debe ejecutarse y adoptar el estado Waiting for recovery
(Esperando recuperación). AWS SCT envía automáticamente las contraseñas necesarias a un agente en
el estado Waiting for recovery (Esperando recuperación). Cuando el agente tiene las contraseñas, reinicia
todas las tareas. No se requiere ninguna acción adicional por parte de SCT.
Para volver a configurar el agente y restaurar las contraseñas para obtener acceso a los
certificados SSL
1. Instale un nuevo agente de AWS SCT y ejecute la configuración.

2. Cambie la propiedad agent.name del archivo instance.properties al nombre del agente para el
que se creó el almacenamiento, para que el nuevo agente trabaje con el almacenamiento del agente
existente.
El archivo instance.properties se almacena en la carpeta privada del agente, que recibe su

nombre siguiendo esta convención: {output.folder}\dmt\{hostName}_{portNumber}\.
3. Cambie el nombre de {output.folder} a la carpeta de salida del agente anterior.
En este momento, AWS SCT todavía intenta obtener acceso al antiguo extractor en el host y puertos
antiguos. Por consiguiente, el extractor inaccesible obtiene el estado FAILED. A continuación, puede
cambiar el host y el puerto.
4. Modifique el host, el puerto o ambas cosas del agente anterior mediante el comando Modify para
redirigir el flujo de solicitudes al nuevo agente.
Cuando AWS SCT puede hacer ping en el nuevo agente, AWS SCT recibe el estado Waiting for
recovery (Esperando recuperación) del agente. A continuación, AWS SCT recupera automáticamente las
contraseñas del agente.
Cada agente que trabaja con el almacenamiento del agente actualiza un archivo especial llamado
storage.lck ubicado en {output.folder}\{agentName}\storage\. Este archivo contiene
el ID de red del agente y el tiempo hasta que el almacenamiento está bloqueado. Cuando el agente
trabaja con el almacenamiento del agente, actualiza el archivo storage.lck y amplía el arrendamiento
del almacenamiento en 10 minutos cada 5 minutos. Ninguna otra instancia puede trabajar con el
almacenamiento de este agente hasta que finalice el arrendamiento.
Version 1.0
152
Creación de filtros de extracción de datos
Creación de filtros de extracción de datos en la

Antes de extraer los datos con la Herramienta de conversión de esquemas de AWS, puede configurar
filtros que reduzcan la cantidad de datos que va a extraer. Puede crear filtros de extracción de datos
mediante el uso de cláusulas WHERE para reducir los datos que puede extraer. Por ejemplo, puede escribir
una cláusula WHERE que seleccione los datos de una única tabla.
Puede crear filtros de extracción de datos y guardar los filtros como parte de su proyecto. Con el proyecto
abierto, utilice el siguiente procedimiento para crear filtros de extracción de datos.
Para crear filtros de extracción de datos
1. En el menú Settings, seleccione Mapping Rules. Aparecerá el cuadro de diálogo Mapping Rules. El
panel superior contiene reglas de transformación y el panel inferior contiene reglas de filtrado.
2. En el panel Filtering Rules, seleccione Add new rule.
3. Configure su filtro:
a. En Name, escriba un nombre para su filtro.

b. En Where schema name like, escriba un filtro para aplicárselo a los esquemas. En este filtro, una
cláusula WHERE se evalúa mediante una cláusula LIKE. Puede especificar un nombre exacto para
seleccionar un esquema o introducir un patrón para seleccionar varios esquemas.
c. En table name like, escriba un filtro para aplicárselo a las tablas. En este filtro, una cláusula
WHERE se evalúa mediante una cláusula LIKE. Puede especificar un nombre exacto para
seleccionar una tabla o introducir un patrón para seleccionar varias tablas.
d. En Where clause, escriba una cláusula WHERE para filtrar los datos.
4. Una vez que haya configurado su filtro, seleccione Save para guardar el filtro o Cancel para cancelar
los cambios.
5. Cuando haya acabado de agregar, editar y eliminar filtros, seleccione Save All para guardar todos los
cambios y, a continuación, seleccione Close.
Puede utilizar el icono de alternar para desactivar un filtro sin eliminarlo. También puede utilizar el icono
de copia para duplicar un filtro existente. Para borrar un filtro existente, utilice el icono de eliminar. Para
guardar los cambios que realice en sus filtros, seleccione Save All.
Ordenación de datos antes de la migración con la

AWS SCT
Ordenar los datos antes de la migración con la AWS SCT proporciona algunas ventajas. Si ordena los
datos en primer lugar, la AWS SCT puede reiniciar el agente de extracción en el último punto guardado
después de un error. Además, si va a migrar datos a Amazon Redshift y ordena los datos en primer lugar,
la AWS SCT puede insertar datos en Amazon Redshift con mayor rapidez.
Estas ventajas tienen que ver con cómo la AWS SCT crea las consultas de extracción de datos. En
algunos casos, la AWS SCT utiliza la función analítica DENSE_RANK en estas consultas. Sin embargo,
DENSE_RANK puede consumir mucho tiempo y recursos del servidor para ordenar el conjunto de datos
que resultan de la extracción, de modo que si la AWS SCT puede trabajar sin ella, así lo hace.
Par ordenar datos antes de la migración con la AWS SCT

2. Abra el menú contextual (clic secundario) para el objeto y seleccione Create Local Task.
3. Seleccione la pestaña Advanced y elija una opción para Sorting Strategy:
Version 1.0
153
Creación, ejecución y monitorización
de una tarea de AWS SCT
• Never use sorting (No utilizar nunca la ordenación) –: El agente de extracción no utiliza la función
analítica DENSE_RANK y se reinicia desde el principio si se produce un error.
• Use sorting if possible (Utilizar la ordenación si es posible) –: El agente de extracción utiliza
DENSE_RANK si la tabla tiene una clave primaria o una restricción única.
• Use sorting after first fail (recommended) [Utilizar la ordenación después del primer error
(recomendado)] – El agente de extracción intenta primero obtener los datos sin usar DENSE_RANK.
Si el primer intento falla, el agente de extracción reconstruye la consulta mediante DENSE_RANK y
conserva su ubicación en caso de error.
4. Establezca parámetros adicionales, como se describe a continuación, y seleccione Create para crear
la tarea de extracción de datos.
Creación, ejecución y monitorización de una tarea de

extracción de datos de AWS SCT
Utilice los siguientes procedimientos para crear, ejecutar y monitorizar las tareas de extracción de datos.
Para asignar tareas a agentes y migrar datos
1. En la Herramienta de conversión de esquemas de AWS, después de haber convertido el esquema,

seleccione una o varias tablas en el panel izquierdo del proyecto.
Version 1.0
154
Creación, ejecución y monitorización
de una tarea de AWS SCT
Puede seleccionar todas las tablas, pero no se lo recomendamos por motivos de desempeño. Le
recomendamos que cree varias tareas para varias tablas basadas en el tamaño de las tablas en el
data warehouse.
2. Abra el menú contextual (clic secundario) para cada tabla y seleccione Create Task. Se abre el cuadro
de diálogo Create Local Task como se muestra a continuación.
3. En Task Name, escriba un nombre para la tarea.

4. En Migration Mode, seleccione una de las siguientes opciones:
• Extract Only (Solo extraer) –: extrae los datos y los guarda en sus carpetas de trabajo locales.
• Extract and Upload (Extraer y cargar) –: extrae los datos y los carga en Amazon S3.
• Extract, Upload and Copy (Extraer, cargar y copiar) –: extrae los datos, los carga a Amazon S3 y los
copia en el almacén de datos de Amazon Redshift.
5. Seleccione Extract LOBs para extraer grandes objetos. Si no es necesario extraer objetos grandes,
puede quitar la marca de selección de la casilla. Esto reduce la cantidad de datos que extrae.
6. Si desea ver información detallada sobre una tarea, seleccione Enable Task Logging. Puede utilizar el
registro de tareas para depurar problemas.
Si habilita el registro de tareas, seleccione el nivel de detalle que desea ver. Los niveles son los
siguientes y cada nivel incluye todos los mensajes del nivel anterior:
• ERROR: – La cantidad mínima de detalles.

• WARNING
• INFO
• DEBUG
• TRACE: – La cantidad máxima de detalles.
7. Seleccione Test Task (Probar tarea) para comprobar que se puede conectar a su carpeta de trabajo,
bucket de Amazon S3 y almacén de datos de Amazon Redshift. La verificación depende del modo de
migración que elija.
8. Seleccione Create para crear la tarea.
9. Repita los pasos anteriores para crear tareas para todos los datos que quiera migrar.
Version 1.0
155
Extracción de datos con un dispositivo AWS Snowball
Para ejecutar y monitorizar tareas
1. En View, elija Data Migration View. Aparecerá la pestaña Agents.

2. Elija la pestaña Tasks. Sus tareas aparecen en la cuadrícula en la parte superior tal y como se
muestra a continuación. Podrá ver el estado de una tarea en la cuadrícula superior y el estado de las
subtareas en la cuadrícula inferior.
3. Seleccione una tarea en la cuadrícula superior y amplíela. En función del modo de migración que elija,
verá la tarea dividida en Extraer, Upload y Copy.
4. Para comenzar una tarea, seleccione Start para esa tarea. Puede monitorizar el estado de sus tareas
mientras están en ejecución. Las subtareas se ejecutan en paralelo. Las funciones de extracción,
carga y copia también se ejecutan en paralelo.
5. Si ha habilitado el registro al configurar la tarea, podrá ver el registro:
a. Seleccione Download Log. Aparecerá un mensaje con el nombre de la carpeta que contiene el
archivo de registro. Omita el mensaje.
b. Aparecerá un enlace en la pestaña Task details. Seleccione el enlace para abrir la carpeta que
contiene el archivo de registro.
Puede cerrar la AWS SCT y sus agentes y tareas seguirán ejecutándose. Puede volver a abrir la AWS
SCT en otro momento para comprobar el estado de sus tareas y consultar los registros de tareas.

El proceso de utilizar AWS SCT y AWS Snowball consta de varios pasos. La migración implica una tarea
local, donde AWS SCT usa un agente de extracción de datos para trasladar los datos al dispositivo AWS
Snowball, y una acción intermedia en la que AWS copia los datos desde el dispositivo AWS Snowball a un
bucket de Amazon S3. El proceso termina cuando AWS SCT carga los datos desde el bucket de Amazon
S3 en Amazon Redshift.
Version 1.0
156
Las secciones que siguen a esta información general proporcionan una guía paso a paso para cada una
de estas tareas. El procedimiento se supone que ha instalado AWS SCT y que ha configurado y registrado
un agente de extracción de datos en una máquina dedicada.
Los siguientes pasos deben producirse para migrar datos desde un almacén de datos local a un almacén
de datos de AWS con AWS Snowball.
1. Cree un trabajo de AWS Snowball utilizando la consola de AWS Snowball. Para obtener más
información, consulte Create an Import Job en la documentación de AWS Snowball.
2. Desbloquee el dispositivo AWS Snowball Edge mediante la máquina Linux dedicada local.
3. Cree un nuevo proyecto en AWS SCT mediante el agente de extracción de datos registrado.
4. Instale el controlador de base de datos para la base de datos de origen en la máquina dedicada en la
que instaló el extractor de datos.
5. Cree y establezca permisos para que el bucket de Amazon S3 los utilice.
6. Cree Local & DMS Task en SCT.
7. Ejecute y monitoree la Local & DMS Task en SCT.
8. Ejecute la tarea de AWS SCT y monitoree el progreso en SCT.
Procedimientos paso a paso para la migración de datos con AWS

SCT y AWS Snowball
En las secciones siguientes se incluye información detallada sobre los pasos para la migración.
Paso 1: Crear un trabajo de AWS Snowball

Cree un trabajo de AWS Snowball siguiendo los pasos descritos en la sección Getting Started with AWS
Snowball Edge: Your First Job en la documentación de AWS Snowball.
Paso 2: Desbloquear el dispositivo AWS Snowball Edge

Debe ejecutar los comandos que desbloquean y proporcionan credenciales para el dispositivo Snowball
Edge de la máquina donde instaló el agente de DMS. De esta forma, puede asegurarse de que la llamada
del agente de DMS conecta con el dispositivo AWS Snowball Edge. Para obtener más información sobre el
desbloqueo del dispositivo AWS Snowball Edge, consulte Desbloqueo del dispositivo Snowball Edge.
Por ejemplo, el siguiente comando muestra el bucket de Amazon S3 utilizado por el dispositivo.
aws s3 ls s3://<bucket-name> --profile <Snowball Edge profile> --endpoint http://<Snowball

IP>:8080 --recursive
Paso 3: Crear un nuevo proyecto de AWS SCT

A continuación, cree un nuevo proyecto de AWS SCT.
Para crear un proyecto nuevo en AWS SCT
1. Inicie AWS SCT y elija New Project para File. Aparece el cuadro de diálogo New Project.
2. Agregue la siguiente información del proyecto.
Version 1.0
157

OLTP Elija Transactional Database (OLTP).
Source DB Engine Elija el almacén de datos de origen.
Target DB Engine Elija el almacén de datos de destino.
3. Elija OK para crear su proyecto de AWS SCT.

4. (Opcional) Pruebe la conexión.
Paso 4: Instalar el controlador de base de datos de origen para el agente de DMS

en el equipo Linux
Para que la migración tenga éxito, el agente de DMS tiene que poder conectarse a la base de datos de
origen. Para que esto sea posible, debe instalar el controlador de base de datos para la base de datos de
origen. El controlador necesario varía en función de la base de datos.
Para reiniciar el agente de DMS después de la instalación del controlador de base de datos, cambie el
directorio de trabajo a <product_dir>/bin y utilice los pasos que se enumeran a continuación para
cada base de datos de origen.
cd <product_dir>/bin
./arep.ctl stop
./arep.ctl start
Para instalar en Oracle
Instale Oracle Instant Client para Linux (x86-64) versión 11.2.0.3.0 o posterior.
Además, si no se ha incluido todavía en el sistema, debe crear un enlace simbólico en el directorio

$ORACLE_HOME\lib. Este enlace debe denominarse libclntsh.so y debería apuntar a una versión
específica de este archivo. Por ejemplo, en un cliente de Oracle 12c:
lrwxrwxrwx 1 oracle oracle 63 Oct 2 14:16 libclntsh.so ->

/u01/app/oracle/home/lib/libclntsh.so.12.1
Además, la variable de entorno LD_LIBRARY_PATH debe anexarse con el directorio lib de Oracle y
añadirse al script site_arep_login.sh bajo la carpeta lib de la instalación. Añada este script si no existe.
vi cat <product dir>/bin/site_arep_login.sh
export ORACLE_HOME=/usr/lib/oracle/12.2/client64; export

LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$ORACLE_HOME/lib
Para instalar en Microsoft SQL Server
Instalar el controlador ODBC para Microsoft
Version 1.0
158
Actualizar el site_arep_login.sh con el siguiente código.
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/opt/microsoft/msodbcsql/lib64/
Controlador ODBC de Simba
Instalar el controlador ODBC para Microsoft
Editar el archivo simba.sqlserverodbc.ini de la siguiente manera
DriverManagerEncoding=UTF-16
ODBCInstLib=libodbcinst.so
Para instalar en SAP Sybase
Debe instalarse el controlador ODBC para SAP Sybase ASE de 64 bits
Si el directorio de instalación es /opt/sap, actualizar site_arep_login.sh con
export SYBASE_HOME=/opt/sap
export
LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$SYBASE_HOME/
DataAccess64/ODBC/lib:$SYBASE_HOME/DataAccess/ODBC/
lib:$SYBASE_HOME/OCS-16_0/lib:$SYBASE_HOME/OCS-16_0/
lib3p64:$SYBASE_HOME/OCS-16_0/lib3p
El /etc/odbcinst.ini debe incluir estas entradas
[Sybase]
Driver=/opt/sap/DataAccess64/ODBC/lib/libsybdrvodb.so
Description=Sybase ODBC driver
Para instalar en MySQL
Instalar MySQL Connector/ODBC para Linux, versión 5.2.6 o posterior
Asegúrese de que el archivo /etc/odbcinst.ini contiene una entrada para MySQL, como en el siguiente
ejemplo
[MySQL ODBC 5.2.6 Unicode Driver]

Driver = /usr/lib64/libmyodbc5w.so
UsageCount = 1
Para instalar en PostgreSQL
Instale postgresql94-9.4.4-1PGDG.<Versión de SO>.x86_64.rpm. Este es el paquete que contiene el

ejecutable de psql.
Version 1.0
159
Por ejemplo, postgresql94-9.4.4-1PGDG.rhel7.x86_64.rpm es el paquete necesario para Red Hat 7.
Instale el controlador ODBC postgresql94-odbc-09.03.0400-1PGDG.<versión de SO>.x86_64 o

superior para Linux, donde <versión de SO> es el SO de la máquina del agente.
Por ejemplo, postgresql94-odbc-09.03.0400-1PGDG.rhel7.x86_64 es el cliente necesario para Red

Hat 7.
Asegúrese de que el archivo /etc/odbcinst.ini contiene una entrada para PostgreSQL, como en el
siguiente ejemplo
[PostgreSQL]
Description = PostgreSQL ODBC driver
Driver = /usr/pgsql-9.4/lib/psqlodbc.so
Setup = /usr/pgsql-9.4/lib/psqlodbcw.so
Debug = 0
CommLog = 1
UsageCount = 2
Paso 5: Configurar AWS SCT para acceder al bucket de Amazon S3

Para obtener más información sobre cómo configurar un bucket de Amazon S3, consulte Uso de buckets
de Amazon S3 en la documentación de Amazon S3.
Paso 6: Creación de una tarea local y de DMS

A continuación, debe crear la tarea de migración integral. La tarea incluye dos tareas secundarias. Una
tarea secundaria migra datos de la base de datos de origen al dispositivo AWS Snowball. La otra tarea
secundaria toma los datos que el dispositivo cara a un bucket de Amazon S3 y los migra a la base de
datos de destino.
Para crear la tarea de migración integral
1. Inicie AWS SCT, elija View y, a continuación, elija Database Migration View (Local & DMS).
2. En el panel de la izquierda que muestra el esquema de la base de datos de origen, seleccione un

objeto del esquema para su migración. Abra el menú contextual (haga clic con el botón derecho) para
el objeto y seleccione Create Local & DMS Task.
Version 1.0
160
3. Añada la información de su tarea.
Task Name Escriba un nombre para la tarea.
Agente Elija DMS Agent.
Replication Instance Elija la instancia de replicación de AWS DMS que desea

usar.
Tipo de migración Elija el tipo de migración que desea.
Elija Migrate existing data para migrar el contenido del

esquema elegido. Este proceso se denomina carga
completa en AWS DMS.
Elija Migrate existing data and replicate ongoing changes

para migrar el contenido del esquema elegido y capturar
todos los cambios continuos a la base de datos. Este
proceso se denomina carga completa y CDC en AWS
DMS.
Target table preparation mode Elija el modo de preparación que desea utilizar.
Truncate: las tablas se truncan sin que los metadatos de la

tabla se vean afectados.
Drop tables on target: las tablas existentes se eliminan y

se crean otras para sustituirlas.
Do nothing: los datos y los metadatos de las tablas de

destino no cambiarán.
Rol de IAM Elija el rol de IAM predefinido que tiene permisos para
acceder al bucket de Amazon S3 y a la base de datos
de destino. Para obtener más información acerca de los
permisos necesarios para acceder a un bucket de Amazon
S3, consulte Configuración de Amazon S3 (p. 146).
Registro Elija Enable para que AWS CloudWatch cree registros

para la migración. Se le cobrarán cargos por este
servicio. Para obtener más información acerca de
Version 1.0
161
Resultado de la tarea de extracción de datos

AWS CloudWatch, consulte Cómo funciona Amazon
CloudWatch
Descripción Escriba una descripción de la tarea.
Use Snowball Elija esta casilla de verificación para utilizar Snowball.
Job Name Elija el nombre del trabajo de AWS Snowball que ha

creado.
Snowball IP Escriba la dirección IP del dispositivo AWS Snowball.
Puerto Escriba el valor de puerto para el dispositivo AWS

Snowball.
Local AWS S3 Access key Escriba la clave de acceso de AWS de la cuenta que utiliza
para la migración.
Local AWS S3 Secret key Escriba la clave secreta de AWS de la cuenta que utiliza
para la migración.
Paso 7: Ejecución y monitorización de la tarea de SCT

Puede iniciar la tarea local y de DMS cuando todas las conexiones a los puntos de enlace se hayan
realizado con éxito. Esto significa todas las conexiones para la tarea local, que incluyen conexiones del
agente de DMS a la base de datos de origen, el almacenamiento provisional del bucket de Amazon S3 y el
dispositivo AWS Snowball, así como las conexiones para la tarea de DMS, que incluye conexiones para el
almacenamiento provisional del bucket de Amazon S3 a la base de datos de destino en AWS.
Puede monitorear los registros del agente de DMS eligiendo Show log. Los detalles del registro incluyen
los registros del servidor del agente (Agent Log) y de la tarea de ejecución local (Task Log). Dado que el
servidor realiza la conectividad del punto de enlace (ya que la tarea local no se está ejecutando y no hay
registros de tareas), los problemas de conexión se enumeran bajo la pestaña Agent Log.

Tras completarse sus tareas de migración, sus datos estarán listos. Utilice la siguiente información para
determinar cómo proceder en función del modo de migración que haya elegido y la ubicación de los datos.
Modo de Ubicación de los datos

migración
Extract, Upload Los datos ya están en su almacén de datos de Amazon Redshift. Puede verificar que
and Copy los datos están ahí y empezar a utilizarlos. Para obtener más información, consulte la
sección Conexión a clústeres desde herramientas cliente y códigos.
Version 1.0
162
Modo de Ubicación de los datos

migración
Extract and Los agentes de extracción habrán guardado sus datos como archivos en el bucket de
Upload Amazon S3. Puede utilizar el comando COPY de Amazon Redshift para cargar sus
datos en Amazon Redshift. Para obtener más información, consulte la sección Carga
de datos desde Amazon S3 en la documentación de Amazon Redshift.
Existen varias carpetas en el bucket de Amazon S3 que se corresponden con las

tareas de extracción que haya configurado. Al cargar sus datos en Amazon Redshift,
especifique el nombre del archivo de manifiesto creado por cada tarea. El archivo de
manifiesto aparecerá en la carpeta de tareas del bucket de S3, tal y como se muestra a
continuación.
Extract Only Los agentes de extracción habrán guardado sus datos en su carpeta de trabajo. Copie
a mano sus datos en el bucket de Amazon S3 y, a continuación, proceda con las
instrucciones para Extract and Upload (Extraer y cargar).
Version 1.0
163
Uso de particiones virtuales
Uso de particiones virtuales con Herramienta de

A menudo, podrá administrar mejor grandes tablas sin particiones mediante la creación de subtareas
que crean particiones virtuales de los datos de la tabla utilizando reglas de filtrado. En la AWS SCT, es
posible crear particiones virtuales de los datos migrados. Existen tres tipos de partición, que funcionan con
determinados tipos de datos:
• El tipo de partición RANGE funciona con tipos de datos de fecha y hora y numéricos.
• El tipo de partición LIST funciona con tipos de datos de fecha y hora, numéricos y caracteres.
• El tipo de partición DATE AUTO SPLIT funciona con tipos de datos de fecha y hora.
La AWS SCT valida los valores que proporcione para crear una partición. Por ejemplo, si intenta realizar la
partición de una columna con tipos de datos NUMERIC pero proporciona valores de otro tipo de datos, la
AWS SCT produce un error.
Límites en la creación de particiones virtuales

Estas son las limitaciones al crear una partición virtual:
• Solo puede utilizar la partición virtual únicamente para tablas no particionadas.

• Puede utilizar la partición virtual únicamente en la vista de migración de datos.
• No puede utilizar la opción UNION ALL VIEW con particiones virtuales.
Tipo de partición RANGE

El tipo de partición RANGE realiza particiones de datos basadas en un intervalo de valores de la columna
para tipos de datos de fecha y hora y numéricos. Este tipo de partición crea una cláusula WHERE y usted
proporciona el intervalo de valores de cada partición. Especifique una lista de valores para la columna
particionada en el cuadro Values. Puede cargar información del valor mediante un archivo .csv.
Por ejemplo, puede crear varias particiones basadas en un intervalo de valores que proporcione. En el
siguiente ejemplo, se especifican los valores de partición para LO_TAX para crear varias particiones.
Partition1: WHERE LO_TAX <= 10000.9

Partition2: WHERE LO_TAX > 10000.9 AND LO_TAX <= 15005.5
Partition3: WHERE LO_TAX > 15005.5 AND LO_TAX <= 25005.95
Para crear una partición virtual RANGE
1. Abra la aplicación AWS SCT.

2. Seleccione el modo Data Migration View.
3. Elija la tabla en la que desea configurar la partición virtual. Abra el menú contextual (clic secundario)
de la tabla y seleccione Add Virtual Partitioning.
4. En el cuadro de diálogo Add Virtual Partitioning, introduzca la información, como sigue.
Opción Acción
Partition Type Seleccione RANGE. La interfaz de usuario del cuadro de diálogo cambia
en función del tipo que elija.
Nombre de la columna Seleccione la columna en la que desea realizar la partición.
Version 1.0
164
Uso de particiones virtuales
Opción Acción
Column Type Elija el tipo de datos para los valores en la columna.
Valores Para añadir nuevos valores, escriba cada valor en el cuadro New Value y,
a continuación, elija el signo más para añadir el valor.
Load From File (Opcional) Escriba el nombre de un archivo .csv que contenga valores de
partición.
5. Seleccione OK.
Tipo de partición LIST

El tipo de partición LIST realiza particiones de datos basadas en los valores de la columna para tipos de
datos de fecha y hora, numéricos y caracteres. Este tipo de partición crea una cláusula WHERE y usted
proporciona los valores de cada partición. Especifique una lista de valores para la columna particionada en
el campo Values. Puede cargar información del valor mediante un archivo .csv.
Por ejemplo, puede crear varias particiones basadas en un valor que proporcione. En el siguiente ejemplo,
se especifican los valores de partición para LO_ORDERKEY para crear varias particiones.
Partition1: WHERE LO_ORDERKEY = 1

…
PartitionN: WHERE LO_ORDERKEY = USER_VALUE_N
También puede crear una partición predeterminada para valores no incluidos en los especificados.
Para crear una partición virtual LIST

Opción Acción
Partition Type Elija LIST. La interfaz de usuario del cuadro de diálogo cambia en función
del tipo que elija.
New Value Aquí puede escribir un valor que se añadirá al conjunto de valores de la
partición.
Include Other Values Seleccione esta opción para crear una partición predeterminada en la
que se almacenan todos los valores que no cumplen los criterios de la
partición.
Load From File (Opcional) Escriba el nombre de un archivo .csv que contenga valores de
partición.
5. Seleccione OK.
Version 1.0
165
Trabajo con LOB
Tipo de partición DATE AUTO SPLIT

El tipo de partición DATE AUTO SPLIT, realiza particiones de datos de tipos de datos de fecha y hora
basadas en un intervalo especificado entre una fecha de inicio y una fecha de finalización. Especifique el
rango e intervalo de los datos (día, semana, mes o año). Si no especifica una fecha de inicio o una fecha
de finalización, estos valores adoptan de manera predeterminada a la fecha actual.
Por ejemplo, puede crear varias particiones basadas en un intervalo de fechas que proporcione. En el
siguiente ejemplo, se especifica el intervalo de valores de partición para LO_ORDERDATE para crear
varias particiones.
Partition1: WHERE LO_ORDERDATE >= ‘1954-10-10’ AND LO_ORDERDATE < ‘1954-10-24’

…
PartitionN: WHERE LO_ORDERDATE >= USER_VALUE_N AND LO_ORDERDATE <= ‘2017-08-13’
Para crear una partición virtual DATE AUTO SPLIT

Opción Acción
Partition Type Seleccione DATE AUTO SPLIT. La interfaz de usuario del cuadro de
diálogo cambia en función del tipo que elija.
Fecha de inicio Escriba una fecha de inicio.
Fecha de finalización Escriba una fecha de finalización.
Intervalo Escriba la unidad del intervalo y elija el valor de dicha unidad.
5. Seleccione OK.
Migración de LOBs a Amazon Redshift

Amazon Redshift no admite el almacenamiento de objetos binarios grandes (LOB). Sin embargo, si
necesita migrar uno o varios LOB a Amazon Redshift, la AWS SCT puede realizar la migración. Para ello,
la AWS SCT utiliza un bucket de Amazon S3 para almacenar los LOB y escribe la dirección URL para el
bucket de S3 en los datos migrados almacenados en Amazon Redshift.
Para migrar LOB a Amazon Redshift

2. En Actions, elija Create Local Task.
3. Seleccione la pestaña Advanced.
4. En S3 bucket LOBs folder, escriba el nombre de la carpeta de un bucket de S3 donde desee
almacenar los LOB.
Version 1.0
166
Prácticas recomendadas y solución de problemas
Prácticas recomendadas y solución de problemas de

agentes de extracción de datos
A continuación se indican algunas prácticas recomendadas y sugerencias de resolución de problemas para
el uso de los agentes de extracción.
Problema Sugerencias para la solución de problemas
El desempeño es lento Para mejorar el desempeño, le recomendamos lo siguiente:
• Instale varios agentes.

• Instale agentes en equipos cercanos a su data warehouse.
• No ejecute todas las tablas en una única tarea de agente.
Evite los retrasos Evite tener demasiados agentes que obtengan acceso a su data
warehouse al mismo tiempo.
Un agente deja de funcionar de Si un agente deja de funcionar, el estado de cada una de sus tareas
forma temporal aparecerá como erróneo en la AWS SCT. En algunos casos, el
Version 1.0
167
Migración de datos desde Apache
Cassandra a Amazon DynamoDB
Problema Sugerencias para la solución de problemas

agente puede recuperarse con solo esperar. En este caso, el estado
de sus tareas se actualiza en la AWS SCT.
Un agente deja de funcionar de Si el equipo que ejecuta un agente deja de funcionar de forma
forma permanente permanente, y ese agente está ejecutando una tarea, puede
sustituirlo por un nuevo agente que continúe con la tarea. Solo puede
sustituir un nuevo agente si la carpeta de trabajo del agente original
no se encuentra en el mismo equipo que el agente original. Para
sustituir un nuevo agente, haga lo siguiente:
• Instale un agente en un nuevo equipo.

• Configure el nuevo agente con los mismos ajustes, incluido el
número de puerto y la carpeta de trabajo, que el agente original.
• Comience el agente. Tras iniciar el agente, la tarea descubrirá
al nuevo agente disponible y seguirá ejecutándose en el nuevo
agente.
Migración de datos desde Apache Cassandra a

Amazon DynamoDB
Puede utilizar un agente de extracción de datos de la AWS SCT para extraer datos desde Apache
Cassandra y migrarlos a Amazon DynamoDB. El agente se ejecuta en una instancia Amazon EC2, donde
extrae datos de Cassandra, los escribe en el sistema de archivos local y los carga a un bucket de Amazon
S3. A continuación, puede utilizar la AWS SCT para copiar los datos en DynamoDB.
Amazon DynamoDB es un servicio de base de datos NoSQL. Para almacenar datos en DynamoDB, cree
tablas de base de datos y, a continuación, cargue los datos en dichas tablas. El agente de extracción de
la AWS SCT para Cassandra automatiza el proceso de creación de tablas de DynamoDB que coinciden
con sus homólogas de Cassandra y, a continuación, rellena esas tablas de DynamoDB con datos de
Cassandra.
El proceso de extracción de datos puede añadir una sobrecarga considerable a un clúster de Cassandra.
Por este motivo, no ejecute el agente de extracción directamente con los datos de producción en
Cassandra. Para evitar interferir con las aplicaciones de producción, la AWS SCT le ayuda a crear
un centro de datos clon—, una copia independiente de los datos de Cassandra que desea migrar a
DynamoDB. El agente puede leer los datos del clon y ponerlos a disposición de la AWS SCT, sin que ello
afecte a las aplicaciones de producción.
Cuando se ejecuta el agente de extracción de datos, lee los datos del centro clon y los escribe en un
bucket de Amazon S3. A continuación, AWS SCT lee los datos desde Amazon S3 y los escribe en Amazon
DynamoDB.
En el siguiente diagrama se muestra la situación admitida:
Version 1.0
168
Migración de datos desde Apache
Cassandra a Amazon DynamoDB
Si no está familiarizado con Cassandra, tenga en cuenta la siguiente terminología importante:
• Un nodo es un equipo único (físico o virtual) que ejecuta el software de Cassandra.

• Un servidor es una entidad lógica que consta de hasta 256 nodos.
• Un bastidor representa uno o varios servidores.
• Un centro de datos es un conjunto de bastidores.
• Un clúster es un conjunto de centros de datos.
Para obtener más información, consulte la página de Wikipedia de Apache Cassandra.
Version 1.0
169
Requisitos previos para migración
desde Cassandra a DynamoDB
Utilice la información de los temas siguientes para aprender a migrar datos desde Apache Cassandra a
Amazon DynamoDB:
Temas
• Requisitos previos para migración desde Cassandra a DynamoDB (p. 170)
• Crear un nuevo proyecto de AWS SCT (p. 172)
• Crear un centro de datos clon (p. 175)
• Instalar, configurar y ejecutar el agente de extracción de datos (p. 181)
• Migrar datos desde el centro de datos clon a Amazon DynamoDB (p. 185)
• Actividades posteriores a la migración (p. 189)
Requisitos previos para migración desde Cassandra a

DynamoDB
Antes de comenzar, tendrá que llevar a cabo varias tareas previas a la migración, tal y como se describe
en esta sección.
Compatibilidad con versiones de Cassandra

AWS SCT admite las siguientes versiones de Apache Cassandra:
• 3.11.2
• 3.1.1
• 3.0
• 2.2
• 2.1.20 o posterior
No admite otras versiones de Cassandra.
Configuración de Amazon S3
Cuando se ejecuta el agente de extracción de datos de AWS SCT, este lee datos desde su centro de datos
clon y los escribe en un bucket de Amazon S3. Antes de continuar, debe proporcionar las credenciales
para conectarse a su cuenta de AWS y a su bucket de Amazon S3. Puede almacenar la información de
sus credenciales y su bucket en un perfil en la configuración de la aplicación global y, a continuación,
asociar el perfil con su proyecto de AWS SCT. Si fuera necesario, seleccione Global Settings para crear
un nuevo perfil. Para obtener más información, consulte Uso de los perfiles del servicio de AWS en la
Instancia Amazon EC2 para centro de datos clon

Como parte del proceso de migración, tendrá que crear un clon de un centro de datos de Cassandra
existente. Este clon se ejecutará en una instancia Amazon EC2 que aprovisionará de antemano. La
instancia ejecutará una instalación de Cassandra independiente, para alojar su centro de centro clon de
manera independiente al centro de datos de Cassandra existente.
La nueva instancia Amazon EC2 debe cumplir los siguientes requisitos:
• Sistema operativo: Ubuntu o CentOS.

• Debe tener Java JDK 8 instalado. (No se admiten otras versiones).
Version 1.0
170
Requisitos previos para migración
desde Cassandra a DynamoDB
Para lanzar una nueva instancia, vaya a la consola de administración de Amazon EC2 en https://
console.aws.amazon.com/ec2/.
Configuración de seguridad
AWS SCT se comunica con el agente de extracción de datos mediante la capa de conexión segura (SSL).
Para habilitar la SSL, configure un almacén de confianza y un almacén de claves:
1. Lance AWS SCT.

2. En el menú Settings (Configuración), elija Global Settings (Configuración global).
3. Seleccione la pestaña Security (Seguridad) como se muestra a continuación:
4. Seleccione Generate Trust and Key Store o haga clic en Select existing Trust and Key Store.
Si selecciona Generate Trust and Key Store, a continuación tendrá que especificar el nombre y
la contraseña de los almacenes de confianza y de claves y la ruta a la ubicación de los archivos
generados. Utilizará estos archivos en pasos posteriores.
Si selecciona Select existing Trust and Key Store, después especificará la contraseña y el nombre del
archivo para los almacenes de confianza y de claves. Utilizará estos archivos en pasos posteriores.
5. Tras haber especificado el almacén de confianza y el almacén de claves, seleccione OK para cerrar el
cuadro de diálogo Global Settings.
Version 1.0
171
Crear un nuevo proyecto de AWS SCT

Una vez que haya realizado los pasos que se describen en Requisitos previos para migración desde
Cassandra a DynamoDB (p. 170), ya está listo para crear un nuevo proyecto de AWS SCT para su
migración. Sigue estos pasos:
1. En el menú File (Archivo), elija New project (Nuevo proyecto).
Añada la información siguiente:

Base de datos NoSQL Seleccione NoSQL database (Base de datos NoSQL).
Source Database Engine (Motor de Elija Cassandra.

base de datos de origen)
Version 1.0
172
Target database engine (Motor de Elija Amazon DynamoDB.

base de datos de destino)
Elija OK (Aceptar) para crear su proyecto de AWS SCT.

2. En la barra de menú, seleccione Connect to Cassandra (Conectar a Cassandra).
Server name Escriba el nombre de host o la dirección IP de su clúster

de Cassandra.
Server port Escriba el número de puerto donde Cassandra escucha las

solicitudes de conexión. Por ejemplo: 9042
Nombre de usuario Escriba un nombre de usuario válido para conectarse al

clúster de Cassandra.
Version 1.0
173
Contraseña Escriba la contraseña asociada con el nombre de usuario.
3. Seleccione OK (Aceptar). AWS SCT prueba la conexión para asegurarse de que puede obtener
acceso a su clúster de Cassandra.
4. En la barra de menú, seleccione Connect to Amazon DynamoDB (Conectar a Amazon DynamoDB).
Copy from AWS profile (Copiar desde Si ya ha configurado las credenciales de AWS, elija el
perfil de AWS) nombre de un perfil existente.
AWS access key (Clave de acceso de Escriba la clave de acceso de AWS.

AWS)
Clave secreta de AWS Escriba la clave secreta asociada a su clave de acceso de

AWS.
Región Elija una región de AWS. AWS SCT migrará los datos a
Amazon DynamoDB en esa región.
5. Seleccione OK (Aceptar). AWS SCT prueba la conexión para asegurarse de que puede obtener
acceso a DynamoDB.
Version 1.0
174
Crear un centro de datos clon

Para evitar interferir con las aplicaciones de producción que utilizan su clúster de Cassandra, AWS SCT
creará un centro de datos clon y copiará los datos de producción en él. El centro de datos clon funciona
como un área de ensayo, de modo que AWS SCT puede realizar más actividades de migración mediante
el clon en lugar de hacerlo en el centro de producción.
Para comenzar el proceso de clonación, siga este procedimiento:
1. En la ventana de AWS SCT, en el lado izquierdo (origen), expanda el nodo Datacenters (Centros de
datos) y elija uno de los centros de datos de Cassandra existentes.
2. Desde el menú Actions (Acciones), elija Clone Datacenter for Extract (Clonar centro de datos para
extraer).
Version 1.0
175
Version 1.0
176
3. Lea el texto de introducción y, a continuación, seleccione Next (Siguiente) para continuar.

4. En la ventana Clone Datacenter for Extract (Clonar centro de datos para extraer), añada la información
siguiente:
Private IP:SSH port (IP privada:puerto Escriba la dirección IP privada y el puerto SSH de
SSH) cualquiera de los nodos en su clúster de Cassandra. Por
ejemplo: 172.28.37.102:22
Public IP:SSH port (IP pública:puerto Escriba la dirección IP pública y puerto SSH para el nodo.
SSH) Por ejemplo: 41.184.48.27:22
OS User (Usuario de SO) Escriba un nombre de usuario válido para conectarse al

nodo.
OS Password (Contraseña SO) Escriba la contraseña asociada con el nombre de usuario.
Key path (Ruta de clave) Si tiene una clave privada SSH (archivo .pem) para este
nodo, elija Browse (Examinar) para ir a la ubicación donde
se almacena la clave privada.
Passphrase (Contraseña) Si su clave privada de SSH está protegida mediante una

contraseña, escríbala aquí.
Usuario de JMX Escriba el nombre de usuario de JMX para acceder a su

clúster de Cassandra.
JMX password (Contraseña de JMX) Escriba la contraseña del usuario de JMX.
Elija Next (Siguiente) para continuar. AWS SCT se conecta al nodo de Cassandra, donde ejecuta el
comando nodetool status.
5. En la ventana Source Cluster Parameters (Parámetros del clúster de origen), acepte los valores
predeterminados y elija Next (Siguiente) para continuar.
6. En la ventana Node Parameters (Parámetros de nodo), verifique los detalles de conexión de todos los
nodos en el clúster de origen. AWS SCT rellenará algunos de estos detalles de forma automática; sin
embargo, debe proporcionar cualquier información que falte.
Note
En lugar de introducir todos los datos aquí, puede cargarlos de forma masiva en su lugar.
Para ello, elija Export (Exportar) para crear un archivo .csv. A continuación, puede editar este
archivo, añadiendo una nueva línea para cada nodo del clúster. Cuando haya terminado,
seleccione Upload (Cargar). AWS SCT leerá el archivo .csv y lo utilizará para rellenar la
ventana Node parameters (Parámetros de nodo).
Elija Next (Siguiente) para continuar. AWS SCT verifica que la configuración del nodo es válida.
7. En la ventana Configure Target Datacenter (Configurar centro de datos de destino), revise los
valores predeterminados. En particular, anote el campo Datacenter suffix (Sufijo de centro de datos):
cuando AWS SCT crea el centro de datos clon, se nombrará del mismo modo que el centro de
datos de origen, pero con el sufijo que proporcione. Por ejemplo, si el centro de datos de origen
se denomina my_datacenter, entonces un sufijo de _tgt haría que el clon se denominara
my_datacenter_tgt.
8. Aún en la ventana Configure Target Datacenter (Configurar centro de datos de destino), elija Add new
node (Añadir nuevo nodo):
Version 1.0
177
Version 1.0
178
9. En la ventana Add New Node (Añadir nuevo nodo), añada la información necesaria para conectar a la
instancia Amazon EC2 que creó en Instancia Amazon EC2 para centro de datos clon (p. 170).
Cuando la configuración sea la que desea, elija Next (Siguiente). El nodo aparece en la lista:
Version 1.0
179
Version 1.0
180
Instalar, configurar y ejecutar el
agente de extracción de datos
10. Elija Next para continuar. Aparecerá el siguiente cuadro de confirmación:
Elija OK (Aceptar) para continuar. AWS SCT reinicia el centro de datos de origen, un nodo cada vez.
11. Revise la información en la ventana Datacenter Synchronization (Sincronización del centro de datos).
Si el clúster está ejecutando Cassandra versión 2, entonces AWS SCT copia todos los datos al centro
de datos clon. Si el clúster está ejecutando Cassandra versión 3, entonces puede elegir los espacios
clave que desea copiar al centro de datos clon.
12. Cuando esté listo para empezar a replicar datos a su centro de clonación, seleccione Start (Inicio).
La replicación de datos comenzará de inmediato. AWS SCT muestra una barra de progreso para que
pueda monitorear el proceso de replicación. Tenga en cuenta que la replicación puede tardar mucho
tiempo, en función de la cantidad de datos que haya en el centro de datos de origen. Si necesita
cancelar la operación antes de que se haya completado, seleccione Cancel (Cancelar).
Cuando la replicación se haya completado, seleccione Next (Siguiente) para continuar.

13. En la ventana Summary (Resumen), AWS SCT muestra un informe que muestra el estado de su
clúster de Cassandra, junto con los siguientes pasos.
Revise la información en este informe y, a continuación, elija Finish (Finalizar) para completar el
asistente.
Instalar, configurar y ejecutar el agente de extracción

de datos
Ahora que tiene un clon de su centro de datos, está listo para comenzar a utilizar el agente de extracción
de datos de AWS SCT para Cassandra. Este agente está disponible como parte de la distribución de AWS
SCT (para obtener más información, consulte Instalación, verificación y actualización de Herramienta de
conversión de esquemas de AWS (p. 4)).
Note
Le recomendamos que ejecute el agente en una instancia Amazon EC2. La instancia EC2 debe
cumplir los siguientes requisitos:
• Sistema operativo: Ubuntu o CentOS.

• 8 CPU virtuales, como mínimo.
• Al menos 16 GB de RAM.
Version 1.0
181
Si aún no tiene una instancia Amazon EC2 que cumpla estos requisitos, vaya a la consola de
administración Amazon EC2 (https://console.aws.amazon.com/ec2/) y lance una nueva instancia
antes de continuar.
Siga este procedimiento para instalar, configurar y ejecutar el agente de extracción de datos de AWS SCT
para Cassandra:
1. Inicie sesión en la instancia Amazon EC2.

2. Compruebe que está ejecutando Java 1.8.x:
java -version
3. Instale el paquete sshfs:
sudo yum install sshfs
4. Instale el paquete expect:
sudo yum install expect
5. Edite el archivo /etc/fuse.conf y quite el comentario de la cadena user_allow_other:
# mount_max = 1000
user_allow_other
6. El agente de extracción de datos de AWS SCT para Cassandra está disponible como parte de
la distribución de AWS SCT (para obtener más información, consulte Instalación, verificación y
actualización de Herramienta de conversión de esquemas de AWS (p. 4)). Puede encontrar el agente
en el archivo .zip que contiene el archivo del instalador de AWS SCT, en el directorio agents. Están
disponibles las siguientes compilaciones del agente:
Nombre de archivo Sistema operativo
aws-cassandra-extractor-n.n.n.deb Ubuntu
aws-cassandra-extractor-n.n.n.x86_64.rpm CentOS
Elija el archivo que sea adecuado para su instancia Amazon EC2. Use la utilidad scp para cargar ese
archivo en la instancia Amazon EC2.
7. Instale el agente de extracción de datos de AWS SCT para Cassandra. (Reemplace n.n.n por el
número de compilación).
• Para Ubuntu:
sudo dpkg -i aws-cassandra-extractor-n.n.n.deb
• Para CentOS:
sudo yum install aws-cassandra-extractor-n.n.n.x86_64.rpm
Version 1.0
182
Durante el proceso de instalación, se le pedirá que seleccione la versión Cassandra que desea usar.
Elija la versión 3 o 2, según corresponda.
8. Una vez que la instalación se haya completado, revise los directorios siguientes para asegurarse de
que se han creado correctamente:
• /var/log/cassandra-data-extractor/—: para los registros del agente de extracción.

• /mnt/cassandra-data-extractor/—: para montaje de carpetas de inicio y datos.
• /etc/cassandra-data-extractor/—: para el archivo de configuración del agente (agent-
settings.yaml).
9. Para habilitar el agente para comunicarse con AWS SCT, debe disponer de un almacén de claves y un
almacén de confianza disponible. (Los crea en Configuración de seguridad (p. 171)). Use la utilidad
scp para cargar estos archivos en su instancia Amazon EC2.
La utilidad de configuración (vea el paso siguiente) requiere especificar el almacén de claves y el

almacén de confianza, por tanto necesita que estén disponibles.
10. Ejecute la utilidad de configuración:
sudo java -jar /usr/share/aws-cassandra-extractor/aws-cassandra-extractor.jar --

configure
La utilidad le pedirá varios valores de configuración. Puede utilizar el siguiente ejemplo como guía,
reemplazando los valores por los suyos propios:
Enter the number of data providers nodes [1]: 1

Enter IP for Cassandra node 1: 34.220.73.140
Enter SSH port for Cassandra node <34.220.73.140> [22]: 22
Enter SSH login for Cassandra node <34.220.73.140> : centos
Enter SSH password for Cassandra node <34.220.73.140> (optional):
Is the connection to the node using a SSH private key? Y/N [N] : Y
Enter the path to the private SSH key for Cassandra node <34.220.73.140>: /home/centos/
my-ec2-private-key.pem
Enter passphrase for SSH private key for Cassandra node <34.220.73.140> (optional):
Enter the path to the cassandra.yaml file location on the node <34.220.73.140>: /etc/
cassandra/conf/
Enter the path to the Cassandra data directories on the node <34.220.73.140>: /u01/
cassandra/data
===== Mounting process started =====
Node [34.220.73.140] mounting started.
Will be executed command:
sudo sshfs ubuntu@34.220.73.140:/etc/cassandra/ /mnt/aws-cassandra-data-
extractor/34.220.73.140_node/conf/ -p 22 -o allow_other -o StrictHostKeyChecking=no
-o IdentityFile=/home/ubuntu/dbbest-ec2-oregon_s.pem > /var/log/aws-cassandra-data-
extractor/dmt-cassandra-v3/conf_34.220.73.140.log 2>&1
Will be executed command:
sudo sshfs ubuntu@34.220.73.140:/u01/cassandra/data/ /mnt/aws-cassandra-data-
extractor/34.220.73.140_node/data/data -p 22 -o allow_other -o StrictHostKeyChecking=no
-o IdentityFile=/home/ubuntu/dbbest-ec2-oregon_s.pem > /var/log/aws-cassandra-data-
extractor/dmt-cassandra-v3/data_34.220.73.140.log 2>&1
===== Mounting process was over =====
Enable SSL communication Y/N [N] : Y
Path to key store: /home/centos/Cassandra_key
Key store password:123456
Re-enter the key store password:123456
Path to trust store: /home/centos/Cassandra_trust
Trust store password:123456
Re-enter the trust store password:123456
Enter the path to the output local folder: /home/centos/out_data
Version 1.0
183
=== Configuration aws-agent-settings.yaml successful completed ===

If you want to add new nodes or change it parameters, you should edit the configuration
file /etc/aws-cassandra-data-extractor/dmt-cassandra-v3/aws-agent-settings.yaml
Note
Cuando la utilidad de configuración se ha completado, es posible que aparezca el siguiente

mensaje:
Change the SSH private keys permission to 600 to secure them. You can
also set permissions to 400.
Puede utilizar el comando chmod para cambiar los permisos, tal y como se muestra en este
ejemplo:
chmod 400 /home/centos/my-ec2-private-key.pem
11. Una vez que se completa la utilidad de configuración, revise los siguientes directorios y archivos:
• /etc/cassandra-data-extractor/agent-settings.yaml—: el archivo de configuración

para el agente.
• $HOME/out_data—: un directorio para los archivos de resultado de la extracción.
• /mnt/cassandra-data-extractor/34.220.73.140_node/conf—: una carpeta de inicio de
Cassandra vacía. (Reemplace 34.220.73.140 por su dirección IP real).
• /mnt/cassandra-data-extractor/34.220.73.140_node/data/data—: un archivo de
datos de Cassandra vacío. (Reemplace 34.220.73.140 por su dirección IP real).
Si estos directorios no están montados, utilice el siguiente comando para montarlos:
sudo java -jar /usr/share/aws-cassandra-extractor/aws-cassandra-extractor.jar -mnt
12. Monte los directorios de inicio y de datos de Cassandra:
sudo java -jusr/share/cassandra-extractor/rest-extraction-service.jar -mnt
Una vez que el proceso de montaje está completo, revise la carpeta de inicio de Cassandra y el
directorio del archivo de datos de Cassandra como se muestra en el ejemplo siguiente. (Reemplace
34.220.73.140 por su dirección IP real).
ls -l /mnt/cassandra-data-extractor/34.220.73.140_node/conf
ls -l /mnt/cassandra-data-extractor/34.220.73.140_node/data/data
13. Inicie el agente de extracción de datos de AWS SCT para Cassandra:
sudo systemctl start aws-cassandra-extractor
Note
De forma predeterminada, el agente se ejecuta en el puerto 8080. Puede cambiarlo editando

el archivo agent-settings.yaml.
Version 1.0
184
Migrar datos desde el centro de
datos clon a Amazon DynamoDB
Migrar datos desde el centro de datos clon a Amazon

DynamoDB
Ahora está listo para realizar la migración desde el centro de datos clon a Amazon DynamoDB, utilizando
AWS SCT. AWS SCT administra los flujos de trabajo entre el agente de extracción de datos de AWS SCT
para Cassandra, AWS Database Migration Service (AWS DMS) y DynamoDB. El proceso de migración
se realiza por completo dentro de la interfaz de AWS SCT y AWS SCT administra todos los componentes
externos en su nombre.
Para migrar sus datos, siga este procedimiento:
1. Desde el menú View (Ver), elija Data migration view (Vista de migración de datos).
2. Elija la pestaña Agents (Agentes).
3. Si no ha registrado aún el agente de extracción de datos de AWS SCT, verá el siguiente mensaje:
Elija Register.
4. En la ventana New agent registration (Registro de nuevo agente), añada la información siguiente:
Descripción Escriba una breve descripción para este agente.
Host name Escriba el nombre de host de la instancia Amazon EC2

que usó para Instalar, configurar y ejecutar el agente de
extracción de datos (p. 181)
Puerto Escriba el número de puerto para el agente. (El número de

puerto predeterminado es 8080).
Contraseña Si utiliza SSL, deje este campo en blanco; de lo contrario,

escriba la contraseña para registrarse en el host.
Use SSL Si utiliza SSL, elija esta opción para activar la pestaña
SSL.
Si utiliza SSL, elija la pestaña SSL y añada la siguiente información:
Trust store (Almacén de confianza) Elija el almacén de confianza que haya configurado en
Instalar, configurar y ejecutar el agente de extracción de
datos (p. 181).
Version 1.0
185
Key store (Almacén de claves) Elija el almacén de claves que haya configurado en
Instalar, configurar y ejecutar el agente de extracción de
datos (p. 181).
Cuando la configuración sea la que desea, elija Register (Registrar). AWS SCT intenta conectar con el
agente de extracción de datos de AWS SCT para Cassandra.
5. En el lado izquierdo de la ventana AWS SCT, elija el centro de datos de Cassandra que ha creado en
Crear un centro de datos clon (p. 175).
6. En la menú Actions (Acciones), elija Create Local & DMS Task (Crear tarea local y DMS).
7. En la ventana Create Local & DMS Task (Crear tarea local y DMS), introduzca la información
siguiente:
Task name Escriba un nombre abreviado para la tarea de AWS DMS

que se va a crear.
Instancia de replicación Elija la instancia de replicación de AWS DMS que desea

usar.
Migration type Seleccione la opción Migrate existing data and replication

ongoing changes (Migrar datos existentes y cambios
de replicación en curso). Esto migrará las tablas en su
centro de datos clon de Cassandra a DynamoDB y, a
continuación, captura todos los cambios en curso. Este
proceso se denomina carga completa y CDC en AWS
DMS.
Target table preparation mode Si ya tiene tablas correspondientes en DynamoDB y desea

eliminarlas antes de la migración, elija Drop tables on
target (Borrar tablas en el destino). De lo contrario, deje la
configuración en su valor predeterminado [Do nothing (No
hacer nada)].
Rol de IAM Elija la función de IAM predefinida que tiene permisos

para acceder al bucket de Amazon S3 y a la base de
datos de destino (Amazon DynamoDB). Para obtener
más información acerca de los permisos necesarios para
acceder a un bucket de Amazon S3, consulte
Cuando se ejecuta el agente de extracción de datos

de AWS SCT, este lee datos desde su centro de datos
clon y los escribe en un bucket de Amazon S3. Antes
de continuar, debe proporcionar las credenciales para
conectarse a su cuenta de AWS y a su bucket de Amazon
S3. Puede almacenar la información de sus credenciales y
su bucket en un perfil en la configuración de la aplicación
global y, a continuación, asociar el perfil con su proyecto
de AWS SCT. Si fuera necesario, seleccione Global
Settings para crear un nuevo perfil. Para obtener más
información, consulte Uso de los perfiles del servicio de
AWS en la Herramienta de conversión de esquemas de
AWS (p. 13).
Version 1.0
186

(p. 170).
Logging level (Nivel de registro) Elija un nivel de registro adecuado para la tarea de
migración.
Descripción Escriba una descripción para la tarea.
Cifrado de datos Elija Enable (Habilitar) o Disable (Deshabilitar).
Delete files from the local directory Elija esta opción para eliminar archivos de datos desde el
(Eliminar archivos del directorio local) directorio local del agente después de cargar los archivos
a Amazon S3.
S3 bucket Escriba el nombre de un bucket de Amazon S3 para el que

tiene privilegios de escritura.
Cuando esté conforme con los ajustes, elija Create.

8. Elija la pestaña Tasks (Tareas), donde debería ver la tarea que ha creado. Para iniciar la tarea,
seleccione Start (Inicio).
Puede monitorear el progreso de las tareas, tal y como se muestra en la siguiente captura de pantalla:
Version 1.0
187
Version 1.0
188
Actividades posteriores a la migración
Actividades posteriores a la migración

Si ha terminado con la migración y desea eliminar la tarea de migración, haga lo siguiente:
1. Elija la pestaña Tasks.

2. Si la tarea se está ejecutando en este momento, elija Stop (Detener).
3. Para eliminar la tarea, seleccione Delete (Eliminar).
Si ya no tiene que utiliza el agente de extracción de datos de AWS SCT para Cassandra, haga lo siguiente:
1. Elija la pestaña Agents (Agentes).

2. Elija el agente que ya no necesite.
3. Seleccione Unregister (Anular el registro).
Version 1.0
189
Información general de la conversión de SQL de aplicación
Conversión de SQL de aplicación

con la Herramienta de conversión de
esquemas de AWS
Al convertir su esquema de base de datos de un motor a otro, también deberá actualizar el código SQL de
sus aplicaciones para interactuar con el nuevo motor de base de datos en lugar del antiguo. Puede ver,
analizar, editar y guardar el código SQL convertido.
Puede utilizar la Herramienta de conversión de esquemas de AWS (AWS SCT) para convertir el código
SQL en código C++, C #, Java u otro tipo de código de su aplicación. En el caso de una conversión de
Oracle a PostgreSQL, puede utilizar AWS SCT para convertir el código de SQL*Plus a PSQL.
Información general de la conversión de SQL de

aplicación
Para convertir el código SQL de su aplicación, siga estos pasos de alto nivel:
• Crear un proyecto de conversión de aplicación: – el proyecto de conversión de la aplicación es

secundario al proyecto de conversión del esquema de la base de datos. Cada proyecto de conversión
de esquema de base de datos puede tener uno o varios proyectos de conversión de aplicaciones
secundarios. Para obtener más información, consulte Creación de proyectos de conversión de
aplicaciones en la Herramienta de conversión de esquemas de AWS (p. 190).
• Analizar y convertir su código SQL: – la AWS SCT analiza su aplicación, extrae el código SQL y crea
una versión local del SQL convertido para que pueda analizarlo y editarlo. La herramienta no cambia
el código en su aplicación hasta que esté listo. Para obtener más información, consulte Análisis y
conversión de su código SQL mediante el uso de la Herramienta de conversión de esquemas de
AWS (p. 193).
• Crear un informe de evaluación de la aplicación: – el informe de evaluación de la aplicación proporciona
información importante sobre la conversión del código SQL de la aplicación desde el esquema de la
base de datos de origen al esquema de la base de datos de destino. Para obtener más información,
consulte Creación y uso del informe de evaluación (p. 194).
• Editar, aplicar los cambios y guardar el código SQL convertido: – el informe de evaluación incluye una
lista de elementos de código SQL que no se pueden convertir automáticamente. Para estos elementos,
puede editar el código SQL manualmente para realizar la conversión. Para obtener más información,
consulte Edición y guardado del código SQL convertido con la Herramienta de conversión de esquemas
de AWS (p. 195).
Creación de proyectos de conversión de

aplicaciones en la Herramienta de conversión de
esquemas de AWS
En la Herramienta de conversión de esquemas de AWS, el proyecto de conversión de la aplicación es
secundario al proyecto de conversión del esquema de la base de datos. Cada proyecto de conversión
Version 1.0
190
Creación de proyectos de conversión de aplicaciones
de esquema de base de datos puede tener uno o varios proyectos de conversión de aplicaciones
secundarios. Utilice el siguiente procedimiento para crear un proyecto de conversión de aplicación.
Para crear un proyecto de conversión de aplicación
1. En la Herramienta de conversión de esquemas de AWS, seleccione New Aplication (Nueva aplicación)

desde el menú Applications (Aplicaciones).
Aparecerá el cuadro de diálogo New application conversion project.
2. Agregue la siguiente información del proyecto.
Application Project Name Escriba un nombre para el proyecto de conversión de la

aplicación. Cada proyecto de conversión de esquemas de bases
de datos puede tener uno o varios proyectos secundarios de
Version 1.0
191
Creación de proyectos de conversión de aplicaciones

conversión de aplicaciones, por lo que deberá elegir un nombre
significativo si va a agregar más proyectos posteriormente.
Ubicación Escriba la ubicación del código fuente de su aplicación.
Project language Elija una de las siguientes opciones:
• JAVA
• C++
• C#
• Cualquiera
SQL parameter style for target Elija una de las siguientes opciones:
database
• Same as in source
• Positional (?)
• Indexed (:1)
• Indexed ($1)
• Named (@name)
• Named (:name)
Select source database schema En el árbol de origen, elija el esquema utilizado por el código de la
aplicación.
3. Seleccione OK para crear su proyecto de conversión de la aplicación.
Se abrirá la ventana de proyecto.
4. La primera vez que cree un proyecto de conversión de aplicaciones, la ventana de proyecto se abrirá
automáticamente. Para abrir un proyecto de conversión de aplicaciones existente, seleccione el nodo
de proyecto en el árbol de origen, abra el menú contextual (clic secundario) y seleccione Manage
application.
Version 1.0
192
Análisis y conversión de su código SQL
5. Puede agregar proyectos de conversión de aplicaciones adicionales si selecciona New Application

desde el menú Applications o seleccionando el nodo Applications en el árbol de origen, abriendo el
menú contextual (clic con el botón secundario) y seleccionando Add application.
Análisis y conversión de su código SQL mediante el

uso de la Herramienta de conversión de esquemas
de AWS
Utilice el siguiente procedimiento para analizar y convertir su código SQL mediante la Herramienta de
Para analizar y convertir su código SQL
1. En el proyecto de conversión de aplicaciones, seleccione Analyze.
La AWS SCT analiza el código de su aplicación y extrae el código SQL. Una lista del código SQL
extraído aparecerá en el panel Parsed SQL Scripts en la parte inferior de la ventana. El elemento
seleccionado en la lista también aparecerá en el panel Extracted SQL script.
2. Puede analizar todos los elementos del código SQL de la lista y, cuando esté listo, seleccionar
Convert para convertir el SQL a SQL para su base de datos de destino.
Note
Puede editar el código SQL convertido en otro procedimiento posterior.
Version 1.0
193
Creación y uso del informe de evaluación
Creación y uso del informe de evaluación

El informe de evaluación de la aplicación proporciona información importante sobre la conversión del
código SQL de la aplicación desde su esquema de base de datos de origen a su esquema de base de
datos de destino. En el informe se detalla todo el código SQL extraído de la aplicación, todo el SQL
convertido, y los elementos de acción en SQL que no se han podido convertir. El informe incluye también
estimaciones de la cantidad de esfuerzo necesario para convertir manualmente el código SQL que no se
pudo convertir automáticamente.
Creación de un informe de evaluación de la aplicación

Utilice el siguiente procedimiento para crear un informe de evaluación de la aplicación.
Para crear un informe de evaluación de la aplicación
1. En la ventana del proyecto de conversión de la aplicación, seleccione Create Report en el menú

Actions.
El informe se creará y se abrirá en la ventana del proyecto de conversión de la aplicación.

2. Analice la pestaña Summary.
En la pestaña Summary que se muestra a continuación aparece la información resumida del informe
de evaluación de la aplicación. Muestra los elementos del código SQL que se hayan convertido
automáticamente y los elementos que no se hayan convertido automáticamente.
Version 1.0
194
Edición y guardado de su código SQL convertido
3. Seleccione la pestaña SQL Conversion Actions y analice la información.
La pestaña SQL Conversion Actions contiene una lista de elementos de código SQL que no se pueden
convertir automáticamente. También hay recomendaciones sobre cómo convertir manualmente
el código SQL. Puede editar el código SQL convertido en un paso posterior. Para obtener más
información, consulte Edición y guardado del código SQL convertido con la Herramienta de
4. Puede guardar una copia local del informe de evaluación de la aplicación en formato PDF o como
un archivo de valores separados por comas (CSV). El archivo PDF contiene tanto el resumen como
información de elementos de acción. El archivo CSV contiene solamente información de elementos de
acción.
Edición y guardado del código SQL convertido con

la Herramienta de conversión de esquemas de
AWS
El informe de evaluación incluye una lista de elementos de código SQL que no se pueden convertir
automáticamente. Para cada elemento que no se puede convertir, hay un elemento de acción en la
pestaña SQL Conversion Actions. Para estos elementos, puede editar el código SQL manualmente para
realizar la conversión.
Utilice el siguiente procedimiento para editar su código SQL convertido, aplique los cambios y, a
continuación, guárdelos.
Para editar, aplicar cambios y guardar su código SQL convertido
1. Edite su código SQL convertido directamente en el panel Target SQL script. Si no se muestra ningún
código convertido, puede hacer clic en el panel y empezar a escribir.
2. Una vez que haya terminado de editar su código SQL convertido, seleccione Apply. En este punto, los
cambios se guardan en memoria, pero aún no se escriben en el archivo.
3. Seleccione Save para guardar los cambios en su archivo.
Important
Al seleccionar Save, sobrescribirá su archivo original. Realice una copia de su archivo original
antes de guardar, a fin de que disponga de un registro de su código de aplicación original.
Version 1.0
195
Uso del paquete de extensión de

la Herramienta de conversión de
esquemas de AWS
El paquete de extensión de la AWS SCT es un módulo complementario que simula funciones presentes en
la base de datos de origen que son necesarias a la hora de convertir objetos a la base de datos de destino.
Antes de poder instalar el paquete de extensión de la AWS SCT, debe convertir su esquema de base de
datos.
El paquete de extensión de la AWS SCT incluye los siguientes componentes:
• Esquema de la – base de datos: Incluye procedimientos, tablas y funciones SQL para simular algunos
objetos OLTP y OLAP (por ejemplo, secuencia) o funciones integradas no admitidas de la base de datos
de origen. Este esquema se nombra en el formato aws_<database engine name>_ext.
• Biblioteca de Python personalizada (para algunas bases de datos OLAP): – Incluye un conjunto de
funciones de Python que simulan funciones de la base de datos integradas no admitidas. Utilice esta
biblioteca al migrar desde una de las bases de datos admitidos a Amazon Redshift.
Para obtener más información sobre esta biblioteca, consulte Uso de la biblioteca de Python
personalizada para el paquete de extensión de la AWS SCT (p. 197).
• Funciones de AWS Lambda (para algunas bases de datos OLTP): Incluye funciones de – que simulan
AWS Lambda funcionalidades de la base de datos complejas, como programación del trabajo y envío de
correos electrónicos.
En las siguientes secciones se explica el paquete de extensión de la AWS SCT.
Temas
• Uso del esquema del paquete de extensión (p. 197)
• Uso de la biblioteca de Python personalizada para el paquete de extensión de la AWS SCT (p. 197)
• Uso de las funciones de AWS Lambda del paquete de extensión AWS SCT (p. 199)
Puede aplicar el paquete de extensión de la AWS SCT de dos formas:
• La AWS SCT aplica automáticamente el paquete de extensión cuando usted aplica un script de base de
datos de destino al elegir ApplyToTarget desde el menú contextual. La AWS SCT aplica el paquete de
extensión antes de que aplicar el resto de objetos del esquema.
• Para aplicar manualmente el paquete de extensión, seleccione la base de datos de destino y, a
continuación, elija Apply Extension Pack desde el menú contextual. La aplicación automática es
suficiente para la mayoría de las situaciones. Sin embargo, es posible que desee aplicar el paquete si se
elimina accidentalmente.
Cada vez que se aplica el paquete de extensión de la AWS SCT a un almacén de datos de destino, los
componentes se sobrescriben. Cada componente tiene un número de versión y la AWS SCT le avisa si la
versión del componente actual es anterior a la versión que se aplica. Puede controlar estas notificaciones
en Notification Settings en la sección Global Settings de Settings.
Version 1.0
196
Uso del esquema de base de
datos del paquete de extensión
Uso del esquema del paquete de extensión

Al convertir su esquema de almacén de datos o base de datos, la AWS SCT añade un esquema adicional
a su base de datos de destino. Este esquema implementa las funciones del sistema SQL de la base de
datos de origen que son necesarias al escribir su esquema convertido en la base de datos de destino. El
esquema adicional se denomina esquema del paquete de extensión.
El esquema del paquete de extensión para bases de datos OLTP se nombra en función a la base de datos
de origen, de la siguiente manera:

• MySQL: AWS_MYSQL_EXT
• PostgreSQL: AWS_POSTGRESQL_EXT
El esquema del paquete de extensión para aplicaciones data warehouse OLAP se nombra en función del
almacén de base de datos de origen, de la siguiente manera:
• Greenplum: AWS_GREENPLUM_EXT
• Netezza: AWS_NETEZZA_EXT
• Teradata: AWS_TERADATA_EXT
• Vertica: AWS_VERTICA_EXT
Uso de la biblioteca de Python personalizada para

el paquete de extensión de la AWS SCT
En algunos casos, Herramienta de conversión de esquemas de AWS no puede convertir características de
base de datos de origen a características de Amazon Redshift equivalentes. El paquete de extensión de la
AWS SCT contiene una biblioteca de Python personalizada que simula algunas funcionalidades de la base
de datos de origen en Amazon Redshift.
Si va a convertir una base de datos transaccional, consulte Uso de las funciones de AWS Lambda del
paquete de extensión AWS SCT (p. 199).
Hay dos casos en los que podría querer instalar el paquete de extensión a mano:
• Si elimina accidentalmente el esquema del paquete de extensión de su base de datos de destino.

• Si quiere cargar bibliotecas de Python personalizadas para emular una funcionalidad de base de datos.
Uso de AWS Services para cargar bibliotecas de

Python personalizadas
El asistente del paquete de extensión de la AWS SCT le ayuda a instalar la biblioteca de Python
personalizada.
Version 1.0
197
Aplicación del paquete de extensión

Utilice el siguiente procedimiento para aplicar el paquete de extensión.
Para aplicar el paquete de extensión
1. En la Herramienta de conversión de esquemas de AWS, en el árbol de la base de datos de destino,

abra el menú contextual (clic secundario) y seleccione Apply Extension Pack (Aplicar paquete de
extensión).
Aparecerá el asistente de paquete de extensión.

2. Lea la página Welcome y seleccione Next.
3. En la página AWS Services Settings, realice lo siguiente:
• Si está volviendo a instalar solamente el esquema del paquete de extensión, seleccione Skip this
step for now y, a continuación, Next.
• Si está cargando la biblioteca de Python, facilite las credenciales para conectarse a su cuenta
de AWS. Puede utilizar sus credenciales de AWS Command Line Interface (AWS CLI) si tiene
instalada la AWS CLI. También puede utilizar las credenciales que ya haya almacenado en un perfil
en la configuración global de la aplicación y tenga asociadas con el proyecto. Si fuera necesario,
seleccione Navigate to Project Settings para asociar al proyecto un perfil diferente. Si fuera
necesario, seleccione Global Settings para crear un nuevo perfil. Para obtener más información,
AWS (p. 13).
4. En la página Python Library Upload, haga lo siguiente:
• Si desea cargar la biblioteca de Python, proporcione la ruta de Amazon S3 y, a continuación,
seleccione Upload Library to S3 (Cargar biblioteca a S3).
Cuando haya terminado, elija Next.

5. En la página Functions Emulation, seleccione Create Extension Pack. Aparecerán mensajes con el
estado de las operaciones del paquete de extensión.
Cuando haya terminado, seleccione Finish.
Version 1.0
198
Las funciones de Lambda del paquete de extensión
Uso de las funciones de AWS Lambda del paquete

de extensión AWS SCT
El paquete de extensión de la Herramienta de conversión de esquemas de AWS contiene funciones
de Lambda que proporcionan funcionalidades de correo electrónico, programación del trabajo y otras
características a las bases de datos alojadas en la plataforma Amazon EC2.
Uso de las funciones de AWS Lambda para simular la

funcionalidad de una base de datos
En algunos casos, las características de la base de datos de origen no se pueden convertir a
características de Amazon RDS equivalentes. Algunos ejemplos son las llamadas de envío de correos
electrónicos de Oracle que utilizan UTL_SMTP y las tareas de Microsoft SQL Server que utilizan un
programador de trabajos. Si aloja y administra una base de datos en la plataforma Amazon EC2, puede
simular estas características sustituyendo los servicios de AWS por ellas.
El asistente del paquete de extensión de la AWS SCT le ayuda a instalar, crear y configurar funciones de
Lambda para simular las características de correo electrónico, programación del trabajo y otras funciones.

Utilice el siguiente procedimiento para aplicar el paquete de extensión.
Important
Las características de simulación de los servicios de AWS solo se admiten en bases de datos
instaladas y autoadministradas en la plataforma Amazon EC2. No instale las características de
simulación de servicios si su base de datos de destino está en una instancia de base de datos de
Amazon RDS.
Para aplicar el paquete de extensión
1. En la Herramienta de conversión de esquemas de AWS, en el árbol de la base de datos de destino,

abra el menú contextual (clic secundario) y seleccione Apply Extension Pack (Aplicar paquete de
extensión).
Aparecerá el asistente de paquete de extensión.

2. Lea la página Welcome y seleccione Next.
3. En la página AWS Services Settings, realice lo siguiente:
Version 1.0
199
• Si está instalando AWS Services, facilite las credenciales para conectarse a su cuenta de AWS.
Puede utilizar sus credenciales de AWS Command Line Interface (AWS CLI) si tiene instalada
la AWS CLI. También puede utilizar las credenciales que ya haya almacenado en un perfil en
la configuración global de la aplicación y tenga asociadas con el proyecto. Si fuera necesario,
seleccione Navigate to Project Settings para asociar al proyecto un perfil diferente. Si fuera
necesario, seleccione Global Settings para crear un nuevo perfil. Para obtener más información,
AWS (p. 13).
4. En la página Email Sending Service, haga lo siguiente:
• Si está instalando servicios de AWS y ya tiene una función de Lambda, puede introducirla. De lo
contrario, el asistente la creará por usted. Cuando haya terminado, elija Next.
5. En la página Job Emulation Service, haga lo siguiente:
• Si está instalando servicios de AWS y ya tiene una función de Lambda, puede introducirla. De lo
contrario, el asistente la creará por usted. Cuando haya terminado, elija Next.
6. En la página Functions Emulation, seleccione Create Extension Pack. Aparecerán mensajes con el
estado de las operaciones del paquete de extensión.
Cuando haya terminado, seleccione Finish.
Version 1.0
200
Administración general de la
memoria y opciones de desempeño
Prácticas recomendadas para la

esquemas de AWS
A continuación, encontrará información sobre prácticas recomendadas y opciones al usar la Herramienta
de conversión de esquemas de AWS.
Administración general de la memoria y opciones

de desempeño
Puede configurar la Herramienta de conversión de esquemas de AWS con diferentes opciones de
desempeño de la memoria. Al aumentar la memoria, acelerará el desempeño de su conversión, pero
empleará más recursos de memoria en su escritorio.
Para establecer su opción de administración de la memoria, seleccione Global Settings en el menú

Settings y seleccione la pestaña Performance and Memory. Elija una de las siguientes opciones:
• Conversión rápida, pero alto consumo de memoria: – esta opción optimiza la conversión para que sea
rápida, pero podría requerir más memoria para la caché de referencia de objetos.
• Bajo consumo de memoria, pero conversión más lenta: – esta opción reduce al mínimo la cantidad de
memoria empleada, pero da como resultado una conversión más lenta. Utilice esta opción si el escritorio
tiene una cantidad limitada de memoria.
• Equilibrio entre velocidad y consumo de memoria: – esta opción de optimización facilita un equilibrio
entre el uso de la memoria y la velocidad de conversión.
Configuración de memoria adicional

Para convertir grandes esquemas de bases de datos, por ejemplo, una base de datos con 3500
procedimientos almacenados, puede configurar la cantidad de memoria disponible para la Herramienta de
Para modificar la cantidad de memoria que consume la AWS SCT:
1. Localice la carpeta en la que esté el archivo de configuración (C:\Program Files\AWS Schema

Conversion Tool\App).
2. Abra el archivo de configuración AWS Schema Conversion Tool.cfg con el bloc de notas o su
procesador de textos favorito.
3. Edite la sección JVMUserOptions para definir la memoria disponible mínima y máxima. El siguiente
ejemplo establece el mínimo en 4 GB y el máximo en 40 GB.
[JVMUserOptions]
-Xmx48960m
-Xms4096m
Version 1.0
201
No se puede cargar objetos de una
base de datos de origen de Oracle
Solución de problemas con la

esquemas de AWS
A continuación, podrá obtener información sobre la solución de problemas con la Herramienta de
conversión de esquemas de AWS (AWS SCT).
No se puede cargar objetos de una base de datos

de origen de Oracle
Al intentar cargar esquemas desde una base de datos de Oracle, puede que reciba uno de los siguientes
errores.
Cannot load objects tree.
ORA-00942: table or view does not exist
Estos errores se producen debido a que el usuario cuyo ID se utiliza para conectarse a la base de datos
Oracle no tiene permisos suficientes para leer el esquema según requiere la AWS SCT.
Puede resolver este problema si concede al usuario permiso select_catalog_role y permiso para
cualquier diccionario en la base de datos. Estos permisos proporcionan un acceso de solo lectura a las
vistas y tablas del sistema que requiere AWS SCT. En el siguiente ejemplo se crea un ID de usuario
denominado min_privs y concede al usuario con este ID los permisos mínimos necesarios para convertir
el esquema de una base de datos Oracle de origen.
create user min_privs identified by min_privs;

grant connect to min_privs;
grant select_catalog_role to min_privs;
grant select any dictionary to min_privs;
Version 1.0
202
Notas de la versión: 632
Notas de la versión de Herramienta

Esta sección contiene las notas de la versión de Herramienta de conversión de esquemas de AWS, a partir
de la versión 1.0.611.
Notas de la versión de la compilación 632 de la

En la siguiente tabla se muestran las características y las correcciones de errores de la versión 1.0.632 de
Origen Destino Novedades, mejoras o correcciones
ALL ALL Interfaz de usuario de SCT: se ha agregado una nueva pestaña

para mostrar los errores que se producen al aplicar scripts.
SAP-ASE ALL Ahora puede guardar el árbol de origen como SQL.
Oracle PostgreSQL o • Ahora convierte los literales de cadena vacíos a NULL en todas
Aurora PostgreSQL partes: metadatos de objeto, instrucciones analizables, scripts
o instrucciones SQL en el código fuente de la aplicación, entre
otros.
• REPLACE tiene ahora el mismo comportamiento en Oracle y en
PostgreSQL.
• Ahora acepta más de 100 argumentos, que no estaban
permitidos para las funciones y los procedimientos de forma
predeterminada.
• Las funciones aws_oracle_ext.instr ya no devuelven un
resultado incorrecto.
• Ahora las funciones LEAST y GREATEST funcionan igual.
• Ya no debe utilizarse la función immutable_concat_ws del
paquete de extensión en lugar de standard concat_ws en
las vistas.
• Se ha implementado la función concat del paquete de
extracción inmutable.
• El sinónimo público ya no se expande en las vistas.
• Se ha añadido compatibilidad con
dbms_application_info.set_module.
• Ahora se admiten variables de tipo de número previamente
incompatibles para los códigos de error.
• Ahora se admite FETCH BULK COLLECT INTO.
• Ahora se admite SAVEPOINT, ROLLBACK TO SAVEPOINT
dentro de las funciones.
Version 1.0
203

• Ahora se admite el cursor con SELECT...INTO....
• Ahora se admite la variable de colección del paquete como
valor DEFAULT del parámetro de entrada de la rutina.
• La declaración de tipo de un parámetro o variable se basa en la
columna %TYPE de una vista del sistema.
• Ahora se admiten las tablas anidadas globales de %ROWTYPE.
• Compatibilidad para paquetes con subtipos de %TYPE.
• Corrección: el campo de inserción en el elemento de colección
causaba un error del transformador.
SAP ASE PostgreSQL o • Ahora se admite la conversión correcta de la instrucción

Aurora PostgreSQL UPDATE de varias tablas con una tabla temporal no resuelta.
• Se resuelve el objeto correcto cuando no se especifica el
nombre del esquema o solo se utiliza el nombre de la base de
datos.
• Ahora se admite la función CONVERT (paquete de extensión).
Netezza Redshift • Código almacenado. Compatibilidad mejorada con el control de

transacciones (COMMIT/ROLLBACK).
• Cambio de la gravedad de "crítica" a "alta" para AI 15028 sin
resolver. Se ha añadido el operador /=/ al procesamiento de las
consultas.
• Se ha reducido el valor “Estimated Time to Resolve Manually
(Tiempo estimado para resolver manualmente)" para las
instancias de AI 15001, 15002, 15003.
• Conversión del operador /=/ en las instrucciones SQL.
• Mejoras en la asignación de tipos de datos para los tipos de
datos entre comillas (por ejemplo "VARCHAR" y "TIME", entre
otros).
Amazon RDS for Redshift Corrección: para el error de comando de copia que se producía
Oracle al cargar en Redshift desde Oracle en RDS mediante el agente
de extracción de datos SCT en cualquier sistema operativo de
entorno japonés. Se ha agregado el comando "ALTER SESSION
SET NLS_DATE_LANGUAGE = 'ENGLISH'" para Oracle antes de
extraer los datos.
Errores resueltos:
• CORRECCIÓN: error tipográfico en el menú de configuración del proyecto actual

• CORRECCIÓN: no se puede convertir a mayúsculas con la regla de asignación (si el destino era
PostgreSQL)

Version 1.0
204
Oracle y Todos Se ha añadido compatibilidad con el mecanismo de recuento y el

OracleDW recuento de líneas de código SQL
Oracle MariaDB Las consultas jerárquicas que utilizan la sintaxis CONNECT BY

(10.2/10.3/10.3 de Oracle se transfieren a expresiones de tabla comunes (WITH
SQL RECURSIVE)
MODE=ORACLE)
Oracle MariaDB Se ha corregido una combinación compleja con la tabla que

aparecía en ambos lados de la combinación
MySQL
MySQL (Aurora)
SAP ASE MySQL Compatibilidad con la función CONVERT
SAP ASE MySQL REVISIÓN: conversión de INSERT con una implementación

SELECT de varias tablas y conversión de la instrucción UPDATE
MySQL (Aurora) de varias tablas con una implementación de tabla temporal
Microsoft SQL MySQL REVISIÓN: la definición de objetos y esquemas no es correcta si

Server se invoca un objeto y no se especifica un esquema
MySQL (Aurora)
Ahora, los objetos del sistema que no tienen esquemas se
convierten tal y como están.
SAP ASE MySQL Corregido: conversión incorrecta de INSERT con SELECT de

varias tablas
MySQL (Aurora)
Microsoft SQL PostgreSQL Ahora, el comentario del bloque try/catch se transfiere al destino
Server
Se ha mejorado la compatibilidad con los parámetros de los
procedimientos almacenados que tienen valores predeterminados
REVISIÓN: se ha eliminado todo el código del proceso cuando se

utiliza ALTER TABLE y ENABLE/DISABLE TRIGGER ALL
SAP ASE PostgreSQL Compatibilidad con la función CONVERT
Oracle PostgreSQL Compatibilidad con la conversión de código de ProC a ECPG
Se ha mejorado la compatibilidad con la conversión RAWTOHEX/

HEXTORAW/UTL_RAW
Se ha mejorado la compatibilidad con los cursores globales para

permitir los comandos FETCH y OPEN en rutinas almacenadas
independientes. Con esta mejora, el cursor se puede abrir en un
procedimiento, recuperarse en otro procedimiento y cerrarse en
un tercer procedimiento.
Opción para cambiar entre el procedimiento y la función en

PostgreSQl 11
DBMS_XMLGEN y DBMS_XMLQUERY
Creación de sinónimos públicos para los procedimientos

almacenados
Version 1.0
205
Microsoft SQL PostgreSQL Se ha mejorado la definición de objetos y esquemas cuando

Server solo se especifica el nombre de la base de datos al llamar a un
PostgreSQL procedimiento
(Aurora)
Ahora, los objetos del sistema que no tienen esquemas se
convierten tal y como están.
Oracle PostgreSQL Se ha mejorado la compatibilidad con los cursores globales para

permitir los comandos FETCH y OPEN en rutinas almacenadas
PostgreSQL independientes. Con esta mejora, el cursor se puede abrir en un
(Aurora) procedimiento, recuperarse en otro procedimiento y cerrarse en
un tercer procedimiento.
Ahora, los alias de columna de una subconsulta se convierten

correctamente.
Compatibilidad con la función REVERSE
Compatibilidad con los parámetros de un bloque anónimo
Se ha añadido una opción para convertir ROWID en

varchar(36). Con esta nueva opción, puede crear un objeto
DOMAIN para MyRowid como varchar(36) NOT NULL,
convertir el tipo de datos ROWID y la columna AS MyRowid y,
finalmente, crear un objeto SEQUENCE para cada columna y
establecerlo de forma predeterminada en NEXTVAL().
Emulación de vistas del sistema
Compatibilidad con FORALL MERGE
Compatibilidad con un cursor global con parámetros de tipo

%TYPE. Se han realizado mejoras en las conversiones de Oracle:
Compatibilidad de los cursores globales con parámetros de tipo

%TYPE. Compatibilidad de los cursores globales con parámetros
de tipo %TYPE
Compatibilidad para crear una función de inicialización en un

paquete sin variables
La IA se activa en una rutina con más de 100 argumentos
Se ha corregido la conversión de DECODE a CASE con NULL
Transformación de SQL recursivo si se necesita una columna

distinta de la columna de conexión.
Uso de los atributos %FOUND y %NOTFOUND de los cursores

explícitos locales
Llamadas a funciones con el resultado de un tipo de colección que

utiliza una notación con nombre
Funciones con el resultado de un tipo de colección y valores de

argumento predeterminados
Version 1.0
206
Greenplum Redshift Declaración FUNCTION (DROP/CREATE PROCEDURE)
Declaración de variables y constantes
Asignaciones y expresiones de variables
Lenguaje de control de flujo.FOR
Cursores
SQL dinámico v1. (rechazo con IA)
Asignación de tipos de datos Greenplum PL/pgSql: Redshift PL/

pgSQL
Estructura PL/pgSQL (BEGIN... END, subbloques, etiquetas)
Comentarios
Lenguaje de control de flujo. RETURN/RETURN NEXT
Lenguaje de control de flujo. IF-THEN-ELSE
Lenguaje de control de flujo. EXIT/CONTINUE en bucles
Lenguaje de control de flujo. LOOP simple
Lenguaje de control de flujo. WHILE
Instrucciones comunes. Llamar a otro procedimiento/UDF
RETURNS SETOF da como resultado funciones de Redshift

(plpythonu)
Devuelve el valor VOID a Redshift (plythonu)
Microsoft SQL Redshift Compatibilidad con procedimientos almacenados de CLR

Server
Se ha mejorado la compatibilidad con código almacenado para el
control de transacciones (COMMIT, ROLLBACK)
Netezza Redshift Los procedimientos de Netezza ya no se convierten en funciones

de python
Compatibilidad con asignaciones, aplicación de SELECT en

variables, comentarios de procedimientos y otros casos.
Oracle Redshift Compatibilidad mejorada con paquetes PL/SQL
Se ha mejorado la compatibilidad con código almacenado para el

control de transacciones (COMMIT, ROLLBACK)
Version 1.0
207
Teradata Redshift Compatibilidad con el control de transacciones (COMMIT,

ROLLBACK) en código almacenado.
Ejecución de funciones y procedimientos almacenados
Devolución de cursores de conjuntos de resultados
Instrucciones de diagnóstico
Compatibilidad con las instrucciones DDL para CREATE TABLE y

CREATE VOLATILE TABLE
Errores resueltos:
• REVISIÓN: no se puede traducir la función SYSDATETIMEOFFSET de SQL Server a PG

• REVISIÓN: error de conexión de prueba de perfil de servicio en Amazon ETL Service (SCT 626)
• REVISIÓN: problemas para convertir la tabla Teradata a Redshift
• REVISIÓN: error de conexión de prueba del perfil de servicio global para el servicio Amazon ETL
• REVISIÓN: el informe de evaluación de SCT no puede guardar caracteres multibyte como PDF
• REVISIÓN: el agente independiente de DMS ahora admite S3 como destino de la tarea local de DMS
• REVISIÓN: ahora puede ver las tablas del sistema de SAP ASE en el árbol de objetos.
• REVISIÓN: en las conversiones entre SQL Server y PostgreSQL, SCT ahora admite comentarios en
bloques try/catch.

La versión 1.0.630 de Herramienta de conversión de esquemas de AWS se ha fusionado con la
versión 1.0.631 de Herramienta de conversión de esquemas de AWS. Para ver los cambios que se han
combinado, consulte Notas de la versión de la compilación 631 de la Herramienta de conversión de

Nueva característica o mejora Descripción

Redshift Para conversiones de Netezza, compatibilidad de código almacenado

con lo siguiente:
• Procedimientos almacenados
Version 1.0
208

Para las conversiones de Microsoft SQL Server:
• Se ha añadido la capacidad de imprimir el procedimiento almacenado

de CLR de código fuente
• OBJECT_ID
Para conversiones de Oracle, compatibilidad de código almacenado con

lo siguiente:
• Paquetes PL/SQL
Para las conversiones de Teradata:
• Tratamiento de excepciones
• Gestión de condiciones
• Instrucciones DDL
• Declaraciones DDL: CREATE otros objetos
• Enunciados DML: compatibilidad mejorada
SAP ASE Compatibilidad con SAP ASE 12.5 como origen
DynamoDB Para conversiones de Cassandra:
• Mejoras de migración y corrección de errores.

• Extracción de tipo de recopilación para tuplas y congeladas
MySQL 8 Para las conversiones de Oracle, se ha agregado compatibilidad con

consultas jerárquicas mediante Oracle CONNECT BY, convirtiendo
ahora la sintaxis a WITH Queries (CTE), incluido el modificador
RECURSIVE.
MySQL y Aurora MySQL Para las conversiones de SAP ASE:
• Se ha añadido compatibilidad con los mensajes definidos por el

usuario a la tabla de sistema sysusermessages para su uso por
parte de cualquier aplicación. Utilice sp_addmessage para añadir
mensajes a sysusermessages; utilice sp_getmessage para
recuperar mensajes para que los usen print y raiserror.
• Se ha corregido la conversión incorrecta de RAISERROR.
Version 1.0
209
Notas de la versión–
PostgreSQL Para conversiones de Oracle, compatibilidad con lo siguiente:
• Opciones para hacer caso omiso de los disparadores y restricciones

deshabilitados
• Asignar la operación de matriz o tabla anidada global de registro
anidado
• Funciones EXTRACT, EXTRACTVALUE
• Contextos de aplicaciones locales y globales con el paquete de
extensión, incluida la categoría de objetos adicional en el árbol de
objetos y las reglas.
• Métodos XMLSEQUENCE, XMLELEMENT y XMLTYPE
• Se ha mejorado la compatibilidad de cursor global para convertir
comandos OPEN y FETCH en rutinas almacenadas independientes.
Ahora, el cursor se puede abrir en un procedimiento, recuperarse en
otro y cerrarse en el tercero.
• Corregido: los alias de las columnas en la subselección ya no se
convierten incorrectamente
• Se ha corregido la combinación compleja de SCT Transformer Error
que ya no muestra la tabla a ambos lados de la combinación.
Para conversiones de Microsoft SQL Server, compatibilidad con el SQL

dinámico:
PostgreSQL y Aurora Para las conversiones de Oracle,

PostgreSQL dbms_application_info.set_action se puede emular
mediante el paquete de extensión. Además, donde la referencia
SQL%bulk_exceptions provocaba un error de transformador, estas
excepciones ahora deben rechazarse con IA.
Errores resueltos:
• Ahora los disparadores y procedimientos pueden convertir de SQL Server a MySQL

• SCT ahora puede convertir esquemas de 6000 procedimientos en conversiones de SQL Server a Aurora
PostgreSQL
• Se ha corregido la incapacidad de usar AWS Glue en la región del Norte de Virginia
• Los procedimientos de origen de SQL Server ya no se bloquean durante la conversión de esquemas
• Corrección de errores y mejoras generales.

la Herramienta de conversión de esquemas de AWS ().
Sustituciones de servicio Para conversiones de DB2 a Aurora MySQL:
Version 1.0
210

• Emulación de envío de correo electrónico
• Emulación de compatibilidad de archivos
• Emulación de trabajos
Para conversiones de DB2 a Aurora PostgreSQL:
• Emulación de envío de correo electrónico

• Emulación de paquetes UTL_File
Para conversiones de Microsoft SQL Server a MySQL, PostgreSQL,

Aurora MySQL o Aurora PostgreSQL:
• Emulación del programador de SQL Server
Para conversiones de Oracle a MySQL o Aurora MySQL:

• Emulación de paquetes OWA_
• Emulación de colas de Oracle
• Emulación de paquetes HTP/HTF/OWA_*
Para conversiones de Oracle a PostgreSQL o Aurora PostgreSQL:

• Emulación de paquetes OWA_
• Emulación de colas de Oracle
• Emulación de paquetes UTL_FILE
Version 1.0
211
Redshift Para conversiones de Microsoft SQL Server, compatibilidad de código

almacenado con lo siguiente:
• Procedimientos almacenados y SQL dinámico
Para conversiones de Oracle, compatibilidad de código almacenado con

lo siguiente:
• Cursores en procedimientos
• MERGE
• EXECUTE IMMEDIATE es compatible con procedimientos y ha
mejorado la compatibilidad con SQL dinámico
• Subprogramas anidados en procedimientos
Para conversiones de Teradata, compatibilidad de código almacenado

con lo siguiente:
• Cursores en procedimientos
• MERGE
• QUALIFY
• variables DECLARE y SET
SAP ASE 15.0 Compatibilidad con SAP ASE 15.0 como origen
DynamoDB Para conversiones de Cassandra, compatibilidad con lo siguiente:
• Extracción de tipos de colección (SET, LIST, MAP)

• Mejoras y correcciones generales
MySQL 8 Para conversiones de DB2 o SAP ASE, compatibilidad con instancias

que distinguen entre mayúsculas y minúsculas
Version 1.0
212
PostgreSQL 11 Para conversiones de DB2, compatibilidad con lo siguiente:
• Compatibilidad con transacciones incrustadas y CALL para

procedimientos almacenados en SQL. En los procedimientos
invocados por el comando CALL, así como en bloques de código
anónimo (comando DO), es posible finalizar las transacciones con los
comandos COMMIT y ROLLBACK. Una nueva transacción se iniciará
automáticamente cuando se termine una transacción con estos
comandos, por lo que no hay ningún comando START TRANSACTION
independiente. (Tenga en cuenta que BEGIN y END tienen distintos
significados en PL/pgSQL).
Para conversiones de Microsoft SQL Server, compatibilidad con lo

siguiente:
• Compatibilidad con T-SQL dinámico. Compatibilidad con llamada a

procedimientos almacenados mediante CALL en consultas dinámicas.
Para conversiones de Oracle, compatibilidad con lo siguiente:
• Compatibilidad con conversiones SQL* Plus, incluidos procedimientos

y SQL dinámico. Procedimientos almacenados CALL en consultas
dinámicas.
• Se ha añadido la opción para cambiar el mapeo de tipos de datos
predeterminado para columnas con PK y FK que hacen referencia
a una PK modificada. Por ejemplo, puede convertir un número
con escala y precisión en bigint, para mejorar el rendimiento.
Anteriormente, cuando el tipo de datos numérico se migraba de Oracle
a PostgreSQL, SCT utilizaba de forma predeterminada la conversión
a numérico en PostgreSQL. Si el número de Oracle se utilizaba con
escala y precisión, esta conversión era correcta. Sin embargo, si se
tratara de un número entero con un índice de PK en la columna, la
conversión a numérico en PostgreSQL podría causar problemas de
rendimiento.
• Compatibilidad para convertir %TYPE en tipo de datos integrado. SCT
sustituye %TYPE por un nuevo tipo de datos, de acuerdo con las reglas
de mapeo de tipos.
• Se ha reemplazado el mapeo predeterminado de los argumentos de
función y procedimiento para que NUMBER se convierta a NUMERIC, en
lugar de DOUBLE PRECISION
Para conversiones de SAP ASE, compatibilidad con lo siguiente:
• CREATE PROCEDURE with RETURN

• Compatibilidad con la llamada a procedimientos almacenados
mediante CALL en consultas dinámicas
• Compatibilidad con FOREIGN KEYen tablas particionadas.
PostgreSQL 11 solo admite claves externas de una tabla con
particiones a una sin particiones.
• Compatibilidad con índices en tablas particionadas. Después de
indexar la tabla maestra, PostgreSQL crea automáticamente un
Version 1.0
213
Notas de la versión: 627 –

índice configurado de forma idéntica en las particiones secundarias
existentes y en las tablas con particiones futuras.
• Compatibilidad con PRIMARY KEY en tablas particionadas. En la
versión 11, puede añadir una clave principal a la tabla maestra. Esto
crea la PRIMARY KEY en todas las tablas secundarias existentes
y en tablas de particiones futuras. Si se añade PARTITION, no es
necesario crear una clave principal manualmente.
• Compatibilidad con disparadores en tablas particionadas. Después
de crear un disparador en la tabla maestra, PostgreSQL crea
automáticamente el disparador en todas las tablas secundarias (este
comportamiento es similar al de los índices).
PostgreSQL y Aurora Para conversiones de Sybase, UDT se convierte en DOMAIN

PostgreSQL
Errores resueltos:
• Se ha añadido compatibilidad para crear un informe SCT junto con componentes lógicos en WQF.
• Solución: problema en el que el informe WQF incluía elementos de acción de error de extracción
• Solución: problema cuando SCT no recoge automáticamente el punto de enlace de DMS para Aurora
PostgreSQL
• Solución: problema cuando Apply to database (Aplicar a base de datos) aparece atenuado para varios
esquemas
• Corrección de errores y mejoras generales
Notas de la versión de la compilación 627 de

Compatibilidad con Se ha mejorado la compatibilidad de las siguientes características al

las conversiones en convertir procedimientos almacenados de Microsoft SQL Server en
procedimientos almacenados Amazon Redshift:
en Amazon Redshift
• Mejoras en la compatibilidad de DDL
• Tablas temporales
• Declaración PROCEDURE
• Tratamiento de errores de procedimientos
• Instrucciones SET
• Lenguaje de control de flujo
• Operadores
• CURSORS
• Expresiones aritméticas con tipos de operandos mixtos
PostgreSQL 11 Las mejoras de las conversiones a PostgreSQL incluyen las siguientes.
Version 1.0
214

• Para orígenes de DB2:
• La función de particiónDEFAULT almacena las tuplas que no están
asignadas a ninguna otra partición. Antes de PostgreSQL 11, estas
filas producían un error. Una fila que no estaba asignada a ninguna
tabla de partición se insertaba en la partición predeterminada.
• Ahora se pueden crear índices de cobertura, utilizando la cláusula
INCLUDE de CREATE INDEX
• CREATE PROCEDURE define un nuevo procedimiento. CREATE
OR REPLACE PROCEDURE creará un nuevo procedimiento o
reemplazará una definición existente. Para poder definir un
procedimiento, el usuario debe tener el privilegio USAGE en el
lenguaje.
• Una vez que el disparador se crea en la tabla maestra, este se
creará automáticamente en todas las tablas secundarias (este
comportamiento es similar al observado para el índice).
• Una vez que el índice se crea en la tabla maestra, este se creará
automáticamente con la misma configuración en todas las
particiones secundarias existentes y se aplicará también a todas las
tablas de partición futuras.
• Postgres 11 solo admite claves externas de una tabla con
• En la versión 11 se puede añadir PRIMARY KEY a la tabla maestra
que creará la PRIMARY KEY en todas las tablas secundarias
existentes y las tablas con particiones futuras. Si se añade
IF PARTITION, no es necesario crear las claves principales
manualmente
• Para orígenes de datos de Microsoft SQL Server:
• Ahora se pueden crear índices de cobertura utilizando la cláusula
INCLUDE de CREATE INDEX
• En los procedimientos invocados por el comando CALL, así como
en bloques de código anónimo (comando DO), es posible finalizar
las transacciones con los comandos COMMIT y ROLLBACK. Una
nueva transacción se iniciará automáticamente cuando se termine
una transacción con estos comandos, por lo que no hay ningún
comando START TRANSACTION independiente. (Tenga en cuenta
que BEGIN y END tienen distintos significados en PL/pgSQL).
• Sintaxis de CALL para procedimientos almacenados de SQL
lenguaje.
• Una vez que el disparador se crea en la tabla maestra, este se
creará automáticamente en todas las tablas secundarias (este
comportamiento es similar al observado para el índice).
• Postgres 11 solo admite claves externas de una tabla con
Version 1.0
215

• En la versión 11 se puede añadir PRIMARY KEY a la tabla maestra
que creará la PRIMARY KEY en todas las tablas secundarias
existentes y tablas con particiones futuras. Si se añade PARTITION,
no es necesario crear las claves principales manualmente
• Para orígenes de Oracle:
o REPLACE PROCEDURE creará un procedimiento o reemplazará
una definición existente. Para poder definir un procedimiento, el
usuario debe tener el privilegio USAGE en el lenguaje.
• Para orígenes de SAP ASE:
lenguaje.
• Las instrucciones UPDATE que cambian una columna de clave
de partición ahora hacen que las filas afectadas se muevan a las
particiones correspondientes.
• La función de particiónDEFAULT de PostgreSQL 11 almacena las
tuplas que no están asignadas a ninguna otra partición. Antes de
PostgreSQL 11, estas filas producían un error. Una fila que no
estaba asignada a ninguna tabla de partición se insertaba en la
partición predeterminada.
• Particiones hash: la tabla se particiona especificando un módulo y
un resto para cada partición. – Cada partición contendrá las filas
para las que el valor hash de la clave de partición dividido por el
módulo especificado producirá el resto especificado.
Version 1.0
216
MySQL 8 SCT admite ahora instancias con distinción entre mayúsculas y

minúsculas para las conversiones de Oracle, Microsoft SQL Server,
Azure, PostgreSQL y MySQL. SCT ofrece ahora la opción de crear y
utilizar los nombres de bases de datos, tablas y desencadenadores en
minúsculas.
Las mejoras en las conversiones a MySQL incluyen las siguientes.
• Para orígenes de DB2:

• MySQL admite ahora índices descendentes: DESC en una definición
de índice ya no se omite, sino que hace que los valores de
clave se almacenen en orden descendente. Anteriormente, los
índices podían analizarse en orden inverso, pero a expensas del
rendimiento. Un índice descendente se puede analizar en orden
ascendente, lo que es más eficaz. Los índices descendentes
también hacen posible que el optimizador utilice índices de varias
columnas cuando el orden de análisis más eficiente combina el
orden ascendente para algunas columnas y el descendente para
otras.
• MySQL permite ahora crear partes de claves de índice funcionales
que indexen valores de expresión en lugar de valores de columna.
Las partes de clave funcionales permiten indexar los valores que no
se pueden indexar de otra manera, como los valores JSON.
• MySQL admite ahora CTE y CTE WITH recursivo (expresiones de
tabla comunes)
• Una tabla derivada ahora puede ir precedida de la palabra clave
LATERAL para especificar que se permite su uso para hacer
referencia a columnas de tablas anteriores en la misma cláusula
FROM. Las tablas derivadas laterales permiten que algunas
operaciones SQL no se puedan realizar con tablas derivadas que no
sean laterales o que requieran soluciones menos eficaces.
• Ahora se pueden utilizar varias funciones de agregación como
funciones de ventana.
• AVG()
• BIT_AND()
• BIT_OR()
• BIT_XOR()
• COUNT()
• JSON_ARRAYAGG()
• JSON_OBJECTAGG()
• MAX()
• MIN()
• STDDEV_POP()
• STDDEV()
• STD()
• STDDEV_SAMP()
• SUM()
• VAR_POP()
• VARIANCE()
• VAR_SAMP()
Version 1.0
217

• MySQL admite las funciones de ventana que, para cada fila de una
consulta, realizan un cálculo utilizando las filas relacionadas con esa
fila.
• CUME_DIST()
• DENSE_RANK()
• FIRST_VALUE()
• LAG()
• LAST_VALUE()
• LEAD()
• NTH_VALUE()
• NTILE()
• PERCENT_RANK()
• RANK()
• ROW_NUMBER()
• Para orígenes de base de datos de Microsoft SQL Server y Azure
SQL:
• AVG()
• BIT_AND()
• BIT_OR()
• BIT_XOR()
• COUNT()
• JSON_ARRAYAGG()
• MAX()
• MIN()
• STDDEV_POP()
• STDDEV()
• STD()
• STDDEV_SAMP()
• SUM()
• VAR_POP()
• VARIANCE()
• VAR_SAMP()
• WITH (expresiones de tabla comunes): MySQL admite CTE y CTE
recursivo –
fila.
• CUME_DIST()
• FIRST_VALUE()
• LAG()
• LAST_VALUE()
• LEAD()
Version 1.0
218

• Tablas derivadas laterales
otras.
• MySQL admite ahora el uso de expresiones como valores
predeterminados en las especificaciones de tipos de datos. Esto
incluye el uso de expresiones como valores predeterminados
para los tipos de datos BLOB, TEXT, GEOMETRY y JSON, a los que
anteriormente no se podían asignar valores predeterminados de
ninguna forma.
• Para orígenes de Oracle:
• Una tabla derivada ahora puede ir precedida de la palabra clave
LATERAL para especificar que se permite su uso para hacer
referencia a columnas de tablas anteriores en la misma cláusula
FROM. Las tablas derivadas laterales permiten que algunas
operaciones SQL no se puedan realizar con tablas derivadas que no
sean laterales o que requieran soluciones menos eficaces.
• InnoDB admite las opciones NOWAIT y SKIP LOCKED con las
instrucciones de bloqueo de lectura SELECT ... FOR SHARE
y SELECT ... FOR UPDATE. NOWAIT hace que la instrucción
termine inmediatamente si una fila solicitada está bloqueada por
otra transacción. SKIP LOCKED elimina las filas bloqueadas del
conjunto de resultados.
• WITH (expresiones de tabla comunes): MySQL admite CTE y CTE
recursivo –
• AVG()
• BIT_AND()
• BIT_OR()
• BIT_XOR()
• COUNT()
• JSON_ARRAYAGG()
• MAX()
• MIN()
• STDDEV_POP()
• STDDEV()
• STD()
• STDDEV_SAMP()
• SUM()
• VAR_POP()
Version 1.0
219

• VARIANCE()
• VAR_SAMP()
• MySQL implementa la compatibilidad con las expresiones regulares
de la manera siguiente.
• NOT REGEXP
• REGEXP
• REGEXP_INSTR()
• REGEXP_LIKE()
• REGEXP_REPLACE()
• REGEXP_SUBSTR()
• RLIKE
fila.
• CUME_DIST()
• DENSE_RANK()
• FIRST_VALUE()
• LAG()
• LAST_VALUE()
• LEAD()
• NTH_VALUE()
• NTILE()
• PERCENT_RANK()
• RANK()
• ROW_NUMBER()
• Para orígenes de SAP ASE:
otras.
• MySQL permite ahora crear partes de claves de índice funcionales
que indexen valores de expresión en lugar de valores de columna.
Las partes de clave funcionales permiten indexar los valores que no
se pueden indexar de otra manera, como los valores JSON.
• MySQL admite ahora el uso de expresiones como valores
predeterminados en las especificaciones de tipos de datos. Esto
incluye el uso de expresiones como valores predeterminados
para los tipos de datos BLOB, TEXT, GEOMETRY y JSON, a los que
anteriormente no se podían asignar valores predeterminados de
ninguna forma.
Version 1.0
220
Notas de la versión:– 626
AWS Glue Las mejoras en las conversiones a AWS Glue incluyen las siguientes.
• Se ha mejorado la conversión de los parámetros de procedimientos.

• Capacidad de añadir comillas para caracteres especiales a los scripts
de AWS Glue.
• Correcciones, mejoras y ajustes de las conversiones de Teradata
BTEQ a AWS Glue.
• Mejoras y correcciones de las conversiones de Oracle a AWS Glue.
DynamoDB Mejoras y correcciones de las migraciones de Cassandra a DynamoDB.
Oracle SCT admite ahora las particiones INTERVAL en orígenes de Oracle.
Errores resueltos:
• Se ha agregado compatibilidad con MySQL 8 como destino en AWS SCT.

• Se ha agregado compatibilidad para la autenticación de Windows en WQF.
• Los campos de nombre de usuario/contraseña ya no son necesarios para el proxy de AWS DMS.
• Corrección: SCT ahora puede leer todos los objetos de base de datos cuando se selecciona el esquema
completo (de Oracle a Amazon Aurora PostgreSQL).
• Corección: la ruta física del archivo de estadísticas de AWS SCT ahora se admite en WQF cuando se
cargan componentes físicos o lógicos desde archivos CSV/JSON.
• Corrección: la clave compuesta (b,a) ya no cambia a (a,b) durante las conversiones de SQL Server a
Aurora MySQL.
• Corrección: véase el error de conversión (de SQL Server a PostgreSQL).
• Corrección: para las conversiones de SAP ASE, se ha añadido compatibilidad para especificar el juego
de caracteres en la conexión del servidor.
Notas de la versión de la compilación 626 de

PostgreSQL 11 PostgresSQL 11 ya se admite como objetivo. Estas son algunas de las

principales características:
• Creación de una partición “predeterminada” para las filas que no

encajan de forma automática en una partición existente.
• Creación de claves externas de una tabla particionada a una tabla no
particionada.
• Creación de un índice único en la tabla maestra. Este índice
administra los índices con la misma configuración en las tablas
secundarias existentes y en tablas particionadas futuras.
• Cuando crea un desencadenador en la tabla maestra, crea, de forma
automática, desencadenadores en todas las tablas secundarias.
Version 1.0
221

• Cuando UPDATE una columna de clave de partición para que encaje
en una partición diferente, esa fila se mueve a la partición adecuada.
• Uso de particiones HASH al especificar un módulo al que aplicar la
clave de partición. El resto de los módulos se utilizan para identificar la
partición para esa fila.
MySQL 8.0 MySQL 8.0 ya se admite como objetivo. Estas son algunas de las
principales características:
• El uso de DESC en una definición de índice ahora almacena valores

clave en orden descendente. Anteriormente, el análisis de estos
índices en orden inverso provocaba una pérdida de rendimiento.
Ahora, un índice descendente se puede escanear de forma eficaz
(avanzando hacia adelante en vez de hacia atrás). Los índices
descendentes también hacen posible que el optimizador utilice índices
de varias columnas cuando el orden de escaneo más eficiente mezcla
el orden ascendente para algunas columnas y el descendente para
otras.
• Uso de expresiones como valores predeterminados en
especificaciones de tipos de datos. Esto incluye los tipos de datos
BLOB, TEXT, GEOMETRY y JSON.
• Creación de partes clave funcionales del índice que indexan valores
de expresión en lugar de valores de columnas. Las partes clave
funcionales permiten indexar los valores que no lo pueden hacer de
otra manera, como los valores JSON.
SAP ASE 15.5 SAP ASE 15.5 ya se admite como origen.
AzureSQL/MSSQL a MySQL/ Ya puede utilizar las columnas de identidad en las tablas temporales y
AuroraMySQL las funciones con valores de tabla.
A partir de ahora puede utilizar INSERT INTO para las tablas con una
columna de identidad.
Cassandra a DynamoDB Mejoras de migración y corrección de errores.
Adición del proceso de compactación en el asistente.
telnet de utilidad se reemplazó con por netcat en el asistente.
De DB2 a MariaDB 10.3 (SQL MODE=ORACLE) Las rutinas de módulos y las referencias variables
ya se admiten.
DB2 a MySQL/AuroraMySQL Sustitución de servicio: soporte para archivos.
Netezza a Redshift Las columnas de la tabla que contienen DEFAULT 'now(0)' se han
establecido ahora en DEFAULT SYSDATE.
Oracle a MariaDB 10.3 (SQL MODE=ORACLE) Las rutinas de módulos, las referencias variables y
el uso de secuencias ya se admiten.
Oracle a MySQL/ Sustitución de servicio: soporte para archivos.

AuroraMySQL
Oracle a AWS Glue La función integrada del conjunto FORMAT MODELS ya se admite.
Version 1.0
222
SAP ASE a MySQL /Aurora Las variables globales ya se admiten.

MySQL
SAP ASE a PostgreSQL / Las variables globales ya se admiten.

Aurora PostgreSQL
Teradata BTEQ a AWS Glue Ahora se admiten funciones integradas para los conjuntos BITBYTE y
PERIOD.
Problemas resueltos:
• Se han corregido errores de convertidor internos para la migración de SQL Server a MySQL.
• Se han corregido problemas en el informe de evaluación de la conversión de la aplicación.
• Se han corregido problemas para el particionado de intervalos de Oracle.
• Se han corregido y pulido las conversiones a AWS Glue.

Conversión de Teradata Ya se pueden convertir scripts de Teradata BTEQ a AWS Glue.

BTEQ
De DB2 a MariaDB 10.3 Ya se pueden utilizar cursores con parámetros.
De DB2 a MariaDB 10.3 (SQL Para conversiones de DB2 a MariaDB 10.3 con SQL MODE=ORACLE,
MODE=ORACLE) ahora se admite lo siguiente:
• variables %TYPE y %ROWTYPE

• variables de estructura ROW en cursores locales
• Declaración de variables escalares
• Declaración de un valor de variable predeterminado
• Conversión de módulos en paquetes
• CREATE PROCEDURE p1 (param OUT INT)
• CREATE PROCEDURE p1 (a IN OUT INT)
• Uso de AS antes del cuerpo de una función
• Uso de IS antes del cuerpo de una función
Oracle a MariaDB 10.3 Para las conversiones de Oracle a MariaDB 10.3, puede utilizar las
variables %TYPE y %ROWTYPE.
De Oracle a MariaDB 10.3 Para las conversiones de Oracle a MariaDB 10.3 con SQL
(SQL MODE=ORACLE) MODE=ORACLE, ahora se admite lo siguiente:
Version 1.0
223

• variables %TYPE y %ROWTYPE
• Rutinas de paquete (procedimientos y funciones)
• SELECT UNIQUE
• GLOBAL CURSORS
• Bloque de inicialización de paquete BEGIN..END
• Paquete sin el cuerpo
• Variables locales y constantes
• Variables globales y constantes
MS SQL Server a MySQL/ Para conversiones de MS SQL Server a MySQL/AuroraMySQL, ya se

AuroraMySQL admite lo siguiente:
• sp_prepexec() con SQL dinámico

• sp_execute() con SQL dinámico
• sp_unprepare() con SQL dinámico
SAP ASE 15.7 SAP ASE 15.7 ya es compatible.
• Se han añadido notificaciones para el momento en que se cierra un proyecto y se podrían perder las
conexiones del agente de datos.
• Se han resuelto los problemas de conversión de Oracle a PostgreSQL.
• Se han resuelto los problemas de conversión de SCT Oracle a PostgreSQL: problema to_date.

Convertir ETL de Oracle a Ya puede convertir los trabajos de ETL de Oracle a ETL en base a AWS
AWS Glue Glue para trabajar junto con Amazon Redshift.
Conversiones de Microsoft Se ha añadido compatibilidad con RDS para MariaDB 10.2 y 10.3 como
SQL Server, Oracle e IBM destino.
Db2 LUW a Amazon RDS for
MariaDB
Conversiones de SAP ASE Se ha añadido compatibilidad para las conversiones de SAP ASE a
a RDS for MySQL y Amazon objetos de base de datos MySQL
Aurora con compatibilidad
con MySQL
Compatibilidad con la Ya puede utilizar la extensión Orafce como destino al convertir a

extensión Orafce durante PostgreSQL en el modo de compatibilidad con Oracle
Version 1.0
224

la conversión de Oracle a
PostgreSQL
• Se ha solucionado el problema al utilizar perfiles de AWS en AWS SCT en las regiones de Pekín y
Ningxia.
• Se ha solucionado un problema en SQL Server a RDS para las conversiones PostgreSQL/Aurora
PostgreSQL donde SCT no regresa al convertir un procedimiento almacenado.
• Se ha solucionado un error de partición virtual en los agentes de extracción de datos desde la
compilación 623.

Note
En la siguiente tabla, se entiende que PostgreSQL hace referencia a PostgreSQL y Amazon

Aurora PostgreSQL.
Conversión de SAP ASE a Se ha añadido SAP ASE como una base de datos de origen.
PostgreSQL
Emulación de la función La función NLSSORT se utiliza para reemplazar una cadena de

NLSSORT de Oracle para la caracteres por la cadena de ordenación equivalente que utiliza el
conversión a PostgreSQL mecanismo de ordenación lingüística. En el caso de una ordenación
binaria, la cadena de clasificación es la misma que la cadena de
entrada. En la ordenación lingüística; cada carácter de una cadena se
reemplaza por otros valores binarios.
Emulación de la función La función DBTIMEZONE de Oracle/PLSQL devuelve la zona horaria de

DBTIMEZONE de Oracle la base de datos como una diferencia de zona horaria (en el siguiente
para la conversión a formato: "[+|-]TZH:TZM") o un nombre de región de zona horaria.
PostgreSQL
Emulación de la función La función LNNVL de Oracle/PLSQL se utiliza en la cláusula WHERE

LNNVL de Oracle para la de una instrucción SQL para evaluar una condición cuando uno de los
conversión a PostgreSQL operandos puede contener un valor NULL.
Emulación de la función La función TO_SINGLE_BYTE de Oracle/PLSQL devuelve un valor de

TO_SINGLE_BYTE de carácter con todos los caracteres multibyte convertidos en caracteres de
Oracle para la conversión a un solo byte. Para utilizar esta función, el conjunto de caracteres de la
PostgreSQL base de datos contiene caracteres de un solo byte y multibyte.
Emulación de la función La función TO_MULTI_BYTE de Oracle/PLSQL devuelve un valor

TO_MULTI_BYTE de de carácter con todos los caracteres de un solo byte convertidos en
Version 1.0
225

Oracle para la conversión a caracteres multibyte. Para utilizar esta función, el conjunto de caracteres
PostgreSQL de la base de datos contiene caracteres de un solo byte y multibyte.
Emulación de la función La función ROUND de Oracle/PLSQL devuelve una fecha redondeada a

ROUND(fecha [; formato ]) de una unidad de medida específica.
Oracle para la conversión a
PostgreSQL
Emulación de la función La función MEDIAN de Oracle/PLSQL devuelve la mediana de una

MEDIAN de Oracle para la expresión.
conversión a PostgreSQL
Emulación de la función La función LISTAGG de Oracle/PLSQL concatena los valores de la

LISTAGG de Oracle para la columna measure_column para cada cláusula GROUP en función del
conversión a PostgreSQL valor de order_by_clause.
Emulación de la función La función NANVL de Oracle/PLSQL le permite sustituir un valor por un

NANVL de Oracle para la número de punto flotante como BINARY_FLOAT o BINARY_DOUBLE
conversión a PostgreSQL cuando se encuentra un valor NaN (abreviatura en inglés de "no es un
número"). Es la que más se usa para convertir los valores NaN en NULL
o 0.
Emulación de la función La función INSTRB de Oracle/PLSQL devuelve la ubicación de una

INSTRB de Oracle para la subcadena en una cadena, utilizando bytes en lugar de caracteres.
Emulación de la función La función SUBSTRB de Oracle/PLSQL devuelve una parte de la

SUBSTRB de Oracle para la cadena; comenzando en una posición especificada de la cadena.
conversión a PostgreSQL La función SUBSTRB calcula las longitudes usando bytes para la
devolución.
Emulación de la función La función LENGTHB de Oracle/PLSQL devuelve la longitud de la

LENGTHB de Oracle para la cadena especificada, utilizando bytes en lugar de caracteres.
MSSQL: conversión de Convertir scripts T-SQL, DML y DDL en código o componentes

scripts a PostgreSQL equivalentes.
MSSQL: emulación de La función OBJECT_NAME(@@PROCID) de MS SQL Server devuelve

OBJECT_NAME(@@PROCID) el identificador de objeto (ID) del módulo T-SQL actual.
para la conversión a
PostgreSQL
MSSQL: emulación de La función OBJECT_SCHEMA_NAME(@@PROCID) de Microsoft SQL

OBJECT_SCHEMA_NAME(@@PROCID)
Server devuelve el nombre del esquema de la base de datos de los
para la conversión a objetos con ámbito de esquema.
PostgreSQL
MSSQL: emulación de vista La vista sysobject se puede emular mediante Ext.Pack durante una
sysobject para la conversión conversión de MS SQL Server a MySQL, Aurora MySQL o MariaDB.
a MySQL, Aurora MySQL o
MariaDB
Modificación del "modo de Cuando compare dos esquemas PostgreSQL con SCT, ya no necesitará
comparación" de SCT para implementar el esquema de servicio.
el módulo de replicación DDL
para PostgreSQL
Version 1.0
226
Mejora de la regla de "tablas La regla de tablas pequeñas tiene en cuenta el número de filas de la
pequeñas" (DISTSTYLE=ALL) tabla, en lugar de su tamaño.
para Redshift
Mejora del control de Según la configuración, SCT establece la compresión ZSTD

compresión ZSTD predeterminada en todas las columnas que no están incluidas en
SortKey (DistKey, opcional).
• Se ha solucionado un problema con la doble codificación UTF-8 en los extractores de datos para las
migraciones de Netezza a Redshift.
• Se ha solucionado un problema con la deserialización de YAML no segura en los archivos de
configuración de Cassandra.
• Mejoras en la conversión de Microsoft SQL Server a PostgreSQL.
• Se ha solucionado un problema por el que no se podía establecer conexión con el clúster de Cassandra
si la versión era 2.1.20. SCT ahora admite la migración desde Cassandra 2.1.20.

Agente de AWS DMS para Si está utilizando el agente de AWS DMS local para migrar datos a un
AWS SCT dispositivo AWS Snowball Edge o para Amazon S3, tenga en cuenta lo
siguiente:
• Si tiene tareas existentes en ejecución con el agente de DMS local

versión 2.4.1, debe migrar estas tareas a la última versión del agente
de DMS.
• No actualice Herramienta de conversión de esquemas de AWS hasta
después de actualizar el agente de DMS.
• Los siguientes componentes deben utilizar el mismo número de
versión del motor de replicación:
• El agente de DMS local.
• La instancia de DMS para la tarea remota.
Microsoft SQL Server a Cuando se utiliza SQL Server como origen, aparece un elemento nuevo
PostgreSQL: conversión de en el panel de origen: "SQL Scripts" (Scripts SQL). Si elige Actions |
scripts Load Scripts (Acciones | Cargar scripts) en el menú de AWS SCT, puede
elegir uno o varios archivos .sql para convertirlos. Durante la conversión,
AWS SCT vuelve a escribir los scripts para usarlos con PostgreSQL. Los
resultados se muestran en el panel de destino: "SQL Scripts" (Scripts
SQL).
El informe de evaluación de AWS SCT destaca los problemas

encontrados al convertir los scripts.
Version 1.0
227
Los extractores de datos El comando COPY puede sustituir NULL por un valor diferente:
permiten la sustitución del
valor NULL • COPY … FROM … NULL AS 'MyReplacementValue' …
• CREATE EXTERNAL TABLE … USING (REMOTESOURCE …
NULLVALUE 'MyReplacementValue' …)
Soporte para compresión Capacidad de elegir compresión ZSTD para las columnas de la tabla.
ZSTD en Redshift Nueva configuración del proyecto para elegir opciones de conversión:
• No utilice la compresión ZSTD.

• Utilice la compresión ZSTD en todas las columnas.
• Utilice la compresión ZSTD en todas las columnas excepto Distkey y
Sortkey.
Almacén de datos de Nueva configuración del proyecto para guardar scripts SQL:
Oracle: compatibilidad con
varios archivos durante la • Archivo único: todo el SQL se generará en un único archivo.
generación de scripts • Varios archivos: cada archivo contiene instrucciones SQL, incluido el
ID y el nombre de la etapa. Los scripts se deben ejecutar de uno en
uno, por orden de ID.
Workload Qualification Workload Qualification Framework (WQF) forma parte de AWS

Framework Database Migration Service (AWS DMS). Ayuda a analizar y planificar
las migraciones a los servicios de bases de datos de AWS. Para obtener
más información, consulte Creación de informes de migración con
Workload Qualification Framework (p. 88).
Problemas resueltos
• Microsoft SQL Server: no se puede crear informes de evaluación para una instancia con nombre.
• Oracle a PostgreSQL: un mensaje de error indica de forma incorrecta que no se admiten las vistas
materializadas.
• Microsoft SQL Server a PostgreSQL: Dynamic SQL se convierte de forma incorrecta.
• Informes de evaluación: los archivos PDF que contienen caracteres multibyte no se pueden guardar.
• Microsoft SQL Server a PostgreSQL: error en conversiones con NullPointerException.
• Extractores de datos OLAP: correcciones de errores para la partición virtual. (Para obtener más
información, consulte https://aws.amazon.com/blogs/database/use-virtual-partitioning-in-the-aws-
schema-conversion-tool).
• Uso de AWS SCT para crear una tarea en AWS DMS: corrección de errores. Se recomienda actualizar a
AWS SCT compilación 622 si necesita ejecutar una tarea de AWS DMS.

Version 1.0
228
Microsoft SQL Server a Las siguientes funciones de fecha y hora son compatibles con
MySQL: mejoras el paquete de extensión de AWS SCT: DATETIMEFROMPARTS,
DATETIME2FROMPARTS y TIMEFROMPARTS.
Ahora la función CHECKSUM es compatible.
Microsoft SQL Server a La función OBJECT_ID es compatible con el paquete de extensión de

PostgreSQL: mejoras AWS SCT.
En SQL Server, puede especificar ELEMENTS XSINIL en una consulta

para generar elementos XML, incluso para valores NULL en el conjunto
de resultados. AWS SCT reconoce la directiva XSINIL al convertir de
SQL Server a PostgreSQL y realiza la conversión de acuerdo con la
semántica de PostgreSQL.
AWS SCT es compatible con el uso de la función NEWID en scripts SQL

guardados. Para habilitar este comportamiento:
• En la barra de menú de AWS SCT, seleccione Settings

(Configuración) | Project settings (Configuración de proyecto).
• Elija Save as SQL and Apply (Guardar como SQL y Aplicar).
• Para Source database uses "newid()" function (La base de datos de
origen utiliza la función "newid()"), elija Yes (Sí).
• Seleccione OK.
Guardar código SQL para Puede guardar las instrucciones SQL que AWS SCT genera para crear
crear un árbol de origen el árbol de origen. En esta versión, los siguientes motores de bases de
datos son ahora compatibles: MySQL, PostgreSQL y Azure.
Compatibilidad para utilizar Amazon Aurora compatible con PostgreSQL es ahora compatible con
Amazon Aurora PostgreSQL la versión principal de PostgreSQL 10.4. AWS SCT es totalmente
10 como destino. compatible con el uso de esta nueva versión como destino.
Netezza como origen: AWS SCT reconoce tablas EXTERNAL en Netezza. Esto permite a AWS
mejoras SCT acceder a datos externos como si estuvieran almacenados de
forma nativa en Netezza.
Para que el rendimiento sea más rápido, AWS SCT utiliza la compresión
paralela al leer datos de Netezza.
El agente de extracción de AWS SCT utiliza el comando COPY de

Redshift para copiar datos de Netezza a Redshift. Puede controlar
el comportamiento del comando COPY mediante los siguientes
parámetros:
• extractor.redshift.copying.thread.pool.size—: el
número de comandos COPY que puede ejecutar el agente de forma
simultánea. El valor predeterminado es 1, lo que supone que el agente
ejecutará todos los comandos COPY de forma secuencial.
• extractor.redshift.copy.command.count.threshold—: el
número máximo de comandos COPY que se pueden ejecutar a la vez.
El valor predeterminado es 5.
Cuando el agente de extracción lee datos desde una única tabla

grande, escribe los datos en varias tablas más pequeñas en Amazon
Version 1.0
229

Redshift. Al final de la migración, estas tablas provisionales se unifican
en una única tabla grande en Redshift. Para limitar el número de tablas
provisionales que se permiten en Redshift, puede modificar el parámetro
extractor.redshift.staging.table.count.threshold. El
valor predeterminado es 100.
(Para obtener más información sobre cómo establecer estos parámetros,

consulte Configuración de agentes de extracción (p. 149)).
• Microsoft SQL Server a MySQL: AWS SCT admite operaciones aritméticas con tipos de operandos
mixtos.
• La partición virtual de AWS SCT es totalmente compatible con columnas que contengan el dato NULL.
Para obtener más información, consulte Uso de particiones virtuales con Herramienta de conversión de

Guardar instrucciones AWS SCT le permite guardar instrucciones SQL utilizadas para crear
CREATE en scripts SQL objetos de base de datos (CREATE TABLE, CREATE VIEW, CREATE
FUNCTION, etc.). Puede guardar todas las instrucciones en un script
SQL, guardar cada una de las instrucciones en un archivo de script SQL
independiente o guardar cada instrucción en su propio script SQL.
Para modificar este comportamiento, seleccione los ajustes Settings

(Configuración) | Project (Proyecto) en la barra de menú de AWS SCT, y
seleccione Save as SQL and Apply (Guardar como SQL y Aplicar).
Microsoft SQL Server a Estas funciones son compatibles con el paquete de extensión de AWS
MySQL: compatibilidad SCT.
con las funciones
CHECKSUM, ISNUMERIC y
NEWSEQUENTIALID
Oracle a MySQL: La instrucción MERGE de Oracle se utiliza para insertar, actualizar o

compatibilidad con MERGE eliminar filas, en función de si esas mismas filas existen actualmente
en la tabla. (Esta operación se denomina a veces "upsert"). MySQL
no es compatible con la instrucción MERGE; sin embargo, AWS SCT
puede migrar instrucciones MERGE a instrucciones INSERT, UPDATE y
DELETE compatibles con MySQL.
Microsoft SQL Server a AWS SCT puede migrar los datos de tipo TIMESTAMP desde SQL
MySQL: tipo de datos Server a MySQL.
TIMESTAMP
Version 1.0
230
Microsoft SQL Server a AWS SCT puede migrar funciones OPENXML desde SQL Server hasta
PostgreSQL: funciones MySQL.
OPENXML
Oracle a MySQL: cursores Oracle es compatible con cursores globales, en los que se
globales puede acceder a un cursor definido en una unidad del programa
(procedimiento, función o desencadenador almacenado) fuera de la
unidad del programa en la que se definió. MySQL no es compatible con
los cursores globales. Sin embargo, AWS SCT ofrece una funcionalidad
equivalente modificando el código de la unidad del programa en el
destino de MySQL.
Oracle a MySQL: datos AWS SCT puede migrar datos espaciales, objetos y funciones desde
espaciales Oracle hasta MySQL.
Oracle a MySQL: Este tipo de datos es compatible con el paquete de extensión de AWS
TIMESTAMP WITH TIME SCT.
ZONE
Tamaño de LOB definido por Ahora puede definir el tamaño máximo de objetos grandes (LOB) al
el usuario con AWS Snowball utilizar el agente de DMS de AWS SCT y AWS Snowball.
Problemas resueltos
• Oracle a PostgreSQL: solución de problemas de conversión leves.

• Las particiones ya no descartan los valores null.

Soporte de migración desde Puede utilizar AWS SCT con un agente de extracción de datos de AWS
Apache Cassandra a Amazon para migrar desde Apache Cassandra a Amazon DynamoDB. Para
DynamoDB obtener más información, consulte Migración de datos desde Apache
Cassandra a Amazon DynamoDB (p. 168).
Soporte para Vertica 9 como A partir de ahora, puede utilizar la versión Vertica 9 como origen de
origen de migración migración. Para obtener más información, consulte Utilizar Vertica como
origen para Herramienta de conversión de esquemas de AWS (p. 77).
Microsoft SQL Server a MySQL no es compatible con la palabra clave RETURN en

MySQL: soporte del valor procedimientos almacenados; sin embargo, se admiten los parámetros
RETURN de procedimiento OUT.
almacenado
Soporte de Azure SQL Ahora puede migrar desde Azure SQL Database a MySQL, PostgreSQL
Database como origen o Amazon Aurora (con compatibilidad con MySQL o PostgreSQL).
Version 1.0
231
Problemas resueltos
• Microsoft SQL Server a PostgreSQL: AWS SCT admite operaciones aritméticas con tipos de operandos
mixtos.
• Oracle Advanced Queuing (AQ) se admite al migrar a Amazon RDS para Oracle.

SQL dinámico en literales de Puede ejecutar una cadena de comandos o una cadena de caracteres
cadena dentro de un lote Transact-SQL o uno de los módulos siguientes:
procedimiento almacenado en el sistema, procedimiento almacenado
definido por el usuario, procedimiento almacenado de CLR, función
definida por el usuario de valor escalar o procedimiento almacenado
extendido. La instrucción EXECUTE se puede utilizar para enviar
comandos de paso a servidores vinculados. Además, el contexto en
el que se ejecuta una cadena o un comando se puede establecer
explícitamente. Los metadatos para el conjunto de resultados se pueden
definir utilizando las opciones WITH RESULT SETS.
Microsoft SQL Server AWS SCT admite la conversión de datos espaciales de MS SQL Server
a PostgreSQL: datos a PostgreSQL.
espaciales
MS SQL Server a MySQL: AWS SCT admite la conversión de datos espaciales de MS SQL Server
datos espaciales a MySQL.
Microsoft SQL Server AWS SCT admite la función @@ROWCOUNT de Microsoft SQL Server
a PostgreSQL: de MS SQL Server a PostgreSQL.
@@ROWCOUNT
Oracle a MySQL: formato La función TO_CHAR de Oracle acepta una amplia gama de caracteres
de cadenas para función de de formato. AWS SCT admite estas cadenas de formato de Oracle a
conversión TO_CHAR MySQL.
Oracle a MySQL: AWS SCT admite instrucciones INSERT y UPDATE que utilizan la
compatibilidad de la cláusula cláusula WITH, de Oracle a MySQL.
WITH para instrucciones
INSERT y UPDATE
Oracle a MySQL: formato La función TO_NUMBER de Oracle acepta una amplia gama de
de cadenas para función de caracteres de formato. AWS SCT admite estas cadenas de formato de
conversión TO_NUMBER Oracle a MySQL.
MS SQL Server a MySQL: La función sp_sequence_get_range de Microsoft SQL Server devuelve

sp_sequence_get_range un rango de valores de secuencia desde un objeto de secuencia. AWS
SCT admite esta función de MS SQL Server a MySQL.
Microsoft SQL Server a AWS SCT admite la función PARSE de Microsoft SQL Server, de MS
PostgreSQL: PARSE SQL Server a PostgreSQL.
Version 1.0
232
MS SQL Server: Puede guardar las instrucciones SQL que AWS SCT genera para crear
almacenamiento de código el árbol de origen.
SQL para crear un árbol de
origen
Problemas resueltos
• Los extractores de datos SCT ahora emiten comandos COPY para Redshift.
• Redshift: la función de ventana count(distinct) se tiene que reescribir a Redshift DENSE_RANK.
• La conversión de consultas utilizando las funciones FROM_TZ y EXTRACT de Oracle ahora se traducen
correctamente a equivalentes basados en Redshift, utilizando extract y convert_timezone.
• El informe de evaluación notifica de forma incoherente el número de objetos de código en la base de
datos de origen.
• Reescritura de la función INSTR de Oracle a función integrada de Redshift para más casos.
• Se ha añadido compatibilidad de comparación de esquemas PostgreSQL 9.x - PostgreSQL 10.

De Oracle a Amazon RDS for AWS SCT incorpora compatibilidad con perfiles de usuario, funciones
Oracle: objetos de nivel de de usuario, programas de eventos y mucho más. Para obtener más
servidor de Oracle información, consulte Conversión de Oracle a Amazon RDS for
Oracle (p. 42).
De SQL Server a Amazon El informe de evaluación de AWS SCT contiene información acerca de
RDS for SQL Server: la instancia de base de datos de Amazon RDS, así como los servicios
inclusión de métricas de SQL Server que se usan en la base de datos de origen. Para obtener
adicionales en el informe de más información, consulte Conversión de SQL Server a Amazon RDS
evaluación for SQL Server (p. 54).
De Oracle a Amazon RDS for El informe de evaluación de AWS SCT contiene información acerca de
Oracle: inclusión de métricas la instancia de base de datos de Amazon RDS, así como los servicios
adicionales en el informe de de Oracle que se usan en la base de datos de origen. Para obtener
evaluación más información, consulte Conversión de Oracle a Amazon RDS for
Oracle (p. 42).
De Oracle a PostgreSQL 10: AWS SCT admite TIMESTAMP sin columnas de zona horaria.
TIMESTAMP sin columnas de
zona horaria
De Oracle a PostgreSQL 10: Puede convertir las pseudocolumnas ROWID en columnas de datos.
columnas ROWID Para obtener más información, consulte Conversión de pseudocolumnas
ROWID de Oracle a PostgreSQL (p. 36).
Version 1.0
233
De SQL Server a AWS SCT convierte la instrucción MERGE al migrar a PostgreSQL. Para
PostgreSQL: emulación de la obtener más información, consulte Uso de Microsoft SQL Server como
instrucción MERGE origen para Herramienta de conversión de esquemas de AWS (p. 45).
De Oracle a MySQL: AWS SCT convierte las cláusulas WITH al migrar a MySQL. Para
cláusulas SELECT y WITH obtener más información, consulte Conversión de Oracle a Amazon
RDS for MySQL o Amazon Aurora (MySQL) (p. 38)
De SQL Server a MySQL: El paquete de extensión de AWS SCT emula varias funciones, incluidas
paquete de extensión ISDATE, FORMAT, PATINDEX y CONVERT.
De SQL Server a Puede utilizar tipos de tablas definidos por el usuario para especificar
PostgreSQL: tipos de tablas estructuras de tabla. Para obtener más información, consulte Uso de
definidos por el usuario Microsoft SQL Server como origen para Herramienta de conversión de
Oracle: almacenamiento de Puede guardar las instrucciones SQL que AWS SCT genera para crear
código SQL para crear un el árbol de origen.
árbol de origen
Problemas resueltos
• Mejoras en el informe de evaluación para objetos de nivel de servidor.

• Corrección del procesamiento incorrecto de los objetos que terminan con el bloque END.
• Adición de la fecha de generación del informe de evaluación en el archivo PDF.
• Adición de la lógica de generación de scripts para varios archivos en la opción Save as SQL.

De SQL Server a AWS SCT permite convertir SUSER_SNAME. Para obtener más
PostgreSQL: compatibilidad información, consulte Conversión de SQL Server PostgreSQL (p. 50).
con SUSER_SNAME
De SQL Server a AWS SCT permite convertir funciones con valores de tabla. Para
PostgreSQL: compatibilidad obtener más información, consulte Conversión de SQL Server
con funciones con valores de PostgreSQL (p. 50).
tabla
De Oracle a Amazon RDS for AWS SCT añade compatibilidad con muchos tipos de trabajos de Oracle
Oracle: trabajos de Oracle en Amazon RDS for Oracle.
De Oracle a Amazon RDS for Amazon RDS for Oracle no admite Oracle RAC. Considere la posibilidad
Oracle: Oracle RAC de utilizar una implementación Multi-AZ en una instancia de Amazon
RDS para obtener una alta disponibilidad.
Version 1.0
234
De Oracle a Amazon RDS for Amazon RDS for Oracle no admite Oracle Data Guard ni Active Data
Oracle: Oracle Data Guard y Guard. Considere la posibilidad de utilizar una implementación Multi-AZ
Active Data Guard en una instancia de Amazon RDS para obtener una alta disponibilidad.
De Oracle a Amazon RDS for Amazon RDS for Oracle no admite la replicación continua. Puede utilizar
Oracle: replicación continua AWS Database Migration Service si necesita tener replicación continua
en un destino de Amazon RDS.
De Oracle a Amazon RDS for Amazon RDS para Oracle no admite Oracle Unified Auditing. Amazon
Oracle: auditorías RDS for Oracle admite las auditorías tradicionales y detalladas (paquete
DBMS_FGA).
De Oracle a Amazon RDS AWS SCT permite convertir objetos de Oracle DBMS_SCHEDULER al
for Oracle: objetos de migrar a Amazon RDS for Oracle.
programación
De SQL Server a MySQL: MySQL no admite funciones con valores de tabla compuestas de varias
funciones con valores de instrucciones. AWS SCT simula las funciones con valores de tabla
tabla durante una conversión mediante la creación de tablas temporales. Para
obtener más información, consulte Uso de Microsoft SQL Server como
origen para Herramienta de conversión de esquemas de AWS (p. 45).
Actualizaciones del informe Las actualizaciones del informe de evaluación de AWS SCT incluyen las
de evaluación de AWS SCT siguientes:
• Muestra el tamaño de las bases de datos en una instancia de base de

datos de Amazon RDS
• Muestra la cantidad de almacenamiento usado en una instancia de
base de datos de Amazon RDS
• Muestra el número de bases de datos en una instancia de base de
datos de Amazon RDS
• Muestra si las bases de datos incluidas en una migración ya se están
utilizando para la replicación
De SQL Server a Amazon Amazon RDS no admite actualmente SQL Server Service Broker ni
RDS for SQL Server: Service puntos de enlace de T-SQL adicionales que usen el comando CREATE
Broker y puntos de enlace ENDPOINT. Para obtener más información, consulte Uso de Microsoft
SQL Server como origen para Herramienta de conversión de esquemas
de AWS (p. 45).
De Db2 LUW a PostgreSQL AWS SCT puede convertir tablas de Db2 LUW en tablas particionadas
10: tablas particionadas de PostgreSQL 10.
Problemas resueltos
• De Db2 LUW a Amazon RDS for MySQL o Amazon Aurora (MySQL). Se ha añadido la capacidad de
mostrar el código SQL de destino para varios objetos relacionados transformados.
• De Db2 LUW a Amazon RDS for PostgreSQL o Amazon Aurora (PostgreSQL). Se ha añadido la
capacidad de mostrar el código SQL de destino para varios objetos relacionados transformados.
• De MySQL a Amazon RDS for PostgreSQL o Amazon Aurora (PostgreSQL). Se ha añadido la capacidad
de mostrar el código SQL de destino para varios objetos relacionados transformados.
• OLAP. Se ha añadido la capacidad de mostrar el código SQL de destino para varios objetos
relacionados transformados.
• Se ha resuelto el problema de AWS SCT de conversión de MySQL a MySQL.
Version 1.0
235

De SQL Server a MySQL: MySQL no admite la instrucción MERGE; sin embargo, AWS SCT
compatibilidad con la puede emular esta instrucción utilizando la cláusula INSERT ON
instrucción MERGE DUPLICATE KEY y las instrucciones UPDATE FROM y DELETE FROM.
Para obtener más información, consulte Conversión de SQL Server a
MySQL (p. 49).
De SQL Server a AWS SCT permite generar nombres de índice únicos si los nombres de
PostgreSQL: compatibilidad los índices no lo son. Para ello, seleccione la opción Generate unique
para crear nombres de índice index names (Generar nombres de índice únicos) en las propiedades del
únicos proyecto. Para obtener más información, consulte Conversión de SQL
Server PostgreSQL (p. 50).
De Oracle a PostgreSQL: En los proyectos de migración de Oracle a PostgreSQL, seleccione la

impedir valores superpuestos opción Populate converted sequences with the last values generated
en secuencias de bases de on the source side (Rellenar las secuencias convertidas con los últimos
datos valores generados en el origen) en la pestaña de ajustes de conversión
de Project Settings (Configuración del proyecto). Para obtener más
información, consulte Conversión de Oracle a Amazon RDS for
PostgreSQL o Amazon Aurora (PostgreSQL) (p. 35).
De Oracle a PostgreSQL: Cuando AWS SCT convierte un esquema de una base de datos
compatibilidad con las de Oracle en una base de datos de PostgreSQL, puede emular
particiones de PostgreSQL 10 particiones y subparticiones. Para obtener más información, consulte
Conversión de Oracle a Amazon RDS for PostgreSQL o Amazon Aurora
(PostgreSQL) (p. 35).
De SQL Server a Cuando AWS SCT convierte un esquema de una base de datos de SQL
PostgreSQL: compatibilidad Server en una base de datos de PostgreSQL, puede emular particiones
con las particiones de y subparticiones. Para obtener más información, consulte Conversión
PostgreSQL 10 de SQL Server PostgreSQL (p. 50).
De SQL Server a MySQL: MySQL no utiliza instrucciones GOTO. Cuando AWS SCT convierte
compatibilidad con la código que contiene la instrucción GOTO, convierte esta instrucción para
instrucción GOTO utilizar en su lugar la instrucción BEGIN...END o LOOP...END LOOP.
De SQL Server a PostgreSQL no utiliza instrucciones GOTO. Cuando AWS SCT convierte
PostgreSQL: compatibilidad código que contiene la instrucción GOTO, convierte esta instrucción para
con la instrucción GOTO utilizar en su lugar la instrucción BEGIN...END o LOOP...END LOOP.
De Oracle a PostgreSQL: PostgreSQL no utiliza instrucciones GOTO. Cuando AWS SCT convierte
compatibilidad con la código que contiene la instrucción GOTO, convierte esta instrucción para
instrucción GOTO utilizar en su lugar la instrucción BEGIN...END o LOOP...END LOOP.
De DB2 LUW a PostgreSQL: AWS SCT puede convertir diversas instrucciones TRIGGER que
compatibilidad con se utilizan con DB2 LUW. Para obtener más información, consulte
disparadores de DB2 en Conversión de DB2 LUW a Amazon RDS for PostgreSQL o Amazon
PostgreSQL Aurora (PostgreSQL) (p. 64)
Version 1.0
236
De SQL Server a Amazon AWS SCT puede añadir disparadores de bases de datos al árbol de
RDS for SQL Server: objetos cuando el destino es Amazon RDS for SQL Server.
compatibilidad con los
disparadores de nivel de base
de datos
De SQL Server a Amazon AWS SCT ahora es compatible con los disparadores de nivel de
RDS for SQL Server: servidor, los servidores enlazados y los agentes de SQL Server. Para
compatibilidad con obtener más información, consulte Uso de Microsoft SQL Server como
disparadores de nivel origen para Herramienta de conversión de esquemas de AWS (p. 45).
de servidor, servidores
enlazados y agentes SQL
Server
De Oracle a Amazon RDS AWS SCT puede añadir objetos de directorio en el árbol de objetos.
for Oracle: compatibilidad Para obtener más información, consulte Uso de Microsoft SQL
con objetos de directorio, Server como origen para Herramienta de conversión de esquemas de
espacios de tabla y funciones AWS (p. 45).
y privilegios de usuario
Compatibilidad con la versión Ahora, AWS SCT es compatible con IBM Db2 LUW versión 10.1.
10.1 de Db2
Se ha agregado la Ahora, AWS SCT admite regiones gubernamentales aisladas.

compatibilidad con regiones
gubernamentales aisladas
Problemas resueltos
• Perfil de AWS. Uso de credenciales federadas.

• De DB2 a PostgreSQL. Conversión de disparadores de DB2.
• Migración de OLAP. Ajustes actuales del proyecto: valor de umbral descompensado. Se ha modificado la
compatibilidad con los porcentajes.
• Informe de evaluación. Marcar tablas de LOB sin clave principal.
• Se han corregido algunos errores de la interfaz de usuario.

Oracle a PostgreSQL: AWS SCT puede convertir archivos SQL*Plus a PSQL. El informe
informe de evaluación para la de evaluación muestra cómo ha convertido AWS SCT los archivos
conversión de SQL*Plus SQL*Plus a PSQL. Para obtener más información, consulte Uso de
Oracle como origen para Herramienta de conversión de esquemas de
AWS (p. 31).
Version 1.0
237
Compatibilidad con la versión Se agregó compatibilidad para convertir esquemas de Aurora MySQL
Aurora MySQL 5.7 5.7.
Db2 LUW 9.1 Se agregó compatibilidad con Db2 LUW 9.1.
Migración de datos OLTP. La compresión de datos durante la migración ahora es opcional al

Compresión de datos. configurar una tarea mediante un agente de replicación.
Oracle a Oracle RDS: Las migraciones de Oracle a Oracle RDS ahora admiten enlaces
compatibilidad con enlaces de base de datos. Para obtener más información, consulte Uso de
de base de datos Oracle como origen para Herramienta de conversión de esquemas de
AWS (p. 31).
Oracle a PostgreSQL: Las instrucciones SQL con BULK COLLECT (VARRAY) ahora se
conversión de SELECT INTO pueden convertir al migrar entre Oracle y PostgreSQL.
BULK COLLECT (VARRAY)
Conversión de comentarios Se agregó compatibilidad para convertir los comentarios de Oracle al

de Oracle formato que utiliza el motor de base de datos de destino. Para obtener
más información, consulte Uso de Oracle como origen para Herramienta
de conversión de esquemas de AWS (p. 31).
Emulación de objetos del Se agregó compatibilidad para convertir objetos del sistema de Oracle
sistema de Oracle a PostgreSQL. Para obtener más información, consulte Uso de
Oracle como origen para Herramienta de conversión de esquemas de
AWS (p. 31).
Oracle a PostgreSQL: Se agregó compatibilidad para convertir ROWNUM.

conversión de ROWNUM a
LIMIT
Microsoft SQL Server Se agregó compatibilidad para convertir BULK INSERT y

a Microsoft SQL Server OPENROWSET()
RDS: BULK INSERT y
OPENROWSET()
Microsoft SQL Server a AWS SCT ahora admite enlaces en los objetos almacenados durante
Microsoft SQL Server RDS: una migración a Amazon RDS. Para obtener más información, consulte
enlaces en los objetos de Uso de Microsoft SQL Server como origen para Herramienta de
almacenamiento conversión de esquemas de AWS (p. 45).
Microsoft SQL Server a AWS SCT ahora admite la conversión de PATINDEX durante una
PostgreSQL: PATINDEX migración a PostgreSQL. Para obtener más información, consulte Uso
de Microsoft SQL Server como origen para Herramienta de conversión
de esquemas de AWS (p. 45).
Microsoft SQL Server a Los objetos del sistema de SQL Server ahora se convierten a objetos en
PostgreSQL: acceso a los PostgreSQL. Para obtener más información, consulte Uso de Microsoft
objetos del sistema SQL Server como origen para Herramienta de conversión de esquemas
de AWS (p. 45).
Microsoft SQL Server a Se agregó compatibilidad con las funciones en línea. Para obtener más
PostgreSQL: creación de información, consulte Uso de Microsoft SQL Server como origen para
funciones en línea Herramienta de conversión de esquemas de AWS (p. 45).
Problemas resueltos
Version 1.0
238
• Mapeo de tipos. Mejoras y correcciones de errores.

• Conversión OLAP. Estrategias de optimización. Corrección de la capacidad para restablecer estrategias.
• Oracle a PostgreSQL. Corrección de errores y mejoras en la conversión de SQL dinámico
• Conversión de scripts SQL*Plus. Mejoras y correcciones de errores
• Conversión de Oracle a PostgreSQL Corrección del reconocimiento de variables de enlace.
• Se agregó la capacidad de actualizar la información del servidor haciendo clic en "Update server
info" (Actualizar información del servidor) en el nivel del servidor.
• Netezza. Corrección de la conversión de esquemas para los objetos en minúsculas.
• Tratamiento de algunos caracteres específicos en los nombres de los nodos del árbol de navegación de
AWS SCT derivados de nombres de archivo

Compatibilidad con DB2 LUW Se agregó compatibilidad con la migración de una base de datos DB2
como origen. Para obtener más información, consulte Convertir los
esquemas de base de datos utilizando el Herramienta de conversión de
Conversión de Oracle a Ahora puede convertir archivos SQL*Plus

PostgreSQL Se agregó
la conversión de archivos
SQL*Plus
Se agregó la pestaña Se agregó una nueva pestaña Snowball para la migración de datos
Snowball a la migración de OLTP que muestra el estado actual de un dispositivo Snowball para
datos OLTP un proyecto concreto. Para obtener más información, consulte Uso de
agentes de extracción de datos (p. 144).
Conversión de Oracle a Conversión de Oracle a PostgreSQL. El código espacial de Oracle se

PostgreSQL. Conversión de convierte a PostGIS.
código espacial de Oracle a
PostGIS
open
La comparación de Ahora puede ejecutar la comparación de esquemas con Oracle 10. Para
esquemas ahora es obtener más información, consulte Comparación de esquemas de bases
compatible con Oracle 10 de datos (p. 112)
Conversión de Oracle a Durante la conversión de Oracle a PostgreSQL, SCT agrega la

PostgreSQL Conversión de conversión de tipo de datos.
tipos implícita de la base de
datos de Oracle controlada
en PostgreSQL
SQL Server, autenticación de SQL Server. Se agregó la compatibilidad del método de conexión de
Windows autenticación de Windows.
Version 1.0
239
Conversión de SQL Server a Se agregó la compatibilidad con el tipo CITEXT. Ahora puede elegirlo
PostgreSQL con el tipo de datos mappint.
Conversión de Oracle a Mejoras adicionales en la conversión de SQL dinámico para EXECUTE

PostgreSQL IMMEDIATE y DBMS_SQL, y los cursores.
Conversión de Oracle a Se agregó compatibilidad la conversión de SELECT INTO BULK

PostgreSQL COLLECT de Oracle a PostgreSQL.
Conversión de Oracle a Ahora se puede convertir una matriz asociativa de Oracle a PostgreSQL.
PostgreSQL
Mapeo de tipos: mejoras Se agregó la capacidad de seleccionar tipos de datos de origen según la
en el mapeo de tipos longitud y la precisión.
personalizados
Configuración de perfil de Se agregó la posibilidad de seleccionar un perfil predeterminado en la

AWS configuración de perfil de AWS.
Conversión de Greenplum a Se agregaron funciones SQL integradas a la conversión de UDF SQL

Redshift escalar de Redshift.
Problemas resueltos
Fecha de notificación Descripción
Posterior a la versión 612 • Conversión de Oracle a Redshift. CAST a CHAR funciona, CAST a
CHARACTER no funciona.
• Los comentarios en tablas no se crean en el DDL de la base de datos
de Oracle de origen.
• La discrepancia de tipos no se marca en el informe de evaluación.
• Conversión de Oracle a PostgreSQL Se realiza una conversión
incorrecta del nombre de tabla de alfabeto en mayúsculas de ancho
completo al nombre de tabla de alfabeto en minúsculas de ancho
completo.
• La ventana de configuración global no se puede cerrar haciendo clic
en el botón Aceptar.
• Oracle a Redshift. La reescritura de to_date y de resta ofrece un
resultado distinto.

Version 1.0
240
Mapeo de tipos de datos Ahora puede configurar reglas de mapeo para cambiar el tipo de
personalizados datos de los objetos de almacenamiento. El tipo de datos que debe
modificarse se define en la pestaña Mapping Rules (Reglas de mapeo).
Se ha añadido una opción Una nueva opción "What's New" (Novedades) en el menú Help (Ayuda)
con las novedades muestra todas las características principales que se han añadido a esta
versión.
La comparación de Ahora puede ejecutar la comparación de esquemas con Oracle 10.

esquemas ahora es
compatible con Oracle 10
Conversión de Oracle a La migración de Oracle a PostgreSQL ahora admite:

PostgreSQL
• Variables globales
• Matrices asociativas
• Cadenas de formato para la función TO_NUMBER
• Conversión de SQL dinámico con el paquete DBMS_SQL
• Conversión de varios subprogramas anidados con variables globales
Se ha agregado Se ha agregado compatibilidad para cargar los atributos de función

compatibilidad para cargar IMMUTABLE, STABLE y VOLATILE de PostgreSQL.
algunos atributos de función
y restricciones de dominio de Se ha agregado compatibilidad para cargar restricciones de dominio de
PostgreSQL PostgreSQL.
Problemas resueltos
Posterior a la versión 611 • APPLY se reconoce como palabra clave para Oracle.
• Se ha corregido un error al ejecutar la comparación de esquemas para
un proyecto de Oracle a Oracle.
• Mejoras generales basadas en los comentarios y correcciones de
errores para las migraciones de Microsoft SQL Server a Microsoft SQL
Server.
• Falta DROP FOREIGN KEY CONSTRAINTS cuando se utiliza Save
as SQL (Guardar como SQL) para las migraciones de Oracle a
PostgreSQL.
• Correcciones de errores de conversión en las funciones TO_DATE y
TRUNC para las migraciones de Oracle a Redshift.
errores para las migraciones de PostgreSQL a PostgreSQL.
errores para las migraciones de MySQL a MySQL.
errores para las migraciones de Oracle a Oracle.
• Reescritura de NUMTOINTERVL() para un literal de intervalo de
Redshift para las migraciones de Oracle a Redshift.
• Optimización del desempeño.
Version 1.0
241

Comparación de esquemas Se ha añadido la posibilidad de comparar bases de datos de MySQL

de MySQL a MySQL a MySQL. Para obtener más información, consulte Comparación de
esquemas de base de datos.
Conversión de instrucciones Se ha añadido la primera versión que admite conversión del paquete
dinámicas de Oracle a DBMS_SQL. Para obtener más información, consulte Conversión de
PostgreSQL SQL dinámico para migraciones de Oracle a PostgreSQL.
Conversión de instrucciones PostgreSQL no admite el operador GOTO en funciones como Oracle,

GOTO de Oracle a pero se puede convertir utilizando el bucle BEGIN/END o LOOP/END.
PostgreSQL
Abrir el archivo de registro Si aparece un error, puede hacer clic en él para obtener acceso al
desde el mensaje de error archivo log asociado, en lugar de tener que buscarlo por todo el sistema
de origen.
Se ha añadido el campo El campo de complejidad estimada se exportaba en la versión .pdf

de complejidad estimada al del informe de evaluación, pero no se incluía en la versión .csv. Para
archivo de exportación PDF obtener más información, consulte Creación y uso del informe de
del informe de evaluación evaluación en AWS Schema Conversion Tool.
Migración de datos OLAP. Después de una migración a Amazon Redshift, el agente puede
Se ha añadido la opción de conservar o eliminar los archivos cargados. Para obtener más
no eliminar archivos en S3 información, consulte Optimización de Amazon Redshift mediante AWS
después de una copia de Schema Conversion Tool .
Redshift
Migración de datos OLAP. Se ha añadido la posibilidad de migrar columnas de LOB. Para obtener
Se ha añadido compatibilidad más información, consulte Migración de LOB a Amazon Redshift.
con la migración de LOB para
Greenplum, Vertica, Netezza
y Microsoft SQL Server.
Se ha añadido la capacidad Cuando AWS SCT transforma el objeto de origen en varios objetos de
de ver objetos relacionados destino, ahora puede ver una lista completa de los objetos relacionados
para conversiones como que se han creado. Para obtener más información, consulte Búsqueda
Oracle en MySQL o Aurora de objetos transformados relacionados .
para MySQL y Microsoft SQL
en MySQL o Aurora para
MySQL.
Extractores de datos OLAP. Durante la instalación o la configuración, puede recuperar el agente si el

Se ha añadido la posibilidad puerto o la ubicación cambian. Para obtener más información, consulte
de recuperar el agente Ocultar y recuperar Information de un agente de AWS SCT .
después de reinstalarlo
Version 1.0
242
Capacidad de ocultar Puede decidir qué objetos e información de sus esquemas desea ver
esquemas en la vista de árbol en la vista de árbol. Para obtener más información, consulte Ocultar
esquemas en la vista de árbol de AWS SCT .
Compatibilidad con Ahora puede administrar tablas sin particiones de gran tamaño mediante
particiones virtuales la creación de subtareas que creen particiones virtuales de los datos
de la tabla utilizando reglas de filtrado. Para obtener más información,
consulte Uso de particiones virtuales con Herramienta de conversión de
Problemas resueltos
Posterior a la versión 608 • Migración de datos OLTP. Se ha añadido la capacidad de actualizar

los registros de agente/tarea.
• Comparación de esquemas de Oracle a Oracle. Se ha solucionado la
comparación de sinónimos públicos.
• Se ha solucionado la capacidad de ocultar el esquema del sistema de
la vista de árbol.
• Se ha añadido una ayuda contextual para el filtro de árbol. Permite
a los usuarios cargar archivos .csv con objetos que tienen que ser
filtrados.
• Conversión solucionada de NUMTOINTERVAL de Oracle a un literal
de intervalo Redshift, si corresponde.
• Conversión de Oracle a Redshift. Se ha solucionado la migración
de una SUBSTR de Redshift con un segundo parámetro constante
(inicio de substr) para que sea una expresión sencilla, en lugar de una
instrucción CASE.
• Migración de datos OLAP. Se ha añadido la descripción de partición
virtual.
Version 1.0
243
Historial de revisión
En la siguiente tabla se describen los cambios importantes en la guía del usuario de AWS Schema
Conversion Tool después de enero de 2018.
Puede suscribirse a una fuente RSS para recibir notificaciones de las actualizaciones de esta
documentación.
update-history-change update-history-description update-history-date
Compilaciones 1.0.632 de AWS Interfaz de usuario de SCT: se November 19, 2019

SCT ha agregado una nueva pestaña
para mostrar los errores que
se producen al aplicar scripts.
Ahora puede guardar el árbol
de origen como SQL al convertir
desde SAP ASE. Mejoras para
las conversiones a PostgreSQL,
Aurora PostgreSQL o Redshift.
Compilaciones 1.0.631 y 1.0.630 Se ha mejorado la compatibilidad September 30, 2019

(combinadas) de AWS SCT con ROWID en Oracle y con los
objetos del sistema en Microsoft
SQL Server y SAP ASE. Se ha
mejorado el tratamiento de los
especificadores que faltan en los
esquemas de SQL Server. Se ha
mejorado la compatibilidad con
las conversiones de Greenplum
a Redshift. Se ha mejorado la
compatibilidad con la conversión
de código almacenado al migrar
a Amazon Redshift, MariaDB,
MySQL y PostgreSQL.
AWS SCT compilación 1.0.629 Compatibilidad con August 20, 2019

procedimientos almacenados
para conversiones de Netezza.
Se ha mejorado la compatibilidad
con las conversiones a Amazon
Redshift, DynamoDB, MySQL
y PostgreSQL. Se ha añadido
compatibilidad con SAP ASE
12.5 como origen.
AWS SCT compilación #1.0.628 Compatibilidad con la emulación June 22, 2019
de servicios para conversiones
de DB2, SQL Server y Oracle.
Mejoras de las conversiones a
Amazon Redshift, incluida más
compatibilidad con cursores y
procedimientos almacenados.
AWS SCT compilación #1.0.627 Compatibilidad con las May 31, 2019
conversiones de SQL Server a
Version 1.0
244
procedimientos almacenados en
Amazon Redshift Mejoras en las
conversiones a PostgresSQL 11
y MySQL 8.0.
AWS SCT compilación #1.0.626 PostgresSQL 11 y MySQL 8.0 April 26, 2019
son ahora objetivos compatibles.
SAP ASE 15.5 es ahora una
fuente compatible.
AWS SCT compilación #1.0.625 Las actualizaciones incluyen March 25, 2019
la capacidad de convertir
Teradata BTEQ a AWS Glue,
compatibilidad con conversiones
a MariaDB 10.3 con modo de
compatibilidad con Oracle,
compatibilidad con SAP ASE
15.7 y sustituciones de servicio
para emular la funcionalidad que
falta.
AWS SCT compilación #1.0.624 Las actualizaciones incluyen February 22, 2019
la capacidad de convertir ETL
de Oracle a AWS Glue, y
compatibilidad de conversiones
de Microsoft SQL Server, Oracle
y IBM Db2 LUW a Amazon
RDS for MariaDB. También se
ha agregado compatibilidad
con conversiones de SAP ASE
a RDS for MySQL y Amazon
Aurora con compatibilidad con
MySQL. Además, hemos añadido
compatibilidad con la extensión
Orafce durante la conversión de
Oracle a PostgreSQL.
AWS SCT compilación #1.0.623 Las actualizaciones incluyen January 25, 2019
la capacidad de convertir las
bases de datos de SAP ASE
y la capacidad de convertir
scripts de T-SQL, DML y DDL
en código o componentes
equivalentes. También se han
añadido emulaciones de Oracle
y Microsoft SQL Server para
mejorar las conversiones.
AWS SCT compilación #1.0.622 Las actualizaciones incluyen December 20, 2018
Workload Qualification
Framework, que analiza la
carga de trabajo de la migración
completa, incluida la base de
datos y las modificaciones de la
aplicación.
Version 1.0
245
AWS SCT compilación #1.0.621 Entre las actualizaciones se November 21, 2018
incluyen la compatibilidad con
Aurora PostgreSQL 10 como
destino y la capacidad de
migrar desde Netezza utilizando
opciones de tablas externas.
AWS SCT compilación #1.0.620 Entre las actualizaciones se October 22, 2018
incluyen la capacidad de guardar
scripts SQL y compatibilidad con
cursores globales de Oracle al
migrar a MySQL.
AWS SCT compilación #1.0.619 Las actualizaciones incluyen September 20, 2018
soporte para migrar desde
Apache Cassandra a DynamoDB
y compatibilidad con Vertica 9
como origen.
AWS SCT compilación #1.0.618 Las actualizaciones incluyen August 24, 2018
informes de evaluación
ampliados, compatibilidad para
convertir las pseudocolumnas
ROWID de Oracle y
compatibilidad con las tablas
definidas por el usuario de SQL
Server.
AWS SCT compilación #1.0.617 Las actualizaciones incluyen July 24, 2018
informes de evaluación
ampliados, compatibilidad para
convertir las pseudocolumnas
ROWID de Oracle y
compatibilidad con las tablas
definidas por el usuario de SQL
Server.
AWS SCT compilación #1.0.616 Las actualizaciones incluyen June 26, 2018
compatibilidad con RDS al
convertir de Oracle a Amazon
RDS for Oracle y al convertir
objetos de programación de
Oracle, así como compatibilidad
con trabajos de Oracle.
Particiones y Db2 LUW versión
10.1.
AWS SCT compilación #1.0.615 Las actualizaciones permite May 24, 2018
convertir SQL Server a
instrucciones GOTO de
PostgreSQL, particiones de
PostgreSQL 10 y Db2 LUW
versión 10.1.
Version 1.0
246
Actualizaciones anteriores
AWS SCT compilación #1.0.614 Las actualizaciones permite April 25, 2018
convertir de Oracle a Oracle DB
Links, de SQL Server a funciones
insertadas de PostgreSQL y
emulación de objetos del sistema
de Oracle.
AWS SCT compilación #1.0.613 Las actualizaciones incluyen March 28, 2018
compatibilidad de Db2 LUW,
conversión de archivos de
SQL*Plus y autenticación de
Windows en SQL Server.
AWS SCT compilación #1.0.612 Las actualizaciones incluyen February 22, 2018
compatibilidad con la asignación
de tipos de datos personalizados,
comparación de esquemas
de Oracle 10 y conversión de
variables globales de Oracle a
PostgreSQL.
AWS SCT compilación #1.0.611 Las actualizaciones incluyen January 23, 2018
compatibilidad de Oracle con
instrucciones dinámicas de
PostgreSQL, la apertura de un
archivo log seleccionando un
mensaje de error y la capacidad
de ocultar esquemas en la vista
de árbol.
En la siguiente tabla se describen los cambios importantes en la guía del usuario de AWS Schema
Conversion Tool antes de enero de 2018.
Versión Cambio Descripción Fecha de

modificación
1.0.608 Compatibilidad Ahora puede solicitar a la AWS SCT que se 17 de noviembre

con puntos de conecte a Amazon S3 and Amazon Redshift de 2017
enlace de FIPS usando puntos de enlace de FIPS si tiene
para Amazon S3 que cumplir con los requisitos de seguridad
del Estándar federal de procesamiento de la
información. Para obtener más información,
consulte Almacenamiento de las credenciales
de AWS (p. 14).
1.0.607 Compatibilidad Ahora puede solicitar a la AWS SCT que se 30 de octubre

con puntos de conecte a Amazon S3 and Amazon Redshift de 2017
enlace de FIPS usando puntos de enlace de FIPS si tiene
para Amazon S3 que cumplir con los requisitos de seguridad
del Estándar federal de procesamiento de la
información. Para obtener más información,
consulte Almacenamiento de las credenciales
de AWS (p. 14).
Version 1.0
247

modificación
1.0.607 Las tareas de Al crear tareas de extracción de datos, ahora 30 de octubre

extracción de puede optar por omitir los objetos grandes de 2017
datos pueden (LOB) para reducir la cantidad de datos que
hacer caso va a extraer. Para obtener más información,
omiso de LOB consulte Creación, ejecución y monitorización
de una tarea de extracción de datos de AWS
SCT (p. 154).
1.0.605 Acceso al A partir de ahora, puede obtener acceso al 28 de agosto de

registro de registro de tareas del agente de extracción de 2017
tareas del datos desde un práctico enlace en la interfaz
agente de de usuario de Herramienta de conversión
extracción de de esquemas de AWS. Para obtener más
datos información, consulte Creación, ejecución y
monitorización de una tarea de extracción de
datos de AWS SCT (p. 154).
1.0.604 Mejoras del El motor de Herramienta de conversión 24 de junio de

convertidor de esquemas de AWS ha sido mejorado 2017
para ofrecer conversiones más eficaces en
migraciones heterogéneas.
1.0.603 Filtros de A partir de ahora, podrá filtrar los datos que 16 de junio de
soporte de extraen los agentes de extracción de su data 2017
agentes de warehouse. Para obtener más información,
extracción de consulte Creación de filtros de extracción de
datos datos en la Herramienta de conversión de
1.0.603 AWS SCT es A partir de ahora, puede utilizar Herramienta de 16 de junio de

compatible conversión de esquemas de AWS para convertir 2017
con versiones sus esquemas Teradata 13 y Oracle Data
adicionales de Warehouse 10 a esquemas Amazon Redshift
almacenes de equivalentes. Para obtener más información,
datos consulte Conversión de esquemas de almacén
de datos a Amazon Redshift utilizando la
Herramienta de conversión de esquemas de
AWS (p. 114).
1.0.602 Los agentes A partir de ahora puede usar agentes de 11 de mayo de

de extracción extracción de datos para extraer datos desde 2017
de datos son sus data warehouses Microsoft SQL Server.
compatibles Para obtener más información, consulte Uso de
con data agentes de extracción de datos (p. 144).
warehouses
adicionales
Version 1.0
248

modificación
1.0.602 Los agentes de Ahora, los agentes de extracción de datos 11 de mayo de

extracción de tienen tres modelos de carga. A partir de 2017
datos pueden ahora, puede especificar si desea simplemente
copiar datos extraer los datos, extraerlos y cargarlos en
a Amazon Amazon S3 o extraerlos, cargarlos y copiarlos
Redshift directamente en Amazon Redshift. Para obtener
más información, consulte Creación, ejecución
y monitorización de una tarea de extracción de
datos de AWS SCT (p. 154).
1.0.601 AWS SCT es A partir de ahora, puede utilizar la Herramienta 18 de abril de

compatible con de conversión de esquemas de AWS para 2017
almacenes convertir sus esquemas Vertica y Microsoft
de datos SQL Server a esquemas Amazon Redshift
adicionales equivalentes. Para obtener más información,
consulte Conversión de esquemas de almacén
AWS (p. 114).
1.0.601 Los agentes A partir de ahora puede usar agentes de 18 de abril de

de extracción extracción de datos para extraer datos desde 2017
de datos son sus data warehouses Greenplum, Netezza y
compatibles Vertica. Para obtener más información, consulte
con data Uso de agentes de extracción de datos (p. 144).
warehouses
adicionales
1.0.601 Los agentes A partir de ahora, puede instalar agentes 18 de abril de

de extracción de extracción de datos en equipos que 2017
de datos son ejecuten los sistemas operativos macOS
compatibles y Microsoft Windows. Para obtener más
con sistemas información, consulte Instalación de agentes de
operativos extracción (p. 147).
adicionales
1.0.601 Los agentes A partir de ahora, los agentes de extracción de 18 de abril de

de extracción datos cargan sus datos extraídos a Amazon 2017
de datos S3 automáticamente. Para obtener más
realizan cargas información, consulte Resultado de la tarea de
a Amazon S3 extracción de datos (p. 162).
automáticamente
1.0.600 Agentes de A partir de ahora, puede instalar agentes de 16 de febrero de

extracción de extracción de datos que extraen los datos de 2017
datos su almacén de datos y prepararlos para su
uso con Amazon Redshift. Puede utilizar la
AWS para registrar los agentes y crear las
tareas de extracción de datos para los mismos.
Para obtener más información, consulte Uso de
agentes de extracción de datos (p. 144).
Version 1.0
249

modificación
1.0.600 Opinión de Ahora puede expresar sus comentarios sobre 16 de febrero de

cliente la Herramienta de conversión de esquemas de 2017
AWS. Puede archivar un informe de errores,
enviar una solicitud de función o proporcionar
información general. Para obtener más
información, consulte Proporcionar opiniones
del cliente (p. 3).
1.0.502 Integración con A partir de ahora, puede utilizar Herramienta 20 de diciembre

AWS DMS de conversión de esquemas de AWS para de 2016
crear puntos de conexión y tareas AWS DMS.
Puede ejecutar y monitorizar las tareas desde
la AWS SCT. Para obtener más información,
consulte Uso de la Herramienta de conversión
de esquemas de AWS con el AWS Database
Migration Service (p. 143).
1.0.502 Amazon Aurora A partir de ahora, la Herramienta de conversión 20 de diciembre

compatible con de esquemas de AWS admite Amazon de 2016
PostgreSQL Aurora compatible con PostgreSQL como
como base de base de datos de destino. Para obtener más
datos de destino información, consulte Convertir los esquemas
de base de datos utilizando el Herramienta de
1.0.502 Compatibilidad A partir de ahora, puede almacenar diferentes 20 de diciembre

con perfiles perfiles en la Herramienta de conversión de de 2016
esquemas de AWS y cambiar fácilmente entre
ellos. Para obtener más información, consulte
Uso de los perfiles del servicio de AWS en la
AWS (p. 13).
1.0.501 Compatibilidad A partir de ahora, puede utilizar la Herramienta 17 de noviembre

con Greenplum de conversión de esquemas de AWS para de 2016
Database y convertir sus esquemas de almacenes de datos
Netezza de Greenplum Database y Netezza a Amazon
Redshift. Para obtener más información,
consulte Conversión de esquemas de almacén
AWS (p. 114).
1.0.501 Optimización de A partir de ahora, puede utilizar la Herramienta 17 de noviembre

Redshift de conversión de esquemas de AWS para de 2016
optimizar sus bases de datos de Amazon
Redshift. Para obtener más información,
consulte Optimización de Amazon Redshift
mediante la Herramienta de conversión de
Version 1.0
250

modificación
1.0.500 Reglas de A partir de ahora, antes de convertir su 4 de octubre de

mapeo esquema con la Herramienta de conversión de 2016
esquemas de AWS, puede configurar reglas
que cambien el tipo de datos de las columnas,
mover objetos de un esquema a otro y cambiar
los nombres de los objetos. Para obtener más
información, consulte Creación de reglas de
mapeo en la Herramienta de conversión de
1.0.500 Migración a la Ahora puede utilizar la Herramienta de 4 de octubre de

nube conversión de esquemas de AWS para copiar 2016
su esquema de base de datos local existente
a una instancia de base de datos de Amazon
RDS que ejecute el mismo motor. Puede utilizar
esta característica para analizar posibles
ahorros de costos en la migración a la nube y
en el cambio del tipo de licencia. Para obtener
más información, consulte Creación de informes
de evaluación con Herramienta de conversión
1.0.400 Conversiones A partir de ahora, puede utilizar la Herramienta 13 de julio de

de esquemas de conversión de esquemas de AWS para 2016
de data convertir sus esquemas de almacenes de
warehouses datos de Oracle y Teradata a Amazon Redshift.
Para obtener más información, consulte
Conversión de esquemas de almacén de datos
a Amazon Redshift utilizando la Herramienta de
1.0.400 Conversiones A partir de ahora, puede utilizar la Herramienta 13 de julio de

de SQL en de conversión de esquemas de AWS para 2016
aplicaciones convertir SQL en su código C++, C #, Java u
otro tipo de código de aplicación. Para obtener
más información, consulte Conversión de SQL
de aplicación con la Herramienta de conversión
1.0.400 Nueva La Herramienta de conversión de esquemas 13 de julio de

característica de AWS ahora contiene un paquete de 2016
extensión y un asistente para ayudarle a
instalar, crear y configurar las funciones de
AWS Lambda y las bibliotecas de Python
para proporcionar funcionalidades de correo
electrónico, programación de trabajos y otras.
Para obtener más información, consulte Uso
de las funciones de AWS Lambda del paquete
de extensión AWS SCT (p. 199) y Uso de la
biblioteca de Python personalizada para el
paquete de extensión de la AWS SCT (p. 197).
Version 1.0
251

modificación
1.0.301 SSL Support Ahora puede usar la capa de conexión segura 19 de mayo de
(SSL) para conectarse a su base de datos 2016
de origen cuando utilice la Herramienta de
1.0.203 Nueva Agrega soporte para MySQL y PostgreSQL 11 de abril de

característica como bases de datos de origen para las 2016
conversiones.
1.0.202 Versión de Agrega soporte para editar el SQL convertido 2 de marzo de

mantenimiento que se haya generado para el motor de base 2016
de datos de destino. Agrega capacidades de
selección mejoradas a las vistas en árbol de
la base de datos de origen y de la instancia
de base de datos de destino. Agrega soporte
para conectarse a una base de datos Oracle de
origen con nombres del Transparent Network
Substrate (TNS).
1.0.200 Versión de Agrega soporte para PostgreSQL como 14 de enero de

mantenimiento motor de base de datos de destino. Agrega la 2016
posibilidad de generar esquemas convertidos
como scripts y de guardar los scripts en
archivos antes de aplicar el esquema a la
instancia de base de datos de destino.
1.0.103 Versión de Agrega capacidad de proyectos sin conexión, 2 de diciembre

mantenimiento la posibilidad de comprobar si hay nuevas de 2015
versiones y administración de la memoria y el
desempeño.
1.0.101 Versión de Agrega el asistente para crear un nuevo 19 de octubre

mantenimiento proyecto de migración de base de datos. de 2015
Agrega la capacidad de guardar el informe de
evaluación de la migración de la base de datos
en formato PDF.
1.0.100 Versión de Ofrece la guía del usuario para la versión 7 de octubre de

prueba preliminar de la Herramienta de conversión de 2015
esquemas de AWS.
Version 1.0
252

Schema Conversion Tool

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Schema Conversion Tool

Cargado por

Copyright:

Formatos disponibles

Schema Conversion Tool de AWS

Guía del usuario

Schema Conversion Tool de AWS: Guía del usuario

Recopilación o carga de estadísticas ........................................................................................ 116

Información general de la conversión de SQL de aplicación .......................................................... 190

AWS SCT es compatible con las siguientes conversiones de OLTP.

Base de datos de origen Base de datos de destino en Amazon RDS

MySQL (versión 5.5 o posteriores) Aurora PostgreSQL, MySQL, PostgreSQL

Puede migrar esquemas y datos de MySQL a un

PostgreSQL (versión 9.1 y posteriores) Aurora MySQL, MySQL, PostgreSQL

Apache Cassandra (versiones 2.0, 3.0, 3.1.1 y Amazon DynamoDB

Sybase (16.0 y 15.7) Aurora MySQL, Aurora PostgreSQL, MySQL,

AWS SCT es compatible con las siguientes conversiones de data warehouse.

Base de datos de origen Base de datos de destino en Amazon Redshift

Greenplum Database (versión 4.3 y posteriores) Amazon Redshift

Microsoft SQL Server (versión 2008 y posteriores) Amazon Redshift

Netezza (versión 7.0.3 y posteriores) Amazon Redshift

Oracle (versión 10 y posteriores) Amazon Redshift

Teradata (versión 13 y posteriores) Amazon Redshift

Vertica (versión 7.2.2 y posteriores) Amazon Redshift

Introducción a la conversión de esquemas

• En algunos casos, las características de la base de datos de origen no se pueden convertir a

Proporcionar opiniones del cliente

Para hacer llegar sus comentarios sobre la AWS SCT.

1. Inicie Herramienta de conversión de esquemas de AWS.

Instalación de la AWS SCT

Sistema operativo Nombre de archivo

Fedora Linux aws-schema-conversion-tool-1.0.build-number.x86_64.rpm

macOS AWS Schema Conversion Tool-1.0.build-number.dmg

Microsoft Windows AWS Schema Conversion Tool-1.0.build-number.msi

Sistema operativo Nombre de archivo

Ubuntu Linux aws-schema-conversion-tool-1.0.build-number.deb

Sistema operativo Instrucciones de instalación

Fedora Linux Ejecute el siguiente comando en la carpeta en la que haya descargado el

sudo yum install aws-schema-conversion-tool-1.0.build-

macOS En Finder, localice y extraiga el archivo zip. En la carpeta extraída, abra

Para completar la instalación, arrastre el icono AWS Schema

Cierre la ventana de instalación, si está abierta. En el Finder, expulse la

Microsoft Windows Haga doble clic en el archivo para ejecutar el instalador.

Ubuntu Linux Ejecute el siguiente comando en la carpeta en la que haya descargado el

sudo dpkg -i aws-schema-conversion-tool-1.0.build-

Instalación de las versiones anteriores de la AWS SCT

Verificación de la descarga del archivo de AWS

Esta sección incluye los siguientes temas.

Verificación de la suma de comprobación del archivo

shasum -a 256 aws-schema-conversion-tool-1.0.latest.zip

Verificación de los archivos RPM de AWS SCT en

Para verificar los archivos RPM de AWS SCT en Fedora

sudo rpm --import aws-dms-team@amazon.com.public.gpg-key

6. Para comprobar que la importación se ha realizado correctamente, ejecute el siguiente comando:

rpm -q --qf "%{NAME}-%{VERSION}-%{RELEASE} \n %{SUMMARY} \n" gpg-pubkey-

7. Para comprobar la firma de RPM, ejecute el siguiente comando:

rpm --checksig -v aws-schema-conversion-tool-1.0.build number-1.x86_64.rpm

Verificación de los archivos DEB de AWS SCT en

Para verificar los archivos DEB de AWS SCT en Ubuntu

gpg --import aws-dms-team@amazon.com.public.gpg-key

7. Para comprobar la firma, ejecute el siguiente comando:

gpg --verify aws-schema-conversion-tool-1.0.latest.deb.asc aws-schema-conversion-

Verificación del archivo MSI de AWS SCT en Microsoft

Para verificar el archivo MSI de AWS SCT en Windows

Verificación de la aplicación AWS SCT en Mac OS

Para verificar la aplicación AWS SCT en Mac OS

codesign -dvvv /Applications/AWS\ Schema\ Conversion\ Tool.app/