# Integraciones sin ETL de Amazon RDS
Una integración sin ETL de Amazon RDS con Amazon Redshift y Amazon SageMaker AI permite realizar análisis y machine learning (ML) casi en tiempo real mediante datos de RDS. Es una solución totalmente administrada que permite que los datos transaccionales estén disponibles en el destino de análisis después de escribirlos en una base de datos de RDS. La *extracción, transformación* y *carga* (ETL) es un proceso en el que se combinan datos de numerosos orígenes en un gran almacenamiento de datos central.
La integración sin ETL hace que los datos de base de datos de RDS estén disponibles en Amazon Redshift o un Amazon SageMaker AI Lakehouse prácticamente en tiempo real. Una vez que los datos están en el almacén de datos de destino o lago de datos, puede alimentar cargas de trabajo de análisis, ML e IA con las capacidades integradas, como el machine learning, las vistas materializadas, el uso compartido de datos, el acceso federado a varios almacenamientos de datos y lagos de datos, y las integraciones con Amazon SageMaker AI, Quick y otros Servicios de AWS.
Para crear una integración sin ETL, especifique una base de datos de RDS como *origen* y un almacén de datos o almacén de lago compatible como *destino*. La integración replica los datos de la base de datos de origen en el almacén de datos de destino o almacén de lago.
El siguiente diagrama ilustra esta funcionalidad para una integración sin ETL con Amazon Redshift:
![\[Una integración sin ETL\]](http://docs.aws.amazon.com/es_es/AmazonRDS/latest/UserGuide/images/zero-etl-integrations.png)
En el siguiente diagrama se ilustra esta funcionalidad para la integración sin ETL con un Amazon SageMaker AI Lakehouse:
![\[Una integración sin ETL con un Amazon SageMaker AI Lakehouse\]](http://docs.aws.amazon.com/es_es/AmazonRDS/latest/UserGuide/images/zero-etl-rds-lakehouse.png)
La integración supervisa el estado de la canalización de datos y se recupera de los problemas cuando es posible. Puede crear integraciones a partir de varias bases de datos de RDS en un único almacén de datos o almacén de lago de destino, lo que le permite obtener información en varias aplicaciones.
**Topics**
+ [Ventajas](#zero-etl.benefits)
+ [Conceptos clave](#zero-etl.concepts)
+ [Limitaciones](#zero-etl.reqs-lims)
+ [Cuotas](#zero-etl.quotas)
+ [Regiones admitidas](#zero-etl.regions)
+ [Introducción a las integraciones sin ETL de Amazon RDS](zero-etl.setting-up.md)
+ [Creación de integraciones sin ETL de Amazon RDS con Amazon Redshift](zero-etl.creating.md)
+ [Creación de integraciones sin ETL de Amazon RDS con un Amazon SageMaker Lakehouse](zero-etl.creating-smlh.md)
+ [Filtrado de datos para integraciones sin ETL de Amazon RDS](zero-etl.filtering.md)
+ [Agregación de datos a una base de datos de RDS de origen y realización de consultas](zero-etl.querying.md)
+ [Visualización y supervisión de las integraciones sin ETL de Amazon RDS](zero-etl.describingmonitoring.md)
+ [Modificación de las integraciones sin ETL de Amazon RDS](zero-etl.modifying.md)
+ [Eliminación de las integraciones sin ETL de Amazon RDS](zero-etl.deleting.md)
+ [Solución de problemas de integraciones sin ETL de Amazon RDS](zero-etl.troubleshooting.md)
## Ventajas
Las integraciones sin ETL de RDS tienen los siguientes beneficios:
+ Le ayudan a obtener información holística a partir de numerosos orígenes de datos.
+ Eliminan la necesidad de crear y mantener canalizaciones de datos complejas que realicen operaciones de extracción, transformación y carga (ETL). Las integraciones sin ETL eliminan los inconvenientes derivados de la creación y administración de canalizaciones, ya que las aprovisionan y administran por usted.
+ Reducen la carga operativa y los costos para que pueda centrarse en mejorar sus aplicaciones.
+ Le permite aprovechar las capacidades de análisis y ML de destino para obtener información a partir de datos transaccionales y de otro tipo, a fin de responder de manera eficaz a eventos críticos y urgentes.
## Conceptos clave
Cuando empiece a utilizar las integraciones sin ETL, tenga en cuenta los siguientes conceptos:
**Integración**
Una canalización de datos totalmente administrada que replica automáticamente los datos y esquemas transaccionales de una base de datos de RDS a un almacén de datos o catálogo.
**Base de datos de origen**
La base de datos de RDS desde donde se replican los datos. Puede especificar una instancia de base de datos single-AZ o multi-AZ o un clúster de base de datos multi-AZ (solo para RDS para MySQL).
**Target**
El almacén de datos o almacén de lago en el que se replican los datos. Hay dos tipos de almacenamientos de datos: un almacenamiento de datos de [clústeres aprovisionados](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-clusters.html) y un almacenamiento de datos [sin servidor](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-workgroup-namespace.html). Un almacenamiento de datos de clústeres aprovisionados es una colección de recursos de computación denominados nodos que están organizados en un grupo llamado *clúster*. Un almacenamiento de datos sin servidor se compone de un grupo de trabajo que almacena los recursos de computación y un espacio de nombres que aloja los objetos y usuarios de la base de datos. Ambos almacenes de datos ejecutan un motor de análisis y contienen una o más bases de datos.
Un almacén de lago de destino consta de catálogos, bases de datos, tablas y vistas. Para obtener más información sobre la arquitectura del almacén de lago, consulte [https://docs.aws.amazon.com/sagemaker-unified-studio/latest/userguide/lakehouse-components.html](https://docs.aws.amazon.com/sagemaker-unified-studio/latest/userguide/lakehouse-components.html) en la *Guía del usuario de Amazon SageMaker AI Unified Studio*.
Múltiples bases de datos de origen pueden escribir en el mismo destino.
Para obtener más información, consulte [Arquitectura del sistema de almacenamiento de datos](https://docs.aws.amazon.com/redshift/latest/dg/c_high_level_system_architecture.html) en la *Guía del desarrollador de Amazon Redshift*.
## Limitaciones
Las siguientes limitaciones se aplican a las integración sin ETL de RDS.
**Topics**
+ [Limitaciones generales](#zero-etl.reqs-lims-general)
+ [Limitaciones de RDS for MySQL](#zero-etl.reqs-lims-mysql)
+ [Limitaciones de RDS para PostgreSQL](#zero-etl.reqs-lims-rds-postgres)
+ [Limitaciones de RDS para Oracle](#zero-etl.reqs-lims-oracle)
+ [Limitaciones de Amazon Redshift](#zero-etl.reqs-lims-redshift)
+ [Amazon SageMaker AILimitaciones de Lakehouse](#zero-etl.reqs-lims-sagemaker-)
### Limitaciones generales
+ La base de datos de origen debe estar en la misma región que el destino.
+ No puede cambiar el nombre de una base de datos si ya tiene integraciones.
+ No se pueden crear varias integraciones entre las mismas bases de datos de origen y de destino.
+ No puede eliminar una base de datos que ya tenga integraciones. Primero debes eliminar todas las integraciones asociadas.
+ Si detiene la base de datos de origen, es posible que las últimas transacciones no se repliquen en el destino hasta que reanude la base de datos.
+ No puede eliminar una integración si la base de datos de origen está detenida.
+ Si la base de datos es el origen de una implementación azul/verde, los entornos azul y verde no pueden tener integraciones sin ETL existentes durante la transición. Primero debe eliminar la integración, realizar la transición y, a continuación, volver a crear la integración.
+ No puede crear una integración para una base de datos de origen en la que se esté creando otra integración de forma activa.
+ Cuando se crea una integración por primera vez, o cuando se vuelve a sincronizar una tabla, la transferencia de datos del origen al destino puede tardar entre 20 y 25 minutos o más, en función del tamaño de la base de datos de origen. Este retardo puede provocar un aumento del retardo en la réplica.
+ Algunos tipos de datos no son compatibles. Para obtener más información, consulte [Diferencias de tipos de datos entre las bases de datos RDS y Amazon Redshift](zero-etl.querying.md#zero-etl.data-type-mapping).
+ Las tablas del sistema, las tablas temporales y las vistas no se replican en almacenes de destino.
+ Al ejecutar comandos DDL (por ejemplo, `ALTER TABLE`) en una tabla de origen, se puede desencadenar una resincronización de la tabla, lo que hace que la tabla no esté disponible para realizar consultas mientras se resincroniza. Para obtener más información, consulte [Una o más de mis tablas de Amazon Redshift requieren una resincronización](zero-etl.troubleshooting.md#zero-etl.troubleshooting.resync).
### Limitaciones de RDS for MySQL
+ La base de datos de origen debe ejecutar una versión compatible de RDS para MySQL. Para obtener una lista de las versiones compatibles, consulte [Regiones y motores de base de datos admitidos para las integraciones sin ETL de Amazon RDS](Concepts.RDS_Fea_Regions_DB-eng.Feature.ZeroETL.md).
+ Las integraciones sin ETL no se admiten en la instancia principal y en una instancia de réplica de lectura de la misma región de AWS.
+ Las integraciones sin ETL se basan en el registro binario de MySQL (binlog) para capturar los cambios en los datos en curso. No utilice el filtrado de datos basado en binlog, ya que puede provocar incoherencias entre los datos de las bases de datos de origen y de destino.
+ Las integraciones sin ETL solo son compatibles con bases de datos configuradas para usar el motor de almacenamiento de InnoDB.
+ No se admiten referencias de clave externas con actualizaciones de tablas predefinidas. En concreto, las reglas `ON DELETE` y `ON UPDATE` no son compatibles con las acciones `CASCADE`, `SET NULL` y `SET DEFAULT`. Si se intenta crear o actualizar una tabla con este tipo de referencias a otra tabla, se producirá un error en la tabla.
+ No puede crear una integración para una base de datos de origen que utilice almacenamiento magnético.
### Limitaciones de RDS para PostgreSQL
+ La base de datos de origen debe ser una instancia de RDS para PostgreSQL que ejecute las versiones 15.7\$1, 16.3\$1 o 17.1\$1. No se admiten versiones anteriores.
+ Las integraciones sin ETL de RDS para PostgreSQL no admiten clústeres de base de datos multi-AZ como bases de datos de origen.
+ No puede crear una integración sin ETL desde una instancia de réplica de lectura de RDS para PostgreSQL.
+ Las tablas no registradas y las vistas materializadas de PostgreSQL no se replican en Amazon Redshift.
+ Debido a las limitaciones de Amazon Redshift, no se admite la replicación de determinados tipos de datos de PostgreSQL, como los [tipos de datos de geometría](https://www.postgresql.org/docs/current/datatype-geometric.html) y los datos de más de 64 KB. Para obtener más información sobre las diferencias de tipos de datos entre RDS para PostgreSQL y Amazon Redshift, consulte [RDS para PostgreSQL](zero-etl.querying.md#zero-etl.data-type-mapping-postgres) en la sección **Diferencias de tipos de datos**.
+ No puede realizar una [actualización de la versión principal](USER_UpgradeDBInstance.PostgreSQL.md) en la instancia de RDS para PostgreSQL de origen mientras tenga una integración sin ETL activa. Para actualizar la instancia de origen, primero debe eliminar todas las integraciones sin ETL existentes. Una vez completada la actualización de la versión principal, puede volver a crear las integraciones sin ETL.
+ Si realiza transacciones de [particionamiento declarativo](https://www.postgresql.org/docs/current/ddl-partitioning.html#DDL-PARTITIONING-DECLARATIVE) en la instancia de base de datos de origen, todas las tablas afectadas pasan a un estado erróneo y dejan de estar accesibles.
### Limitaciones de RDS para Oracle
+ La base de datos de origen debe ser una instancia de RDS para Oracle que ejecute la versión 19c Enterprise Edition o Standard Edition 2, actualización de julio de 2019 o posterior. No se admiten versiones anteriores.
+ No puede crear una integración sin ETL a partir de una instancia de réplica de lectura de RDS para Oracle.
+ No puede cambiar el nombre de una [base de datos de inquilino](Oracle.Concepts.CDBs.md) cuando hay una integración sin ETL en esa base de datos de inquilino.
+ Una base de datos de inquilino solo puede tener una integración sin ETL.
+ RDS para Oracle y Amazon Redshift tienen algunas diferencias en los tipos de datos. Para obtener más información, consulte [RDS para Oracle](zero-etl.querying.md#zero-etl.data-type-mapping-oracle) en la sección **Diferencias de tipo de datos**.
### Limitaciones de Amazon Redshift
Para obtener una lista de limitaciones de Amazon Redshift relacionadas con las integraciones sin ETL, consulte [Consideraciones al utilizar las integraciones sin ETL con Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl.reqs-lims.html) de la *Guía de administración de Amazon Redshift*.
### Amazon SageMaker AILimitaciones de Lakehouse
La siguiente es una limitación para las integraciones sin ETL de Amazon SageMaker AI Lakehouse.
+ Los nombres de catálogo están limitados a 19 caracteres de longitud.
## Cuotas
La cuenta tiene las siguientes cuotas relacionadas con las integraciones sin ETL de RDS. Cada una de las cuotas se aplica a una sola región, a no ser que se especifique otra cosa.
| Nombre | Predeterminado | Descripción |
| --- | --- | --- |
| Integraciones | 100 | El número total de integraciones dentro de una Cuenta de AWS. |
| Integraciones por destino | 50 | El número de integraciones que envían datos a un único almacén de datos o almacén de lago de destino. |
| Integraciones por instancia de origen | 5 | La cantidad de integraciones que envían datos desde una sola instancia de base de datos de origen. |
Además, el almacén de destino establece algunos límites en la cantidad de tablas permitidas en cada instancia de base de datos o nodo de clúster. Para obtener más información sobre cuotas y límites de Amazon Redshift, consulte [Cuotas y límites de Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) en la *Guía de administración de Amazon Redshift*.
## Regiones admitidas
Las integraciones sin ETL de RDS están disponibles en un subconjunto de Regiones de AWS. Para obtener una lista de las regiones admitidas, consulte [Regiones y motores de base de datos admitidos para las integraciones sin ETL de Amazon RDS](Concepts.RDS_Fea_Regions_DB-eng.Feature.ZeroETL.md).
# Introducción a las integraciones sin ETL de Amazon RDS
Antes de crear una integración sin ETL, configure la base de datos de RDS y el almacén de datos con los parámetros y permisos necesarios. Durante la configuración, realizará los siguientes pasos:
1. [Creación de un grupo de parámetros de de base de datos personalizado.](#zero-etl.parameters)
1. [Cree una base de datos de origen](#zero-etl.create-cluster).
1. [Cree un almacenamiento de datos de destino para Amazon Redshift](#zero-etl-setting-up.data-warehouse) o [cree un Amazon SageMaker Lakehouse](#zero-etl-setting-up.sagemaker).
Una vez que haya completado estas tareas, continúe con [Creación de integraciones sin ETL de Amazon RDS con Amazon Redshift](zero-etl.creating.md) o [Creación de integraciones sin ETL de Amazon RDS con un Amazon SageMaker Lakehouse](zero-etl.creating-smlh.md).
**sugerencia**
Puede dejar que RDS complete estos pasos de configuración automáticamente mientras crea la integración, en lugar de hacerlos de forma manual. Para empezar inmediatamente a crear una integración, consulte [Creación de integraciones sin ETL de Amazon RDS con Amazon Redshift](zero-etl.creating.md).
En el paso 3, puede optar por crear un almacén de datos de destino (paso 3a) o un Lakehouse de destino (paso 3b), según sus necesidades:
+ Elija un almacén de datos si necesita capacidades de almacenamiento de datos tradicionales con análisis basados en SQL.
+ Elija un Amazon SageMaker Lakehouse si necesita capacidades de machine learning y desea utilizar las características de lakehouse para la ciencia de datos y los flujos de trabajo de machine learning.
## Crear un grupo de parámetros de de base de datos personalizado
Las integraciones sin ETL de Aurora requieren valores específicos para los parámetros de base de datos que controlan la replicación de datos. Los parámetros específicos dependen del motor de base de datos de origen. Para configurar estos parámetros, primero debe crear un grupo de parámetros de base de datos personalizado y, a continuación, asociarlo a la base de datos de origen. Configure los siguientes valores de parámetros en función del motor de base de datos de origen. Para obtener instrucciones sobre cómo crear un grupo de parámetros, consulte [Grupos de parámetros de base de datos para instancias de Amazon RDS](USER_WorkingWithDBInstanceParamGroups.md). Se recomienda configurar todos los valores de los parámetros en la misma solicitud para evitar problemas de dependencia.
**RDS para MySQL**:
+ `binlog_format=ROW`
+ `binlog_row_image=full`
Compruebe también que el parámetro `binlog_row_value_options` *no* esté establecido en `PARTIAL_JSON`. Si la base de datos de origen es un clúster de base de datos multi-AZ, asegúrese de que el parámetro `binlog_transaction_compression` *no* esté establecido en `ON`.
Algunos de estos parámetros (como `binlog_format`) son dinámicos, lo que significa que puede aplicar cambios al parámetro sin desencadenar un reinicio. Esto significa que algunas sesiones existentes podrían seguir utilizando el valor anterior del parámetro. Para evitar que esto cause problemas al crear una integración sin ETL, habilite [Performance Schema.](USER_PerfInsights.EnableMySQL.md) Performance Schema garantiza que se realicen comprobaciones previas sin ETL, lo que ayuda a detectar los parámetros faltantes al principio del proceso.
**RDS para PostgreSQL**:
+ `rds.logical_replication = 1`
+ `rds.replica_identity_full = 1`
+ `session_replication_role = origin`
+ `wal_sender_timeout ≥ 20000 or = 0`
+ `max_wal_senders ≥ 20`
+ `max_replication_slots ≥ 20`
Para varias integraciones de PostgreSQL, se utilizará una ranura de replicación lógica por integración. Revise los parámetros `max_replication_slots` y `max_wal_senders` en función de su uso.
Para una sincronización de datos eficiente en integraciones sin ETL, configure `rds.replica_identity_full` en la instancia de base de datos de origen. Esto indica a la base de datos que [registre los datos de fila completos](https://www.postgresql.org/docs/current/sql-altertable.html#SQL-ALTERTABLE-REPLICA-IDENTITY) en el registro de escritura anticipada (WAL) durante las operaciones `UPDATE` y `DELETE`, en lugar de solo la información de la clave principal. Cuando no se usa ETL, se requieren datos de fila completos, incluso cuando todas las tablas replicadas deben tener claves principales. Para determinar qué datos están visibles durante las consultas, Amazon Redshift utiliza una estrategia antiunión especializada para comparar los datos con una tabla interna de seguimiento de eliminaciones. El registro de imágenes de filas completas ayuda a Amazon Redshift a realizar estas antiuniones de manera eficiente. Sin datos de filas completas, Amazon Redshift tendría que realizar búsquedas adicionales, lo que podría reducir el rendimiento durante las operaciones de alto rendimiento en el motor de columnas que utiliza Amazon Redshift.
**importante**
Si configura la identidad de la réplica para registrar filas completas, [aumenta el volumen de WAL](https://www.postgresql.org/docs/current/runtime-config-wal.html#GUC-WAL-LEVEL), lo que puede incrementar la amplificación de la escritura y el uso de E/S, especialmente en el caso de tablas anchas o actualizaciones frecuentes. Para prepararse para estos impactos, planifique su capacidad de almacenamiento y sus requisitos de E/S, supervise el crecimiento de su WAL y realice un seguimiento del retraso en la replicación en las cargas de trabajo con un uso intensivo de escritura.
**RDS para Oracle**:
No es necesario cambiar los parámetros de RDS para Oracle.
## Paso 2: seleccionar o crear una base de datos de origen
Tras crear un grupo de parámetros personalizado del de base de datos, elija o cree un instancia de base de datos de RDS . Esta base de datos será el origen de la replicación de datos en el almacén de datos de destino. Para obtener instrucciones sobre cómo crear una instancia de base de datos multi-AZ o single-AZ, consulte [Creación de una instancia de base de datos de Amazon RDS](USER_CreateDBInstance.md). Para obtener instrucciones sobre cómo crear un clúster de base de datos multi-AZ (solo RDS para MySQL), consulte [Creación de un clúster de base de datos multi-AZ para Amazon RDS](create-multi-az-db-cluster.md).
La base de datos debe ejecutar una versión de motor de base de datos compatible. Para obtener una lista de las versiones compatibles, consulte [Regiones y motores de base de datos admitidos para las integraciones sin ETL de Amazon RDS](Concepts.RDS_Fea_Regions_DB-eng.Feature.ZeroETL.md).
Al crear la base de datos, en **Configuración adicional**, cambie el **grupo de parámetros de de base de datos** predeterminado por el grupo de parámetros personalizado que ha creado en el paso anterior.
**nota**
Si asocia el grupo de parámetros a la base de datos *después* de haber creado la base de datos, debe reiniciar la base de datos para aplicar los cambios y poder crear una integración sin ETL. Para obtener instrucciones, consulte [Reinicio de una instancia de base de datos ](USER_RebootInstance.md) o [Reinicio de un clúster de base de datos multi-AZ e instancias de base de datos de lector para Amazon RDS](multi-az-db-clusters-concepts-rebooting.md).
Además, asegúrese de que las copias de seguridad automáticas están activadas en la base de datos. Para obtener más información, consulte [Habilitar las copias de seguridad automatizadas](USER_WorkingWithAutomatedBackups.Enabling.md).
## Paso 3a: crear un almacén de datos de destino
Tras crear la base de datos de origen, debe crear y configurar un almacén de datos de destino. El almacenamiento de datos debe cumplir los siguientes requisitos:
+ Uso de un tipo de nodo RA3 con al menos dos nodos o Redshift sin servidor.
+ Cifrado (si se utiliza un clúster aprovisionado). Para obtener más información, consulte [Cifrado de base de datos de Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-db-encryption.html).
Para obtener instrucciones sobre cómo crear un almacenamiento de datos, consulte la sección [Creación de un clúster](https://docs.aws.amazon.com/redshift/latest/mgmt/create-cluster) para clústeres aprovisionados o [Creación de un grupo de trabajo con un espacio de nombres](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-console-workgroups-create-workgroup-wizard.html) para Redshift Serverless.
### Activar la distinción entre mayúsculas y minúsculas en el almacén de datos
Para que la integración funcione, el parámetro de distinción entre mayúsculas y minúsculas ([https://docs.aws.amazon.com/redshift/latest/dg/r_enable_case_sensitive_identifier.html](https://docs.aws.amazon.com/redshift/latest/dg/r_enable_case_sensitive_identifier.html)) debe estar habilitado en el almacenamiento de datos. De forma predeterminada, la distinción entre mayúsculas y minúsculas está desactivada en todos los clústeres y grupos de trabajo sin servidor de Redshift suministrados.
Para activar la distinción entre mayúsculas y minúsculas, realice los siguientes pasos en función del tipo de almacén de datos:
+ **Clúster aprovisionado**: para habilitar la distinción entre mayúsculas y minúsculas en un clúster aprovisionado, cree un grupo de parámetros personalizado con el parámetro `enable_case_sensitive_identifier` habilitado. A continuación, asocie el grupo de parámetros al clúster. Para obtener instrucciones, consulte la sección [Administración de grupos de parámetros mediante la consola](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-parameter-groups-console.html) o [Configuración de los valores de parámetros mediante la AWS CLI](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-parameter-groups.html#configure-parameters-using-the-clil).
**nota**
Recuerde reiniciar el clúster después de asociarlo el grupo de parámetros personalizado.
+ **Grupo de trabajo sin servidor**: para habilitar la distinción entre mayúsculas y minúsculas en un grupo de trabajo sin servidor de Redshift, debe usar AWS CLI. Actualmente, la consola de Amazon Redshift no permite modificar los valores de los parámetros de Redshift sin servidor. Envíe la siguiente solicitud de [update-workgroup](https://docs.aws.amazon.com/cli/latest/reference/redshift-serverless/update-workgroup.html):
```
aws redshift-serverless update-workgroup \
--workgroup-name target-workgroup \
--config-parameters parameterKey=enable_case_sensitive_identifier,parameterValue=true
```
No es necesario reiniciar un grupo de trabajo después de modificar los valores de los parámetros.
### Configure la autorización para el almacenamiento de datos
Tras crear un almacenamiento de datos, debe configurar la base de datos de RDS de origen como origen de integración autorizado. Para obtener instrucciones, consulte [Configuración de la autorización para el almacenamiento de datos de Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.setting-up.html#zero-etl-using.redshift-iam).
## Configuración de una integración mediante los AWS SDK
En lugar de configurar cada recurso manualmente, puede ejecutar el siguiente script de Python para configurar automáticamente los recursos necesarios. El ejemplo de código utiliza [AWS SDK para Python (Boto3)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) para crear una instancia de base de datos de RDS para MySQL de origen y un almacén de datos de destino, cada uno de ellos con los valores de parámetros necesarios. A continuación, espera a que las bases de datos estén disponibles antes de crear una integración sin ETL entre ellas. Puede comentar diferentes funciones dependiendo de los recursos que necesite configurar.
Ejecute los siguientes comandos para asegurarse de que dispone de todas las dependencias necesarias:
```
pip install boto3
pip install time
```
En el script, si lo desea, modifique los nombres de los grupos de origen, destino y parámetros. La función final crea una integración denominada `my-integration` después de configurar los recursos.
### Ejemplo de código Python
```
import boto3
import time
# Build the client using the default credential configuration.
# You can use the CLI and run 'aws configure' to set access key, secret
# key, and default Region.
rds = boto3.client('rds')
redshift = boto3.client('redshift')
sts = boto3.client('sts')
source_db_name = 'my-source-db' # A name for the source database
source_param_group_name = 'my-source-param-group' # A name for the source parameter group
target_cluster_name = 'my-target-cluster' # A name for the target cluster
target_param_group_name = 'my-target-param-group' # A name for the target parameter group
def create_source_db(*args):
"""Creates a source RDS for MySQL DB instance"""
response = rds.create_db_parameter_group(
DBParameterGroupName=source_param_group_name,
DBParameterGroupFamily='mysql8.0',
Description='RDS for MySQL zero-ETL integrations'
)
print('Created source parameter group: ' + response['DBParameterGroup']['DBParameterGroupName'])
response = rds.modify_db_parameter_group(
DBParameterGroupName=source_param_group_name,
Parameters=[
{
'ParameterName': 'binlog_format',
'ParameterValue': 'ROW',
'ApplyMethod': 'pending-reboot'
},
{
'ParameterName': 'binlog_row_image',
'ParameterValue': 'full',
'ApplyMethod': 'pending-reboot'
}
]
)
print('Modified source parameter group: ' + response['DBParameterGroupName'])
response = rds.create_db_instance(
DBInstanceIdentifier=source_db_name,
DBParameterGroupName=source_param_group_name,
Engine='mysql',
EngineVersion='8.0.32',
DBName='mydb',
DBInstanceClass='db.m5.large',
AllocatedStorage=15,
MasterUsername='username',
MasterUserPassword='Password01**'
)
print('Creating source database: ' + response['DBInstance']['DBInstanceIdentifier'])
source_arn = (response['DBInstance']['DBInstanceArn'])
create_target_cluster(target_cluster_name, source_arn, target_param_group_name)
return(response)
def create_target_cluster(target_cluster_name, source_arn, target_param_group_name):
"""Creates a target Redshift cluster"""
response = redshift.create_cluster_parameter_group(
ParameterGroupName=target_param_group_name,
ParameterGroupFamily='redshift-1.0',
Description='RDS for MySQL zero-ETL integrations'
)
print('Created target parameter group: ' + response['ClusterParameterGroup']['ParameterGroupName'])
response = redshift.modify_cluster_parameter_group(
ParameterGroupName=target_param_group_name,
Parameters=[
{
'ParameterName': 'enable_case_sensitive_identifier',
'ParameterValue': 'true'
}
]
)
print('Modified target parameter group: ' + response['ParameterGroupName'])
response = redshift.create_cluster(
ClusterIdentifier=target_cluster_name,
NodeType='ra3.4xlarge',
NumberOfNodes=2,
Encrypted=True,
MasterUsername='username',
MasterUserPassword='Password01**',
ClusterParameterGroupName=target_param_group_name
)
print('Creating target cluster: ' + response['Cluster']['ClusterIdentifier'])
# Retrieve the target cluster ARN
response = redshift.describe_clusters(
ClusterIdentifier=target_cluster_name
)
target_arn = response['Clusters'][0]['ClusterNamespaceArn']
# Retrieve the current user's account ID
response = sts.get_caller_identity()
account_id = response['Account']
# Create a resource policy granting access to source database and account ID
response = redshift.put_resource_policy(
ResourceArn=target_arn,
Policy='''
{
\"Version\":\"2012-10-17\",
\"Statement\":[
{\"Effect\":\"Allow\",
\"Principal\":{
\"Service\":\"redshift.amazonaws.com\"
},
\"Action\":[\"redshift:AuthorizeInboundIntegration\"],
\"Condition\":{
\"StringEquals\":{
\"aws:SourceArn\":\"%s\"}
}
},
{\"Effect\":\"Allow\",
\"Principal\":{
\"AWS\":\"arn:aws:iam::%s:root\"},
\"Action\":\"redshift:CreateInboundIntegration\"}
]
}
''' % (source_arn, account_id)
)
return(response)
def wait_for_db_availability(*args):
"""Waits for both databases to be available"""
print('Waiting for source and target to be available...')
response = rds.describe_db_instances(
DBInstanceIdentifier=source_db_name
)
source_status = response['DBInstances'][0]['DBInstanceStatus']
source_arn = response['DBInstances'][0]['DBInstanceArn']
response = redshift.describe_clusters(
ClusterIdentifier=target_cluster_name
)
target_status = response['Clusters'][0]['ClusterStatus']
target_arn = response['Clusters'][0]['ClusterNamespaceArn']
# Every 60 seconds, check whether the databases are available
if source_status != 'available' or target_status != 'available':
time.sleep(60)
response = wait_for_db_availability(
source_db_name, target_cluster_name)
else:
print('Databases available. Ready to create zero-ETL integration.')
create_integration(source_arn, target_arn)
return
def create_integration(source_arn, target_arn):
"""Creates a zero-ETL integration using the source and target databases"""
response = rds.create_integration(
SourceArn=source_arn,
TargetArn=target_arn,
IntegrationName='my-integration'
)
print('Creating integration: ' + response['IntegrationName'])
def main():
"""main function"""
create_source_db(source_db_name, source_param_group_name)
wait_for_db_availability(source_db_name, target_cluster_name)
if __name__ == "__main__":
main()
```
## Paso 3b: creación de un catálogo de AWS Glue para una integración sin ETL de Amazon SageMaker Lakehouse
Al crear una integración sin ETL con un Amazon SageMaker Lakehouse, debe crear un catálogo administrado por AWS Glue en AWS Lake Formation. El catálogo de destino debe ser un catálogo administrado por Amazon Redshift. Para crear un catálogo administrado por Amazon Redshift, cree primero el rol vinculado al servicio de `AWSServiceRoleForRedshift`. En la consola de Lake Formation, agregue `AWSServiceRoleForRedshift` como administrador de solo lectura.
Para obtener más información sobre las tareas anteriores, consulte los siguientes temas.
+ Para obtener información sobre la creación de un catálogo administrado por Amazon Redshift, consulte [Creación de un catálogo administrado por Amazon Redshift en AWS Glue Data Catalog](https://docs.aws.amazon.com/lake-formation/latest/dg/create-rms-catalog.html) en la *Guía para desarrolladores de AWS Lake Formation*.
+ Para obtener información sobre el role vinculado al servicio para Amazon Redshift, consulte [Uso de roles vinculados a servicios para Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/using-service-linked-roles.html) en la *Guía de administración de Amazon Redshift*.
+ Para obtener información sobre los permisos de administrador de solo lectura para Lake Formation, consulte la [referencia sobre las personas de Lake Formation y los permisos de IAM](https://docs.aws.amazon.com/lake-formation/latest/dg/permissions-reference.html) en la *Guía para desarrolladores de AWS Lake Formation*.
### Configuración de los permisos para el catálogo de AWS Glue de destino
Antes de crear un catálogo de destino para la integración sin ETL, debe crear el rol de creación de destino de Lake Formation y el rol de transferencia de datos de AWS Glue. Utilice el rol de creación de destino de Lake Formation para crear el catálogo de destino. Al crear el catálogo de destino, ingrese el rol de transferencia de datos de Glue en el campo **Rol de IAM** de la **sección Acceso desde motores**.
#### Rol de creación de destino de Lake Formation
El rol de creación de destino debe ser un administrador de Lake Formation y requiere los siguientes permisos.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": "lakeformation:RegisterResource",
"Resource": "*"
},
{
"Sid": "VisualEditor1",
"Effect": "Allow",
"Action": [
"s3:PutEncryptionConfiguration",
"iam:PassRole",
"glue:CreateCatalog",
"glue:GetCatalog",
"s3:PutBucketTagging",
"s3:PutLifecycleConfiguration",
"s3:PutBucketPolicy",
"s3:CreateBucket",
"redshift-serverless:CreateNamespace",
"s3:DeleteBucket",
"s3:PutBucketVersioning",
"redshift-serverless:CreateWorkgroup"
],
"Resource": [
"arn:aws:glue:*:111122223333:catalog",
"arn:aws:glue:*:111122223333:catalog/*",
"arn:aws:s3:::*",
"arn:aws:redshift-serverless:*:111122223333:workgroup/*",
"arn:aws:redshift-serverless:*:111122223333:namespace/*",
"arn:aws:iam::111122223333:role/GlueDataCatalogDataTransferRole"
]
}
]
}
```
------
El rol de creación de destino debe tener la siguiente relación de confianza.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "glue.amazonaws.com"
},
"Action": "sts:AssumeRole"
},
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:user/Username"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
#### Rol de transferencia de datos de Glue
El rol de transferencia de datos de Glue es necesario para las operaciones del catálogo de MySQL y debe tener los siguientes permisos.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DataTransferRolePolicy",
"Effect": "Allow",
"Action": [
"kms:GenerateDataKey",
"kms:Decrypt",
"glue:GetCatalog",
"glue:GetDatabase"
],
"Resource": [
"*"
]
}
]
}
```
------
El rol de transferencia de datos de Glue debe tener la siguiente relación de confianza.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"glue.amazonaws.com",
"redshift.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
## Siguientes pasos
Con una base de datos de RDS de origen y un almacenamiento de datos de destino de Amazon Redshift o Amazon SageMaker Lakehouse, puede crear una integración sin ETL y datos de replicación. Para obtener instrucciones, consulte [Creación de integraciones sin ETL de Amazon RDS con Amazon Redshift](zero-etl.creating.md).
# Creación de integraciones sin ETL de Amazon RDS con Amazon Redshift
Al crear una integración sin ETL de Amazon RDS, debe especificar una base de datos de RDS de origen y un almacenamiento de datos de Amazon Redshift de destino. También puede personalizar la configuración de cifrado y añadir etiquetas. Amazon RDS crea una integración entre la base de datos de origen y su destino. Una vez que la integración esté activa, todos los datos que inserte en la base de datos de origen se replicarán en el destino configurado de Amazon Redshift.
## Requisitos previos
Antes de crear una integración sin ETL, debe crear una base de datos de origen y un almacenamiento de datos de Amazon Redshift de destino. También debe permitir la réplica en el almacenamiento de datos añadiendo la base de datos como origen de integración autorizado.
Para obtener instrucciones para completar cada uno de estos pasos, consulte [Introducción a las integraciones sin ETL de Amazon RDS](zero-etl.setting-up.md).
## Permisos necesarios
Para crear una integración sin ETL se necesitan determinados permisos de IAM. Como mínimo, necesita permisos para realizar las siguientes acciones:
+ Crear integraciones sin ETL para la base de datos RDS de origen.
+ Ver y eliminar todas las integraciones sin ETL.
+ Crear integraciones entrantes en el almacenamiento de datos de destino.
Las políticas de ejemplo siguiente muestran los [permisos con privilegios mínimos](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege) necesarios para crear y administrar integraciones. Es posible que no necesite estos permisos exactos si su usuario o rol tiene permisos más amplios, como una política administrada `AdministratorAccess`.
**nota**
Los nombres de recurso de Amazon (ARN) de Redshift tienen el siguiente formato. Tenga en cuenta el uso de la barra diagonal (`(/`) en lugar de dos puntos (`:`) antes del UUID del espacio de nombres sin servidor.
Clúster aprovisionado: `arn:aws:redshift:{region}:{account-id}:namespace:namespace-uuid`
Sin servidor: `arn:aws:redshift-serverless:{region}:{account-id}:namespace/namespace-uuid`
### Política de ejemplo para el destino de Redshift
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "CreateIntegration",
"Effect": "Allow",
"Action": [
"rds:CreateIntegration"
],
"Resource": [
"arn:aws:rds:us-east-1:123456789012:db:source-db",
"arn:aws:rds:us-east-1:123456789012:integration:*"
]
},
{
"Sid": "DescribeIntegrationDetails",
"Effect": "Allow",
"Action": [
"rds:DescribeIntegrations"
],
"Resource": [
"arn:aws:rds:us-east-1:123456789012:integration:*"
]
},
{
"Sid": "ChangeIntegrationDetails",
"Effect": "Allow",
"Action": [
"rds:DeleteIntegration",
"rds:ModifyIntegration"
],
"Resource": [
"arn:aws:rds:us-east-1:123456789012:integration:*"
]
},
{
"Sid": "AllowRedShiftIntegration",
"Effect": "Allow",
"Action": [
"redshift:CreateInboundIntegration"
],
"Resource": [
"arn:aws:redshift:us-east-1:123456789012:namespace:namespace-uuid"
]
}
]
}
```
------
### Elegir un almacenamiento de datos de destino en una cuenta diferente
Si tiene previsto especificar un almacenamiento de datos de Amazon Redshift de destino distinto de una Cuenta de AWS, debe crear un rol que permita a los usuarios de la cuenta actual acceder a los recursos de la cuenta de destino. Para obtener más información, consulte [Proporcionar acceso a un usuario de IAM a otra Cuenta de AWS propia](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_aws-accounts.html).
El rol debe tener los siguientes permisos, que permiten al usuario ver los clústeres aprovisionados de Amazon Redshift y los espacios de nombres de Redshift sin servidor disponibles en la cuenta de destino.
#### Permisos necesarios y política de confianza
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"redshift:DescribeClusters",
"redshift-serverless:ListNamespaces"
],
"Resource":[
"*"
]
}
]
}
```
------
El rol debe tener la siguiente política de confianza, que especifica el ID de la cuenta de destino.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:root"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Para obtener instrucciones sobre cómo crear los roles, consulte [Creación de un rol mediante políticas de confianza personalizadas](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-custom.html).
## Creación de integraciones sin ETL
Puede crear la integración sin ETL mediante la Consola de administración de AWS, la AWS CLI o la API de RDS.
**importante**
Las integraciones sin ETL no admiten operaciones de actualización o resincronización. Si encuentra problemas con una integración después de la creación, debe eliminarla y crear una nueva.
De forma predeterminada, RDS para MySQL purga inmediatamente los archivos de registro binarios. Como las integraciones sin ETL se basan en registros binarios para replicar los datos de origen en el destino, el periodo de retención de la base de datos de origen debe ser de al menos una hora. Al crear una integración, Amazon RDS comprueba el periodo de retención del archivo de registro binario para la base de datos de origen seleccionada. Si el valor actual es 0 horas, Amazon RDS lo cambia automáticamente a 1 hora. De lo contrario, el valor sigue siendo el mismo.
### Consola de RDS
**Para eliminar una integración sin ETL**
1. Inicie sesión en la Consola de administración de AWS y abra la consola de Amazon RDS en [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. En el panel de navegación izquierdo, elija **Integraciones sin ETL**.
1. Elija **Crear integración sin ETL**.
1. En **Identificador de la integración**, introduzca un nombre para la integración. El nombre puede tener hasta 63 caracteres alfanuméricos y puede incluir guiones.
**importante**
Los nombres de catálogo están limitados a 19 caracteres de longitud. Asegúrese de que el identificador de integración cumpla este requisito si se va a utilizar como nombre de catálogo.
1. Elija **Siguiente**.
1. En **Origen**, seleccione la base de datos de RDS donde se originarán los datos.
**nota**
RDS le avisa si los parámetros del de base de datos no están configurados correctamente. Si aparece este mensaje, puede elegir la opción **Corregir automáticamente** o configurarlos manualmente. Para obtener instrucciones sobre cómo corregirlos manualmente, consulte [Crear un grupo de parámetros de de base de datos personalizado](zero-etl.setting-up.md#zero-etl.parameters).
Para modificar los parámetros del de base de datos es necesario reiniciar. Para crear la integración, es necesario completar el reinicio y aplicar correctamente los nuevos valores de parámetros en la base de datos.
1. Cuando la base de datos de origen esté configurado correctamente, seleccione **Siguiente**.
1. En **Destino**, haga lo siguiente:
1. (Opcional) Para utilizar una cuenta diferente a la Cuenta de AWS para el destino de Amazon Redshift, elija **Especificar una cuenta diferente**. A continuación, introduzca el ARN del rol de IAM con permisos para mostrar sus almacenamientos de datos. Para obtener instrucciones para crear el rol de IAM, consulte [Elegir un almacenamiento de datos de destino en una cuenta diferente](#zero-etl.create-permissions-cross-account).
1. Para el **almacenamiento de datos de Amazon Redshift**, seleccione el destino para los datos replicados de la base de datos de origen. Puede elegir un *clúster* de Amazon Redshift aprovisionado o un *espacio de nombres* Redshift sin servidor como destino.
**nota**
RDS le avisa si la política de recursos o la configuración de distinción entre mayúsculas y minúsculas del almacenamiento de datos especificado no están configuradas correctamente. Si aparece este mensaje, puede elegir la opción **Corregir automáticamente** o configurarlas manualmente. Para obtener instrucciones sobre cómo corregirlas manualmente, consulte [Activación de la distinción entre mayúsculas y minúsculas en el almacenamiento de datos](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.setting-up.html#zero-etl-setting-up.case-sensitivity) y [Configuración de la autorización para el almacenamiento de datos](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.setting-up.html#zero-etl-using.redshift-iam) en la *Guía de administración de Amazon Redshift*.
Para modificar la distinción entre mayúsculas y minúsculas en un clúster de Redshift *aprovisionado* es necesario reiniciar. Para crear la integración, es necesario completar el reinicio y aplicar correctamente el nuevo valor del parámetro al clúster.
Si el origen y el destino seleccionados están en Cuentas de AWS diferentes, Amazon RDS no podrá corregir esta configuración automáticamente. Debe acceder a la otra cuenta y corregirla manualmente en Amazon Redshift.
1. Una vez que el almacenamiento de datos de destino esté configurado correctamente, seleccione **Siguiente**.
1. (Opcional) En **Etiquetas**, añada una o más etiquetas al trabajo de integración. Para obtener más información, consulte [Etiquetado de los recursos de Amazon RDS](USER_Tagging.md).
1. En el caso del **cifrado**, especifique cómo desea que se cifra la integración. De forma predeterminada, RDS cifra todas las integraciones con una Clave propiedad de AWS. Para elegir una clave administrada por el cliente en su lugar, active **Personalizar la configuración de cifrado** y elija una clave de KMS para usarla en el cifrado. Para obtener más información, consulte [Cifrado de recursos de Amazon RDS](Overview.Encryption.md).
Si lo desea, añada un contexto de cifrado. Para obtener más información, consulte [Contexto de cifrado](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context) en la *Guía para desarrolladores de AWS Key Management Service*.
**nota**
Amazon RDS añade los siguientes pares de contexto de cifrado (además de los que usted incluya):
`aws:redshift:integration:arn` - `IntegrationArn`
`aws:servicename:id` - `Redshift`
Esto reduce el número total de pares que se pueden añadir (de 8 a 6) y contribuye al límite total de caracteres en la restricción de concesiones. Para obtener más información, consulte [Uso de restricciones de concesiones](https://docs.aws.amazon.com/kms/latest/developerguide/create-grant-overview.html#grant-constraints) en la *Guía para desarrolladores de AWS Key Management Service*.
1. Elija **Siguiente**.
1. Revise la configuración de integración y elija **Crear integración sin ETL**.
Si se produce un error en la creación, consulte [No puedo crear una integración sin ETL](zero-etl.troubleshooting.md#zero-etl.troubleshooting.creation) para ver los pasos de solución de problemas.
La integración tiene un estado de `Creating` mientras se crea y el almacenamiento de datos de Amazon Redshift de destino tiene un estado de `Modifying`. Durante este tiempo, no puede consultar el almacenamiento de datos ni realizar ningún cambio de configuración en él.
Cuando la integración se crea correctamente, tanto el estado de la integración como el almacenamiento de datos de Amazon Redshift de destino cambian a `Active`.
### AWS CLI
Para crear una integración sin ETL mediante la AWS CLI, utilice el comando [create-integration](https://docs.aws.amazon.com/cli/latest/reference/rds/create-integration.html) con las siguientes opciones:
**nota**
Recuerde que los nombres de catálogo están limitados a 19 caracteres. Elija el nombre de la integración en consecuencia si se va a utilizar como nombre de catálogo.
+ `--integration-name`: especifique un nombre para la integración.
+ `--source-arn`: especifique el ARN de la base de datos de RDS que será el origen de la integración.
+ `--target-arn`: especifique el ARN del almacenamiento de datos de Amazon Redshift que será el destino de la integración.
**Example**
Para Linux, macOS o Unix:
```
aws rds create-integration \
--integration-name my-integration \
--source-arn arn:aws:rds:{region}:{account-id}:my-db \
--target-arn arn:aws:redshift:{region}:{account-id}:namespace:namespace-uuid
```
Para Windows:
```
aws rds create-integration ^
--integration-name my-integration ^
--source-arn arn:aws:rds:{region}:{account-id}:my-db ^
--target-arn arn:aws:redshift:{region}:{account-id}:namespace:namespace-uuid
```
### API de RDS
Para crear una integración sin ETL mediante la API de Amazon RDS, utilice la operación [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateIntegration.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateIntegration.html) con los siguientes parámetros:
**nota**
Los nombres de catálogo están limitados a 19 caracteres. Asegúrese de que el parámetro IntegrationName cumpla este requisito si se va a utilizar como nombre de catálogo.
+ `IntegrationName`: especifique un nombre para la integración.
+ `SourceArn`: especifique el ARN de la base de datos de RDS que será el origen de la integración.
+ `TargetArn`: especifique el ARN del almacenamiento de datos de Amazon Redshift que será el destino de la integración.
## Cifrado de integraciones con una clave administrada por el cliente
Si especifica una clave de KMS personalizada en lugar de una Clave propiedad de AWS al crear una integración, la política de claves debe darle a la entidad principal del servicio Amazon Redshift acceso principal a la acción `CreateGrant`. Además, debe permitir al usuario actual realizar las acciones `DescribeKey` y `CreateGrant`.
En la siguiente política de muestra se demuestra cómo proporcionar los permisos necesarios en su política de claves. Incluye claves de contexto que sirven para reducir aún más el alcance de los permisos.
### Política de claves de muestra
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "Key policy",
"Statement": [
{
"Sid": "Enables IAM user permissions",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:root"
},
"Action": "kms:*",
"Resource": "*"
},
{
"Sid": "Allows the Redshift service principal to add a grant to a KMS key",
"Effect": "Allow",
"Principal": {
"Service": "redshift.amazonaws.com"
},
"Action": "kms:CreateGrant",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:EncryptionContext:{context-key}": "{context-value}"
},
"ForAllValues:StringEquals": {
"kms:GrantOperations": [
"Decrypt",
"GenerateDataKey",
"CreateGrant"
]
}
}
},
{
"Sid": "Allows the current user or role to add a grant to a KMS key",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/{role-name}"
},
"Action": "kms:CreateGrant",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:EncryptionContext:{context-key}": "{context-value}",
"kms:ViaService": "rds.us-east-1.amazonaws.com"
},
"ForAllValues:StringEquals": {
"kms:GrantOperations": [
"Decrypt",
"GenerateDataKey",
"CreateGrant"
]
}
}
},
{
"Sid": "Allows the current uer or role to retrieve information about a KMS key",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/{role-name}"
},
"Action": "kms:DescribeKey",
"Resource": "*"
}
]
}
```
------
Para obtener más información, consulte [Creating a key policy](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-overview.html) en la *Guía del desarrollador de AWS Key Management Service*.
## Siguientes pasos
Tras crear correctamente una integración sin ETL, debe crear una base de datos de destino dentro del clúster o grupo de trabajo de Amazon Redshift de destino. A continuación, puede empezar a agregar datos a la base de datos de RDS de origen y a dirigirle consultas en Amazon Redshift. Para obtener instrucciones, consulte [Creating destination databases in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.creating-db.html).
# Creación de integraciones sin ETL de Amazon RDS con un Amazon SageMaker Lakehouse
Cuando crea una integración sin ETL de Amazon RDS con un Amazon SageMaker Lakehouse, debe especificar una base de datos de RDS de origen y el catálogo administrado por AWS Glue de destino. También puede personalizar la configuración de cifrado y añadir etiquetas. Amazon RDS crea una integración entre la base de datos de origen y su destino. Una vez que la integración esté activa, todos los datos que inserte en la base de datos de origen se replicarán en el destino configurado.
## Requisitos previos
Antes de crear una integración sin ETL con un Amazon SageMaker Lakehouse, debe crear una base de datos de origen y un catálogo administrado por AWS Glue de destino. También debe permitir la replicación en el catálogo agregando la base de datos como origen de integración autorizado.
Para obtener instrucciones para completar cada uno de estos pasos, consulte [Introducción a las integraciones sin ETL de Amazon RDS](zero-etl.setting-up.md).
## Permisos necesarios
Se necesitan determinados permisos de IAM para crear una integración sin ETL con un Amazon SageMaker Lakehouse. Como mínimo, necesita permisos para realizar las siguientes acciones:
+ Crear integraciones sin ETL para la base de datos RDS de origen.
+ Ver y eliminar todas las integraciones sin ETL.
+ Cree integraciones entrantes en el catálogo administrado por AWS Glue de destino.
+ Acceda a los buckets de Amazon S3 que utiliza el catálogo administrado por AWS Glue.
+ Utilice claves de AWS KMS para el cifrado si está configurado un cifrado personalizado.
+ Registre recursos con Lake Formation.
+ Incluya la política de recursos en el catálogo administrado por AWS Glue para autorizar las integraciones entrantes.
La política de ejemplo siguiente demuestra los [permisos con privilegios mínimos](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege) necesarios para crear y administrar integraciones con un Amazon SageMaker Lakehouse. Es posible que no necesite estos permisos exactos si su usuario o rol tiene permisos más amplios, como una política administrada `AdministratorAccess`.
Además, debe configurar una política de recursos en el catálogo administrado por AWS Glue de destino para autorizar las integraciones entrantes. Use el comando de la AWS CLI siguiente para aplicar la política de recursos.
### Comando de la AWS CLI de ejemplo para autorizar las integraciones entrantes en el catálogo de destino
```
aws glue put-resource-policy \
--policy-in-json '{
"Version": "2012-10-17",
"Statement": [{
"Effect": "Allow",
"Principal": {
"Service": "glue.amazonaws.com"
},
"Action": [
"glue:AuthorizeInboundIntegration"
],
"Resource": ["arn:aws:glue:region:account_id:catalog/catalog_name"],
"Condition": {
"StringEquals": {
"aws:SourceArn": "arn:aws:rds:region:account_id:db:source_name"
}
}
},
{
"Effect": "Allow",
"Principal": {
"AWS": "account_id"
},
"Action": ["glue:CreateInboundIntegration"],
"Resource": ["arn:aws:glue:region:account_id:catalog/catalog_name"]
}
]
}' \
--region region
```
**nota**
Los nombres de recurso de Amazon (ARN) del catálogo de Glue tienen el siguiente formato:
Catálogo de Glue: `arn:aws:glue:{region}:{account-id}:catalog/catalog-name`
### Elección de un catálogo administrado por AWS Glue de destino en una cuenta diferente
Si piensa especificar un catálogo administrado por AWS Glue de destino que está en otra Cuenta de AWS, debe crear un rol que permita a los usuarios de la cuenta actual acceder a los recursos de la cuenta de destino. Para obtener más información, consulte [Proporcionar acceso a un usuario de IAM a otra Cuenta de AWS propia](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_aws-accounts.html).
El rol debe tener los siguientes permisos, que permiten al usuario ver los catálogos de AWS Glue disponibles en la cuenta de destino.
#### Permisos necesarios y política de confianza
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"glue:GetCatalog"
],
"Resource":[
"*"
]
}
]
}
```
------
El rol debe tener la siguiente política de confianza, que especifica el ID de la cuenta de destino.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Principal":{
"AWS": "arn:aws:iam::111122223333:root"
},
"Action":"sts:AssumeRole"
}
]
}
```
------
Para obtener instrucciones sobre cómo crear los roles, consulte [Creación de un rol mediante políticas de confianza personalizadas](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-custom.html).
## Creación de integraciones sin ETL con un Amazon SageMaker Lakehouse
Puede crear una integración sin ETL con un Amazon SageMaker Lakehouse mediante la Consola de administración de AWS, la AWS CLI o la API de RDS.
**importante**
Las integraciones sin ETL con un Amazon SageMaker Lakehouse no admiten operaciones de actualización o resincronización. Si encuentra problemas con una integración después de la creación, debe eliminarla y crear una nueva.
De forma predeterminada, RDS para MySQL purga inmediatamente los archivos de registro binarios. Como las integraciones sin ETL se basan en registros binarios para replicar los datos de origen en el destino, el periodo de retención de la base de datos de origen debe ser de al menos una hora. Al crear una integración, Amazon RDS comprueba el periodo de retención del archivo de registro binario para la base de datos de origen seleccionada. Si el valor actual es 0 horas, Amazon RDS lo cambia automáticamente a 1 hora. De lo contrario, el valor sigue siendo el mismo.
### Consola de RDS
**Creación de una integración sin ETL con un Amazon SageMaker Lakehouse**
1. Inicie sesión en la Consola de administración de AWS y abra la consola de Amazon RDS en [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. En el panel de navegación izquierdo, elija **Integraciones sin ETL**.
1. Elija **Crear integración sin ETL**.
1. En **Identificador de la integración**, introduzca un nombre para la integración. El nombre puede tener hasta 63 caracteres alfanuméricos y puede incluir guiones.
1. Elija **Siguiente**.
1. En **Origen**, seleccione la base de datos de RDS donde se originarán los datos.
**nota**
RDS le avisa si los parámetros del de base de datos no están configurados correctamente. Si aparece este mensaje, puede elegir la opción **Corregir automáticamente** o configurarlos manualmente. Para obtener instrucciones sobre cómo corregirlos manualmente, consulte [Crear un grupo de parámetros de de base de datos personalizado](zero-etl.setting-up.md#zero-etl.parameters).
Para modificar los parámetros del de base de datos es necesario reiniciar. Para crear la integración, es necesario completar el reinicio y aplicar correctamente los nuevos valores de parámetros en la base de datos.
1. Cuando la base de datos de origen esté configurado correctamente, seleccione **Siguiente**.
1. En **Destino**, haga lo siguiente:
1. (Opcional) Para utilizar una Cuenta de AWS diferente para el Amazon SageMaker Lakehouse de destino, elija **Especificar una cuenta diferente**. A continuación, ingrese el ARN de un rol de IAM con permisos para mostrar los catálogos de AWS Glue. Para obtener instrucciones para crear el rol de IAM, consulte [Elección de un catálogo administrado por AWS Glue de destino en una cuenta diferente](#zero-etl.create-permissions-cross-account-smlh).
1. Para el **catálogo de AWS Glue**, seleccione el destino de los datos replicados de la base de datos de origen. Puede elegir un catálogo administrado por AWS Glue existente como destino.
1. El rol de IAM de destino necesita permisos de descripción en el catálogo de destino y debe tener los siguientes permisos:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": "glue:GetCatalog",
"Resource": [
"arn:aws:glue:us-east-1:111122223333:catalog/*",
"arn:aws:glue:us-east-1:111122223333:catalog"
]
}
]
}
```
------
El rol de IAM de destino debe tener la siguiente relación de confianza:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "glue.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Debe conceder al rol de IAM de destino permisos de descripción para el catálogo administrado por AWS Glue de destino con el rol de administrador de Lake Formation creado en [Paso 3b: creación de un catálogo de AWS Glue para una integración sin ETL de Amazon SageMaker Lakehouse](zero-etl.setting-up.md#zero-etl-setting-up.sagemaker).
**nota**
RDS le notificará si la política de recursos o la configuración del catálogo administrado por AWS Glue especificado no están configurados correctamente. Si aparece este mensaje, puede elegir la opción **Corregir automáticamente** o configurarlas manualmente.
Si el origen y el destino seleccionados están en Cuentas de AWS diferentes, Amazon RDS no podrá corregir esta configuración automáticamente. Debe acceder a la otra cuenta y corregirla manualmente en SageMaker Unified Studio.
1. Una vez que el catálogo administrado por AWS Glue de destino esté configurado correctamente, elija **Siguiente**.
1. (Opcional) En **Etiquetas**, añada una o más etiquetas al trabajo de integración. Para obtener más información, consulte [Etiquetado de los recursos de Amazon RDS](USER_Tagging.md).
1. En el caso del **cifrado**, especifique cómo desea que se cifra la integración. De forma predeterminada, RDS cifra todas las integraciones con una Clave propiedad de AWS. Para elegir una clave administrada por el cliente en su lugar, active **Personalizar la configuración de cifrado** y elija una clave de KMS para usarla en el cifrado. Para obtener más información, consulte [Cifrado de recursos de Amazon RDS](Overview.Encryption.md).
Si lo desea, añada un contexto de cifrado. Para obtener más información, consulte [Contexto de cifrado](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context) en la *Guía para desarrolladores de AWS Key Management Service*.
**nota**
Amazon RDS añade los siguientes pares de contexto de cifrado (además de los que usted incluya):
`aws:glue:integration:arn` - `IntegrationArn`
`aws:servicename:id` - `glue`
Esto reduce el número total de pares que se pueden añadir (de 8 a 6) y contribuye al límite total de caracteres en la restricción de concesiones. Para obtener más información, consulte [Uso de restricciones de concesiones](https://docs.aws.amazon.com/kms/latest/developerguide/create-grant-overview.html#grant-constraints) en la *Guía para desarrolladores de AWS Key Management Service*.
1. Elija **Siguiente**.
1. Revise la configuración de integración y elija **Crear integración sin ETL**.
Si se produce un error en la creación, consulte [Solución de problemas de integraciones sin ETL de Amazon RDS](zero-etl.troubleshooting.md) para ver los pasos de solución de problemas.
La integración tiene un estado de `Creating` mientras se crea y el Amazon SageMaker Lakehouse de destino tiene un estado de `Modifying`. Durante este tiempo, no puede consultar el catálogo ni realizar ningún cambio de configuración en él.
Cuando la integración se crea correctamente, el estado de la integración y el Amazon SageMaker Lakehouse de destino cambian a `Active`.
### AWS CLI
Para preparar un catálogo administrado por AWS Glue de destino para una integración sin ETL utilizando la AWS CLI, primero debe utilizar el comando [create-integration-resource-property](https://docs.aws.amazon.com/cli/latest/reference/rds/create-integration.html) con las siguientes opciones:
+ `--resource-arn`: especifique el ARN del catálogo administrado por AWS Glue que será el destino de la integración.
+ `--target-processing-properties`: especifique el ARN del rol de IAM para acceder al catálogo administrado por AWS Glue de destino
```
aws glue create-integration-resource-property --region us-east-1
--resource-arn arn:aws:glue:region:account_id:catalog/catalog_name \
--target-processing-properties '{"RoleArn" : "arn:aws:iam::account_id:role/TargetIamRole"}'
```
Para crear una integración sin ETL mediante un Amazon SageMaker Lakehouse, utilice la AWS CLI, use el comando [create-integration](https://docs.aws.amazon.com/cli/latest/reference/rds/create-integration.html) con las siguientes opciones:
+ `--integration-name`: especifique un nombre para la integración.
+ `--source-arn`: especifique el ARN de la base de datos de RDS que será el origen de la integración.
+ `--target-arn`: especifique el ARN del catálogo administrado por AWS Glue que será el destino de la integración.
**Example**
Para Linux, macOS o Unix:
```
aws rds create-integration \
--integration-name my-sagemaker-integration \
--source-arn arn:aws:rds:{region}:{account-id}:cluster:my-db \
--target-arn arn:aws:glue:{region}:{account-id}:catalog/catalog-name
```
Para Windows:
```
aws rds create-integration ^
--integration-name my-sagemaker-integration ^
--source-arn arn:aws:rds:{region}:{account-id}:cluster:my-db ^
--target-arn arn:aws:glue:{region}:{account-id}:catalog/catalog-name
```
### API de RDS
Para crear una integración sin ETL con Amazon SageMaker mediante la API de Amazon RDS, utilice la operación [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateIntegration.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateIntegration.html) con los siguientes parámetros:
**nota**
Los nombres de catálogo están limitados a 19 caracteres. Asegúrese de que el parámetro IntegrationName cumpla este requisito si se va a utilizar como nombre de catálogo.
+ `IntegrationName`: especifique un nombre para la integración.
+ `SourceArn`: especifique el ARN de la base de datos de RDS que será el origen de la integración.
+ `TargetArn`: especifique el ARN del catálogo administrado por AWS Glue que será el destino de la integración.
## Cifrado de integraciones con una clave administrada por el cliente
Si especifica una clave de KMS personalizada en lugar de una Clave propiedad de AWS al crear una integración con Amazon SageMaker, la política de claves debe proporcionar a la entidad principal de servicio SageMaker Unified Studio acceso a la acción `CreateGrant`. Además, debe permitir al usuario actual realizar las acciones `DescribeKey` y `CreateGrant`.
En la siguiente política de muestra se demuestra cómo proporcionar los permisos necesarios en su política de claves. Incluye claves de contexto que sirven para reducir aún más el alcance de los permisos.
### Política de claves de muestra
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "Key policy",
"Statement": [
{
"Sid": "EnablesIAMUserPermissions",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:root"
},
"Action": "kms:*",
"Resource": "*"
},
{
"Sid": "GlueServicePrincipalAddGrant",
"Effect": "Allow",
"Principal": {
"Service": "glue.amazonaws.com"
},
"Action": "kms:CreateGrant",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:EncryptionContext:{context-key}":"{context-value}"
},
"ForAllValues:StringEquals": {
"kms:GrantOperations": [
"Decrypt",
"GenerateDataKey",
"CreateGrant"
]
}
}
},
{
"Sid": "AllowsCurrentUserRoleAddGrantKMSKey",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/{role-name}"
},
"Action": "kms:CreateGrant",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:EncryptionContext:{context-key}":"{context-value}",
"kms:ViaService": "rds.us-east-1.amazonaws.com"
},
"ForAllValues:StringEquals": {
"kms:GrantOperations": [
"Decrypt",
"GenerateDataKey",
"CreateGrant"
]
}
}
},
{
"Sid": "AllowsCurrentUserRoleRetrieveKMSKeyInformation",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/{role-name}"
},
"Action": "kms:DescribeKey",
"Resource": "*"
}
]
}
```
------
Para obtener más información, consulte [Creating a key policy](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-overview.html) en la *Guía del desarrollador de AWS Key Management Service*.
## Siguientes pasos
Después de crear correctamente una integración sin ETL con Amazon SageMaker, puede comenzar a agregar datos a base de datos de RDS de destino, y consultarlos en el Amazon SageMaker Lakehouse. Los datos se replicarán automáticamente y estarán disponibles para las cargas de trabajo de análisis y machine learning.
# Filtrado de datos para integraciones sin ETL de Amazon RDS
Las integraciones sin ETL de Amazon RDS admiten el filtrado de datos, lo que le permite controlar qué datos se replican desde la base de datos de Amazon RDS de origen al almacén de datos de destino. En lugar de replicar toda la base de datos, puede aplicar uno o más filtros para incluir o excluir selectivamente tablas específicas. Esto lo ayuda a optimizar el almacenamiento y el rendimiento de las consultas al garantizar que solo se transfieran los datos relevantes. Actualmente, el filtrado está limitado a los niveles de base de datos y tabla. No se admite el filtrado a nivel de columna y fila.
El filtrado de datos puede resultar útil cuando desee:
+ Una determinadas tablas de dos o más bases de datos de origen diferentes y no necesita datos completos de la base de datos.
+ Ahorrar costos realizando análisis utilizando únicamente un subconjunto de tablas en lugar de una flota completa de bases de datos.
+ Filtrar la información confidencial (como números de teléfono, direcciones o datos de tarjetas de crédito) de determinadas tablas.
Puede agregar filtros de datos a una integración sin ETL mediante la Consola de administración de AWS, la AWS Command Line Interface (AWS CLI) o la API de Amazon RDS.
Si la integración tiene un clúster aprovisionado como destino, el clúster debe tener [la revisión 180](https://docs.aws.amazon.com/redshift/latest/mgmt/cluster-versions.html#cluster-version-180) o uno posterior para usar el filtrado de datos.
**Topics**
+ [Formato de un filtro de datos](#zero-etl.filtering-format)
+ [Lógica de filtros](#zero-etl.filtering-evaluate)
+ [Prioridad del filtro](#zero-etl.filtering-precedence)
+ [Ejemplos de RDS para MySQL](#zero-etl.filtering-examples-mysql)
+ [Ejemplos de RDS para PostgreSQL](#zero-etl.filtering-examples-postgres)
+ [Ejemplos de RDS para Oracle](#zero-etl.filtering-examples-oracle)
+ [Adición de filtros de datos a una integración](#zero-etl.add-filter)
+ [Eliminación de filtros de datos de una integración](#zero-etl.remove-filter)
## Formato de un filtro de datos
Puede definir varios filtros para una sola integración. Cada filtro incluye o excluye cualquier tabla de base de datos existente y futura que coincida con uno de los patrones de la expresión del filtro. Las integraciones sin ETL de Amazon RDS utilizan la [sintaxis de filtro Maxwell](https://maxwells-daemon.io/filtering/) para el filtrado de datos.
Cada filtro tiene los siguientes elementos:
| Element | Descripción |
| --- | --- |
| Tipo de filtro | Un tipo de filtro `Include` *incluye* todas las tablas que coinciden con uno de los patrones de la expresión de filtro. Un tipo de filtro `Exclude` *excluye* todas las tablas que coinciden con uno de los patrones. |
| Expresión de filtro | Una lista separada por comas de patrones. Las expresiones deben usar la [sintaxis de filtro Maxwell](https://maxwells-daemon.io/filtering/). |
| Pattern | Un patrón de filtro en el formato `database.table` para RDS para MySQL o `database.schema.table` para RDS para PostgreSQL. Puede especificar nombres literales o definir expresiones regulares. Para RDS para MySQL, se admiten expresiones regulares tanto en el nombre de la base de datos como de la tabla. Para RDS para PostgreSQL, las expresiones regulares solo se admiten en el nombre del esquema y la tabla, no en el nombre de la base de datos. No pueden incluir filtros en columnas ni listas de denegación. Una sola integración puede tener un máximo de 99 patrones en total. En la consola, puede introducir patrones dentro de una sola expresión de filtro o distribuirlos entre varias expresiones. Un único patrón no puede superar los 256 caracteres de longitud. |
**importante**
Si selecciona una base de datos de origen de RDS para PostgreSQL, debe especificar al menos un patrón de filtro de datos. Como mínimo, el patrón debe incluir una única base de datos (`database-name.*.*`) para la replicación en el almacén de datos de destino.
En la imagen siguiente, se muestra la estructura de los filtros de datos de RDS para MySQL en la consola:
![\[Filtros de datos para integraciones sin ETL\]](http://docs.aws.amazon.com/es_es/AmazonRDS/latest/UserGuide/images/zero-etl-filter.png)
**importante**
No incluya información de identificación personal, confidencial o sensible en sus patrones de filtros.
### Filtros de datos en la AWS CLI
Cuando se utiliza la AWS CLI para agregar un filtro de datos, la sintaxis es ligeramente diferente a la de la consola. Debe asignar un tipo de filtro (`Include` o `Exclude`) a cada patrón individualmente, por lo que no puede agrupar varios patrones en un mismo tipo de filtro.
Por ejemplo, en la consola puede agrupar los siguientes patrones separados por comas en una sola instrucción `Include`:
**RDS para MySQL**
```
mydb.mytable, mydb./table_\d+/
```
**RDS para PostgreSQL**
```
mydb.myschema.mytable, mydb.myschema./table_\d+/
```
Sin embargo, al utilizar la AWS CLI, el mismo filtro de datos debe tener el siguiente formato:
**RDS para MySQL**
```
'include: mydb.mytable, include: mydb./table_\d+/'
```
**RDS para PostgreSQL**
```
'include: mydb.myschema.mytable, include: mydb.myschema./table_\d+/'
```
## Lógica de filtros
Si no especifica ningún filtro de datos en la integración, Amazon RDS asume un filtro predeterminado de `include:*.*`, que replica todas las tablas en el almacén de datos de destino. No obstante, si agrega al menos un filtro, la lógica predeterminada cambia a `exclude:*.*`, que excluye todas las tablas de forma predeterminada. Esto le permite definir explícitamente qué bases de datos y tablas se incluirán en la replicación.
Por ejemplo, si hace lo siguiente:
```
'include: db.table1, include: db.table2'
```
Amazon RDS evalúa el filtro de la siguiente manera:
```
'exclude:*.*, include: db.table1, include: db.table2'
```
Por lo tanto, Amazon RDS solo replica `table1` y `table2` de la base de datos llamada `db` en el almacén de datos de destino.
## Prioridad del filtro
Amazon RDS evalúa los filtros de datos en el orden que especifique. En la Consola de administración de AWS, procesa las expresiones de filtro de izquierda a derecha y de arriba abajo. Un segundo filtro o un patrón individual que siga al primero puede anularlo.
Por ejemplo, si el primer filtro es `Include books.stephenking`, solo incluye la tabla `stephenking` de la base de datos `books`. Sin embargo, si agrega un segundo filtro, `Exclude books.*`, este anulará el primer filtro. Esto evita que las tablas del índice de `books` se repliquen en el almacén de datos de destino.
Cuando especifica al menos un filtro, la lógica comienza con la suposición de `exclude:*.*` de forma predeterminada, lo que *excluye* automáticamente todas las tablas de la replicación. Como práctica recomendada, defina los filtros de más amplio a más específico. Comience con una o más instrucciones `Include` para especificar los datos que desea replicar; a continuación, agregue filtros `Exclude` para eliminar selectivamente ciertas tablas.
El mismo principio se aplica a los filtros que se definen mediante la AWS CLI. Amazon RDS evalúa estos patrones de filtro en el orden en que los especifique, por lo que un patrón podría anular a otro especificado antes que él.
## Ejemplos de RDS para MySQL
En los siguientes ejemplos, se muestra cómo funciona el filtrado de datos para las integraciones sin ETL de ejemplos de RDS para MySQL:
+ Incluir todas las bases de datos y todas las tablas:
```
'include: *.*'
```
+ Incluir todas las tablas en la base de datos `books`:
```
'include: books.*'
```
+ Excluya cualquier tabla con el nombre `mystery`:
```
'include: *.*, exclude: *.mystery'
```
+ Incluir dos tablas específicas en la base de datos `books`:
```
'include: books.stephen_king, include: books.carolyn_keene'
```
+ Incluya todas las tablas de la base de datos `books`, excepto las que contengan la subcadena `mystery`:
```
'include: books.*, exclude: books./.*mystery.*/'
```
+ Incluya todas las tablas de la base de datos `books`, excepto las que comiencen por `mystery`:
```
'include: books.*, exclude: books./mystery.*/'
```
+ Incluya todas las tablas de la base de datos `books`, excepto las que finalicen por `mystery`:
```
'include: books.*, exclude: books./.*mystery/'
```
+ Incluya todas las tablas de la base de datos `books` que comiencen por `table_`, excepto la que se llama `table_stephen_king`. Por ejemplo, `table_movies` o `table_books` se replicaría, pero no `table_stephen_king`.
```
'include: books./table_.*/, exclude: books.table_stephen_king'
```
## Ejemplos de RDS para PostgreSQL
En los siguientes ejemplos, se muestra cómo funciona el filtrado de datos para las integraciones sin ETL de RDS para PostgreSQL:
+ Incluir todas las tablas en la base de datos `books`:
```
'include: books.*.*'
```
+ Excluya cualquier tabla nombrada `mystery` en la base de datos `books`:
```
'include: books.*.*, exclude: books.*.mystery'
```
+ Incluya una tabla dentro de la base de datos `books` en el esquema `mystery` y una tabla dentro de la base de datos `employee` en el esquema `finance`:
```
'include: books.mystery.stephen_king, include: employee.finance.benefits'
```
+ Incluya todas las tablas de la base de datos `books` y el esquema `science_fiction`, excepto las que contengan la subcadena `king`:
```
'include: books.science_fiction.*, exclude: books.*./.*king.*/
```
+ Incluya todas las tablas de la base de datos `books`, excepto las que tengan un nombre de esquema que comience por `sci`:
```
'include: books.*.*, exclude: books./sci.*/.*'
```
+ Incluya todas las tablas de la base de datos `books`, excepto las que estén en el esquema `mystery` y acaben en `king`:
```
'include: books.*.*, exclude: books.mystery./.*king/'
```
+ Incluya todas las tablas de la base de datos `books` que comiencen por `table_`, excepto la que se llama `table_stephen_king`. Por ejemplo, `table_movies` en el esquema `fiction` y `table_books` en el esquema `mystery` se replican, pero no `table_stephen_king` en ninguno de los dos esquemas:
```
'include: books.*./table_.*/, exclude: books.*.table_stephen_king'
```
## Ejemplos de RDS para Oracle
En los siguientes ejemplos, se muestra cómo funciona el filtrado de datos para las integraciones sin ETL de RDS para Oracle:
+ Incluya todas las tablas en la base de datos books:
```
'include: books.*.*'
```
+ Excluya las tablas denominadas mistery en la base de datos books:
```
'include: books.*.*, exclude: books.*.mystery'
```
+ Incluya una tabla dentro de la base de datos books en el esquema mystery y una tabla dentro de la base de datos employee en el esquema finance:
```
'include: books.mystery.stephen_king, include: employee.finance.benefits'
```
+ Incluya todas las tablas en el esquema de mistery dentro de la base de datos books:
```
'include: books.mystery.*'
```
### Consideraciones sobre diferenciación entre mayúsculas y minúsculas
Oracle Database y Amazon Redshift gestionan las mayúsculas y minúsculas de los nombres de los objetos de forma diferente, lo que afecta a la configuración del filtro de datos y a las consultas de destino. Tenga en cuenta lo siguiente:
+ Oracle Database almacena los nombres de bases de datos, esquemas y objetos en mayúsculas, a menos que se indique explícitamente en la instrucción `CREATE`. Por ejemplo, si crea `mytable` (sin comillas), el diccionario de datos de Oracle almacena el nombre de la tabla como `MYTABLE`. Si cita el nombre del objeto, el diccionario de datos conserva las mayúsculas y minúsculas.
+ Los filtros de datos zero-ETL distinguen entre mayúsculas y minúsculas y deben coincidir exactamente con las mayúsculas y minúsculas de los nombres de los objetos tal como aparecen en el diccionario de datos de Oracle.
+ Las consultas de Amazon Redshift utilizan de forma predeterminada los nombres de objetos en minúscula, a menos que se cite explícitamente. Por ejemplo, una consulta de `MYTABLE` (sin comillas) busca `mytable`.
Tenga en cuenta las diferencias entre mayúsculas y minúsculas cuando cree el filtro de Amazon Redshift y consulte los datos.
#### Creación de una integración en mayúsculas
Al crear una tabla sin especificar el nombre entre comillas dobles, Oracle Database almacena el nombre en mayúsculas en el diccionario de datos. Por ejemplo, puede crear `MYTABLE` con cualquiera de las siguientes instrucciones SQL.
```
CREATE TABLE REINVENT.MYTABLE (id NUMBER PRIMARY KEY, description VARCHAR2(100));
CREATE TABLE reinvent.mytable (id NUMBER PRIMARY KEY, description VARCHAR2(100));
CREATE TABLE REinvent.MyTable (id NUMBER PRIMARY KEY, description VARCHAR2(100));
CREATE TABLE reINVENT.MYtabLE (id NUMBER PRIMARY KEY, description VARCHAR2(100));
```
Como no ha citado el nombre de la tabla en las instrucciones anteriores, Oracle Database almacena el nombre del objeto en mayúsculas como `MYTABLE`.
Para replicar esta tabla en Amazon Redshift, debe especificar el nombre en mayúsculas en el filtro de datos del comando `create-integration`. El nombre del filtro zero-ETL y el nombre del diccionario de datos de Oracle deben coincidir.
```
aws rds create-integration \
--integration-name upperIntegration \
--data-filter "include: ORCL.REINVENT.MYTABLE" \
...
```
De forma predeterminada, Amazon Redshift almacena los datos en minúsculas. Para consultar `MYTABLE` en la base de datos replicada en Amazon Redshift, debe citar el nombre en mayúsculas `MYTABLE` para que coincida con el del diccionario de datos de Oracle.
```
SELECT * FROM targetdb1."REINVENT"."MYTABLE";
```
Las consultas siguientes no utilizan el mecanismo de entrecomillado. Todas devuelven un error porque buscan una tabla de Amazon Redshift llamada `mytable`, que usa el nombre en minúsculas predeterminado, pero la tabla se llama `MYTABLE` en el diccionario de datos de Oracle.
```
SELECT * FROM targetdb1."REINVENT".MYTABLE;
SELECT * FROM targetdb1."REINVENT".MyTable;
SELECT * FROM targetdb1."REINVENT".mytable;
```
Las siguientes consultas utilizan el mecanismo de entrecomillado para especificar un nombre en mayúsculas y minúsculas combinadas. Todas las consultas devuelven un error porque buscan una tabla de Amazon Redshift que no se llama `MYTABLE`.
```
SELECT * FROM targetdb1."REINVENT"."MYtablE";
SELECT * FROM targetdb1."REINVENT"."MyTable";
SELECT * FROM targetdb1."REINVENT"."mytable";
```
#### Creación de una integración en minúsculas
En el siguiente ejemplo alternativo, se utilizan comillas dobles para almacenar el nombre de la tabla en minúsculas en el diccionario de datos de Oracle. Se crea `mytable` de la siguiente manera.
```
CREATE TABLE REINVENT."mytable" (id NUMBER PRIMARY KEY, description VARCHAR2(100));
```
Oracle Database almacena el nombre de la tabla como `mytable` en minúsculas. Para replicar esta tabla en Amazon Redshift, debe especificar el nombre en minúsculas `mytable` en el filtro de datos zero-ETL.
```
aws rds create-integration \
--integration-name lowerIntegration \
--data-filter "include: ORCL.REINVENT.mytable" \
...
```
Al consultar esta tabla en la base de datos replicada en Amazon Redshift, puede especificar el nombre en minúsculas `mytable`. La consulta se realiza correctamente porque busca una tabla llamada `mytable`, que es el nombre de la tabla en el diccionario de datos de Oracle.
```
SELECT * FROM targetdb1."REINVENT".mytable;
```
Como Amazon Redshift utiliza de forma predeterminada los nombres de objetos en minúsculas, las siguientes consultas de `mytable` también se encuentran correctamente.
```
SELECT * FROM targetdb1."REINVENT".MYtablE;
SELECT * FROM targetdb1."REINVENT".MYTABLE;
SELECT * FROM targetdb1."REINVENT".MyTable;
```
Las consultas siguientes utilizan el mecanismo de entrecomillado para el nombre del objeto. Todas devuelven un error porque buscan una tabla de Amazon Redshift cuyo nombre es diferente de `mytable`.
```
SELECT * FROM targetdb1."REINVENT"."MYTABLE";
SELECT * FROM targetdb1."REINVENT"."MyTable";
SELECT * FROM targetdb1."REINVENT"."MYtablE";
```
#### Creación de una tabla con integración compuesta por mayúsculas y minúsculas
En el siguiente ejemplo, se utilizan comillas dobles para almacenar el nombre de la tabla en minúsculas en el diccionario de datos de Oracle. Se crea `MyTable` de la siguiente manera.
```
CREATE TABLE REINVENT."MyTable" (id NUMBER PRIMARY KEY, description VARCHAR2(100));
```
Oracle Database almacena el nombre de esta tabla como `MyTable` con mayúsculas y minúsculas combinadas. Para replicar esta tabla en Amazon Redshift, debe especificar el nombre en mayúsculas y minúsculas combinadas en el filtro de datos.
```
aws rds create-integration \
--integration-name mixedIntegration \
--data-filter "include: ORCL.REINVENT.MyTable" \
...
```
Al consultar esta tabla en la base de datos replicada en Amazon Redshift, debe especificar el nombre `MyTable` en mayúsculas y minúsculas combinadas entrecomillando el nombre del objeto.
```
SELECT * FROM targetdb1."REINVENT"."MyTable";
```
Como Amazon Redshift utiliza de forma predeterminada los nombres de objetos en minúsculas, las siguientes consultas no encuentran el objeto porque buscan el nombre `mytable` en minúscula.
```
SELECT * FROM targetdb1."REINVENT".MYtablE;
SELECT * FROM targetdb1."REINVENT".MYTABLE;
SELECT * FROM targetdb1."REINVENT".mytable;
```
**nota**
No puede usar expresiones regulares en el valor de filtro de nombre de la base de datos, el esquema o el nombre de la tabla en las integraciones de RDS para Oracle.
## Adición de filtros de datos a una integración
Puede configurar el filtrado de datos mediante la Consola de administración de AWS, la AWS CLI o la API de Amazon RDS.
**importante**
Si agrega un filtro después de crear una integración, Amazon RDS lo trata como si hubiera existido siempre. Elimina todos los datos del almacén de datos de destino que no coincidan con los nuevos criterios de filtrado y vuelve a sincronizar todas las tablas afectadas.
### Consola de RDS
**Adición de filtros de datos a una integración sin ETL**
1. Inicie sesión en la Consola de administración de AWS y abra la consola de Amazon RDS en [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. En el panel de navegación, elija **Integraciones sin ETL**. Seleccione la integración a la que desea agregar filtros de datos y, a continuación, elija **Modificar**.
1. En **Origen**, agregue una o más instrucciones `Include` y `Exclude`.
En la imagen siguiente, se muestra un ejemplo de filtros de datos para una integración de MySQL:
![\[Filtros de datos para una integración sin ETL en la consola de RDS\]](http://docs.aws.amazon.com/es_es/AmazonRDS/latest/UserGuide/images/zero-etl-filter-data.png)
1. Cuando esté satisfecho con los cambios, elija **Continuar** y **Guardar cambios**.
### AWS CLI
Para agregar filtros de datos a una integración sin ETL mediante la AWS CLI, llame al comando [modify-integration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/modify-integration.html). Además del identificador de integración, especifique el parámetro `--data-filter` con una lista separada por comas de filtros `Include` y `Exclude` Maxwell.
**Example**
En el siguiente ejemplo, se agregan patrones de filtro a `my-integration`.
Para Linux, macOS o Unix:
```
aws rds modify-integration \
--integration-identifier my-integration \
--data-filter 'include: foodb.*, exclude: foodb.tbl, exclude: foodb./table_\d+/'
```
Para Windows:
```
aws rds modify-integration ^
--integration-identifier my-integration ^
--data-filter 'include: foodb.*, exclude: foodb.tbl, exclude: foodb./table_\d+/'
```
### API de RDS
Para modificar una integración sin ETL mediante la API de RDS, llame a la operación [ModifyIntegration](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyIntegration.html). Especifique el identificador de integración y proporcione una lista separada por comas de patrones de filtro.
## Eliminación de filtros de datos de una integración
Al eliminar un filtro de datos de una integración, Amazon RDS vuelve a evaluar los filtros restantes como si el filtro eliminado nunca hubiera existido. A continuación, replica en el almacén de datos de destino cualquier dato excluido anteriormente que ahora cumpla los criterios. Esto desencadena una nueva sincronización de todas las tablas afectadas.
# Agregación de datos a una base de datos de RDS de origen y realización de consultas
Para terminar de crear una integración sin ETL que replique los datos de Amazon RDS en Amazon Redshift, debe crear una base de datos en el destino.
Para conexiones con Amazon Redshift, conéctese al clúster o grupo de trabajo de Amazon Redshift y cree una base de datos con una referencia al identificador de integración. A continuación, puede agregar datos a la base de datos de RDS de origen y verlos replicados en Amazon Redshift o Amazon SageMaker.
**Topics**
+ [Creación de una base de datos de destino](#zero-etl.create-db)
+ [Añadir datos a la base de datos de origen](#zero-etl.add-data-rds)
+ [Consulta de los datos de Amazon RDS en Amazon Redshift](#zero-etl.query-data-redshift)
+ [Diferencias de tipos de datos entre las bases de datos RDS y Amazon Redshift](#zero-etl.data-type-mapping)
+ [Operaciones DDL para RDS para PostgreSQL](#zero-etl.ddl-postgres)
## Creación de una base de datos de destino
Antes de empezar a replicar datos en Amazon Redshift y después de crear una integración, debe crear una base de datos en el almacén de datos de destino. Esta base de datos debe incluir una referencia al identificador de integración. También puede utilizar la consola de Amazon Redshift o el editor de consultas v2 para crear la base de datos.
Para obtener instrucciones sobre cómo crear una base de datos de destino, consulte [Creación de una base de datos de destino en Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.creating-db.html#zero-etl-using.create-db).
## Añadir datos a la base de datos de origen
Tras configurar la integración, puede completar la base de datos de RDS de origen con datos que desea replicar en el almacén de datos.
**nota**
Existen diferencias entre los tipos de datos en Amazon RDS y el almacén de análisis de destino. Para consultar una tabla de correspondencias de tipos de datos, consulte [Diferencias de tipos de datos entre las bases de datos RDS y Amazon Redshift](#zero-etl.data-type-mapping).
Primero, conéctese a la base de datos de origen mediante el cliente MySQL que prefiera. Para obtener instrucciones, consulte [Conexión a la instancia de base de datos de MySQL](USER_ConnectToInstance.md).
A continuación, cree una tabla e inserte una fila de datos de muestra.
**importante**
Asegúrese de que la tabla tenga una clave principal. De lo contrario, no se podrá replicar en el almacenamiento de datos de destino.
**RDS para MySQL**
En el siguiente ejemplo se usa la [utilidad MySQL Workbench](https://dev.mysql.com/downloads/workbench/).
```
CREATE DATABASE my_db;
USE my_db;
CREATE TABLE books_table (ID int NOT NULL, Title VARCHAR(50) NOT NULL, Author VARCHAR(50) NOT NULL,
Copyright INT NOT NULL, Genre VARCHAR(50) NOT NULL, PRIMARY KEY (ID));
INSERT INTO books_table VALUES (1, 'The Shining', 'Stephen King', 1977, 'Supernatural fiction');
```
**RDS para PostgreSQL**
En el siguiente ejemplo, se utiliza el terminal interactivo `[psql](https://www.postgresql.org/docs/current/app-psql.html)` de PostgreSQL. Al conectarse a la base de datos, incluya el nombre de la base de datos que desea replicar.
```
psql -h mydatabase.123456789012.us-east-2.rds.amazonaws.com -p 5432 -U username -d named_db;
named_db=> CREATE TABLE books_table (ID int NOT NULL, Title VARCHAR(50) NOT NULL, Author VARCHAR(50) NOT NULL,
Copyright INT NOT NULL, Genre VARCHAR(50) NOT NULL, PRIMARY KEY (ID));
named_db=> INSERT INTO books_table VALUES (1, 'The Shining', 'Stephen King', 1977, 'Supernatural fiction');
```
**RDS para Oracle**
En el siguiente ejemplo se utiliza SQL\$1Plus para conectarse a la base de datos de RDS para Oracle.
```
sqlplus 'user_name@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=dns_name)(PORT=port))(CONNECT_DATA=(SID=database_name)))'
SQL> CREATE TABLE books_table (ID int NOT NULL, Title VARCHAR(50) NOT NULL, Author VARCHAR(50) NOT NULL,
Copyright INT NOT NULL, Genre VARCHAR(50) NOT NULL, PRIMARY KEY (ID));
SQL> INSERT INTO books_table VALUES (1, 'The Shining', 'Stephen King', 1977, 'Supernatural fiction');
```
## Consulta de los datos de Amazon RDS en Amazon Redshift
Después de agregar datos a la base de datos de RDS, se replican en la base de datos de destino y ya se pueden consultar.
**Consulta de datos replicados**
1. Vaya a la consola de Amazon Redshift y seleccione el **editor de consultas v2** en el panel de navegación izquierdo.
1. Conéctese a su clúster o grupo de trabajo y elija su base de datos de destino (la que creó a partir de la integración) en el menú desplegable (**destination\$1database** en este ejemplo). Para obtener instrucciones sobre cómo crear una base de datos de destino, consulte [Creación de una base de datos de destino en Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.creating-db.html#zero-etl-using.create-db).
1. Utilice una instrucción SELECT para consultar los datos. En este ejemplo, puede ejecutar el siguiente comando para seleccionar todos los datos de la tabla que creó en la base de datos de RDS de origen:
```
SELECT * from my_db."books_table";
```
![\[Ejecute una instrucción SELECT en el editor de consultas. Como resultado, se agrega una única fila de datos de ejemplo a la base de datos de Amazon RDS.\]](http://docs.aws.amazon.com/es_es/AmazonRDS/latest/UserGuide/images/zero-etl-redshift-editor.png)
+ `my_db` es el nombre del esquema de la base de datos de RDS.
+ `books_table` es el nombre de la tabla de RDS.
También puede consultar los datos mediante un cliente de línea de comandos. Por ejemplo:
```
destination_database=# select * from my_db."books_table";
ID | Title | Author | Copyright | Genre | txn_seq | txn_id
----+–------------+---------------+-------------+------------------------+----------+--------+
1 | The Shining | Stephen King | 1977 | Supernatural fiction | 2 | 12192
```
**nota**
Para distinguir entre mayúsculas y minúsculas, utilice comillas dobles (" ") para los nombres de esquemas, tablas y columnas. Para obtener más información, consulte [enable\$1case\$1sensitive\$1identifier](https://docs.aws.amazon.com/redshift/latest/dg/r_enable_case_sensitive_identifier.html).
## Diferencias de tipos de datos entre las bases de datos RDS y Amazon Redshift
Las siguientes tablas muestran las asignaciones de RDS para MySQL, RDS para PostgreSQL y RDS para Oracle a tipos de datos de destino correspondiente. *Actualmente, Amazon RDS solo admite estos tipos de datos para integraciones sin ETL.*
Si una tabla del clúster de base de datos de origen incluye un tipo de datos no compatible, la tabla no se sincroniza y el destino no puede utilizarla. La transmisión desde el origen al destino continúa, pero la tabla con el tipo de datos no admitido no está disponible. Para corregir la tabla y hacer que esté disponible en el destino, debe revertir manualmente el cambio de ruptura y, a continuación, actualizar la integración ejecutando `[ALTER DATABASE...INTEGRATION REFRESH](https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_DATABASE.html)`.
**nota**
No puede actualizar las integraciones sin ETL con un Amazon SageMaker Lakehouse. En su lugar, elimine e intente crear la integración de nuevo.
**Topics**
+ [RDS para MySQL](#zero-etl.data-type-mapping-mysql)
+ [RDS para PostgreSQL](#zero-etl.data-type-mapping-postgres)
+ [RDS para Oracle](#zero-etl.data-type-mapping-oracle)
### RDS para MySQL
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/AmazonRDS/latest/UserGuide/zero-etl.querying.html)
### RDS para PostgreSQL
Las integraciones sin ETL para RDS para PostgreSQL no admiten tipos de datos personalizados ni tipos de datos creados por extensiones.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/AmazonRDS/latest/UserGuide/zero-etl.querying.html)
### RDS para Oracle
**Tipos de datos no admitidos**
Los siguientes tipos de datos de RDS para Oracle no son compatibles con Amazon Redshift:
+ `ANYDATA`
+ `BFILE`
+ `REF`
+ `ROWID`
+ `UROWID`
+ `VARRAY`
+ `SDO_GEOMETRY`
+ Tipos de datos definidos por el usuario
**Diferencias de tipos de datos**
En la siguiente tabla se muestran las diferencias de tipo de datos que afectan a una integración sin ETL cuando RDS para Oracle es el origen y Amazon Redshift es el destino.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/AmazonRDS/latest/UserGuide/zero-etl.querying.html)
## Operaciones DDL para RDS para PostgreSQL
Amazon Redshift se deriva de PostgreSQL, por lo que comparte varias características con RDS para PostgreSQL debido a su arquitectura PostgreSQL común. Las integraciones sin ETL aprovechan estas similitudes para agilizar la replicación de datos desde RDS para PostgreSQL a Amazon Redshift, asignando las bases de datos por nombre y utilizando la base de datos, el esquema y la estructura de tablas compartidos.
Tenga en cuenta los siguientes puntos al administrar las integraciones sin ETL de RDS para PostgreSQL:
+ El aislamiento se administra por base de datos.
+ La replicación se produce por base de datos.
+ Las bases de datos de RDS para PostgreSQL se asignan a las bases de datos de Amazon Redshift por nombre, con datos que fluyen a la base de datos de Redshift con el nombre correspondiente si se cambia el nombre de la original.
A pesar de sus similitudes, Amazon Redshift y RDS para PostgreSQL presentan diferencias importantes. En las siguientes secciones se describen las respuestas del sistema Amazon Redshift para las operaciones de DDL más comunes.
**Topics**
+ [Operaciones de base de datos](#zero-etl.ddl-postgres-database)
+ [Operaciones de esquema](#zero-etl.ddl-postgres-schema)
+ [Operaciones de tabla](#zero-etl.ddl-postgres-table)
### Operaciones de base de datos
En la siguiente tabla, se muestran las respuestas del sistema para las operaciones de DDL de base de datos.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/AmazonRDS/latest/UserGuide/zero-etl.querying.html)
### Operaciones de esquema
En la siguiente tabla, se muestran las respuestas del sistema para las operaciones DDL de esquema.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/AmazonRDS/latest/UserGuide/zero-etl.querying.html)
### Operaciones de tabla
En la siguiente tabla, se muestran las respuestas del sistema para las operaciones DDL de tabla.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/AmazonRDS/latest/UserGuide/zero-etl.querying.html)
# Visualización y supervisión de las integraciones sin ETL de Amazon RDS
Puede acceder a los detalles de una integración sin ETL de Amazon RDS para ver su información de configuración y su estado actual. También puede supervisar el estado de la integración consultando vistas concretas del sistema en Amazon Redshift. Además, Amazon Redshift publica determinadas métricas relacionadas con la integración en Amazon CloudWatch, que puede ver en la consola de Amazon Redshift.
**Topics**
+ [Visualización de las integraciones](#zero-etl.describing)
+ [Supervisión de las integraciones mediante tablas del sistema para Amazon Redshift](#zero-etl.monitoring)
+ [Supervisión de las integraciones con Amazon EventBridge para Amazon Redshift](#zero-etl.eventbridge)
## Visualización de las integraciones
Puede ver integraciones sin ETL de Amazon RDS con la Consola de administración de AWS, la AWS CLI o la API de RDS.
### Consola
**Para ver los detalles de una integración sin ETL**
1. Inicie sesión en la Consola de administración de AWS y abra la consola de Amazon RDS en [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Elija **Integraciones sin ETL** en el panel de navegación izquierdo.
1. Seleccione una integración para ver más detalles sobre ella, como la base de datos de origen y el almacenamiento de datos de destino.
![\[Detalles sobre una integración sin ETL\]](http://docs.aws.amazon.com/es_es/AmazonRDS/latest/UserGuide/images/zero-etl-integration-view.png)
Una integración puede tener los siguientes estados:
+ `Creating`: la integración se está creando.
+ `Active`: la integración envía datos transaccionales al almacenamiento de datos de destino.
+ `Syncing`: la integración detectó un error recuperable y vuelve a almacenar los datos. Las tablas afectadas no están disponibles para consultas hasta que no terminen la resincronización.
+ `Needs attention`: la integración detectó un evento o error que requiere la intervención manual para su resolución. Para solucionar el problema, siga las instrucciones del mensaje de error que aparece en la página de detalles de la integración.
+ `Failed`: la integración detectó un evento o error irrecuperable que no se puede corregir. Debe eliminar y volver a crear la integración.
+ `Deleting`: la integración se está eliminando.
### AWS CLI
Para ver todas las integraciones sin ETL de la cuenta actual mediante la AWS CLI, utilice el comando [describe-integrations](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-integrations.html) y especifique la opción `--integration-identifier`.
**Example**
Para Linux, macOS o Unix:
```
aws rds describe-integrations \
--integration-identifier ee605691-6c47-48e8-8622-83f99b1af374
```
Para Windows:
```
aws rds describe-integrations ^
--integration-identifier ee605691-6c47-48e8-8622-83f99b1af374
```
### API de RDS
Para ver una integración sin ETL mediante la API de Amazon RDS, utilice la operación [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeIntegrations.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeIntegrations.html) con el parámetro `IntegrationIdentifier`.
## Supervisión de las integraciones mediante tablas del sistema para Amazon Redshift
Amazon Redshift dispone de muchas tablas y vistas de sistema que contienen información acerca de cómo funciona el sistema. Puede consultar estas tablas y vistas de sistema de la misma forma que lo haría con cualquier otra tabla de bases de datos. Para obtener más información acerca de las vistas y tablas del sistema en Amazon Redshift, consulte la [Referencia de las tablas y vistas de sistema](https://docs.aws.amazon.com//redshift/latest/dg/cm_chap_system-tables.html) en la *Guía del desarrollador de bases de datos de Amazon Redshift*.
Puede consultar las siguientes vistas y tablas del sistema para obtener información sobre las integraciones sin ETL de :
+ [SVV\$1INTEGRATION](https://docs.aws.amazon.com/redshift/latest/dg/r_SVV_INTEGRATION.html): proporciona detalles de configuración de sus integraciones.
+ [SVV\$1INTEGRATION\$1TABLE\$1STATE](https://docs.aws.amazon.com/redshift/latest/dg/r_SVV_INTEGRATION_TABLE_STATE.html): describe el estado de cada tabla de una integración.
+ [SYS\$1INTEGRATION\$1TABLE\$1STATE\$1CHANGE](https://docs.aws.amazon.com/redshift/latest/dg/r_SYS_INTEGRATION_TABLE_STATE_CHANGE.html): muestra los cambios de estado de las tablas de una integración.
+ [SYS\$1INTEGRATION\$1ACTIVITY](https://docs.aws.amazon.com/redshift/latest/dg/r_SYS_INTEGRATION_ACTIVITY.html): proporciona información sobre las ejecuciones de integración finalizadas.
Todas las métricas de Amazon CloudWatch provienen de Amazon Redshift. Para obtener información, consulte [Métricas para integraciones sin ETL](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.monitoring.html) en la *Guía de administración de Amazon Redshift*. Actualmente, Amazon RDS no publica ninguna métrica relacionada con la integración en CloudWatch.
## Supervisión de las integraciones con Amazon EventBridge para Amazon Redshift
Amazon Redshift envía eventos relacionados con la integración a Amazon EventBridge. Para obtener una lista de los eventos y sus correspondientes ID, consulte la sección sobre [notificaciones de eventos de integración sin ETL con Amazon EventBridge](https://docs.aws.amazon.com/redshift/latest/mgmt/integration-event-notifications) en la *Guía de administración de Amazon Redshift*.
# Modificación de las integraciones sin ETL de Amazon RDS
Solo puede modificar el nombre, la descripción y las opciones de filtrado de datos para una integración sin ETL en un almacén de datos compatible. No puede modificar la clave AWS KMS utilizada para cifrar la integración ni las bases de datos de origen o destino.
Si agrega un filtro a una integración existente, Amazon RDS volverá a evaluar el filtro como si hubiera existido siempre. Elimina cualquier dato que se encuentre actualmente en el almacén de datos de destino y que no coincida con los nuevos criterios de filtrado. Si *elimina* un filtro de datos de una integración, este replica todos los datos que anteriormente no coincidían con los criterios de filtrado (pero que ahora sí) en el almacenamiento de datos de destino. Para obtener más información, consulte [Filtrado de datos para integraciones sin ETL de Amazon RDS](zero-etl.filtering.md).
Puede modificar la integración sin ETL mediante la Consola de administración de AWS, la AWS CLI o la API de Amazon RDS.
## Consola de RDS
**Modificación de una integración sin ETL**
1. Inicie sesión en la Consola de administración de AWS y abra la consola de Amazon RDS en [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. En el panel de navegación, elija **Integraciones sin ETL** y, a continuación, elija la integración que desee modificar.
1. Elija **Modificar** y modifique cualquier configuración disponible.
1. Cuando haya realizado todos los cambios que desee, elija **Modificar**.
## AWS CLI
Para modificar una integración sin ETL utilizando la AWS CLI, llame al comando [modify-integration](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-integration.html). Junto con `--integration-identifier`, especifique cualquiera de las siguientes opciones:
+ `--integration-name`: especifique un nombre nuevo para la integración.
+ `--description`: especifique una descripción nueva para la integración.
+ `--data-filter`: especifique las opciones de filtrado de datos para la integración. Para obtener más información, consulte [Filtrado de datos para integraciones sin ETL de Amazon RDS](zero-etl.filtering.md).
**Example**
La siguiente solicitud modifica una integración existente.
Para Linux, macOS o Unix:
```
aws rds modify-integration \
--integration-identifier ee605691-6c47-48e8-8622-83f99b1af374 \
--integration-name my-renamed-integration
```
Para Windows:
```
aws rds modify-integration ^
--integration-identifier ee605691-6c47-48e8-8622-83f99b1af374 ^
--integration-name my-renamed-integration
```
## API de RDS
Para modificar una integración sin ETL mediante la API de RDS, llame a la operación [ModifyIntegration](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyIntegration.html). Especifique el identificador de integración y los parámetros que desee modificar.
# Eliminación de las integraciones sin ETL de Amazon RDS
Al eliminar una integración sin ETL, Amazon RDS la elimina de la base de datos de origen. Los datos transaccionales no se eliminan de Amazon RDS ni del destino de los análisis, pero Amazon RDS no envía nuevos datos a Amazon Redshift o Amazon SageMaker.
Solo puede eliminar una integración si su estado es `Active`, `Failed`, `Syncing`, o `Needs attention`.
Puede eliminar las integraciones sin ETL mediante la Consola de administración de AWS, AWS CLI o la API de RDS.
## Consola
**Eliminación de una integración sin ETL**
1. Inicie sesión en la Consola de administración de AWS y abra la consola de Amazon RDS en [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Elija **Integraciones sin ETL** en el panel de navegación.
1. Seleccione la integración sin ETL que desea eliminar.
1. Elija **Acciones**, **Eliminar dominio** y confirme la eliminación.
## AWS CLI
Para eliminar una integración sin ETL, utilice el comando [delete-integration](https://docs.aws.amazon.com/cli/latest/reference/rds/delete-integration.html) y especifique la opción `--integration-identifier`.
**Example**
Para Linux, macOS o Unix:
```
aws rds delete-integration \
--integration-identifier ee605691-6c47-48e8-8622-83f99b1af374
```
Para Windows:
```
aws rds delete-integration ^
--integration-identifier ee605691-6c47-48e8-8622-83f99b1af374
```
## API de RDS
Para eliminar una integración sin ETL mediante la API de Amazon RDS, utilice la operación [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DeleteIntegration.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DeleteIntegration.html) con el parámetro `IntegrationIdentifier`.
# Solución de problemas de integraciones sin ETL de Amazon RDS
Para comprobar el estado de una integración sin ETL, consulte la tabla del sistema [SVV\$1INTEGRATION](https://docs.aws.amazon.com/redshift/latest/dg/r_SVV_INTEGRATION.html) en el destino de análisis. Si la columna `state` tiene un valor de `ErrorState`, significa que algo está mal. Para obtener más información, consulte [Supervisión de las integraciones mediante tablas del sistema para Amazon Redshift](zero-etl.describingmonitoring.md#zero-etl.monitoring).
Utilice la siguiente información para solucionar problemas habituales relacionados con las integraciones sin ETL de Amazon RDS.
**importante**
Las operaciones de resincronización y actualización no están disponibles para las integraciones sin ETL con un Amazon SageMaker AI Lakehouse. Si hay problemas con una integración, debe eliminarla y crear una nueva. No puede actualizar ni volver a sincronizar una integración existente.
**Topics**
+ [No puedo crear una integración sin ETL](#zero-etl.troubleshooting.creation)
+ [Mi integración está atascada en un estado de `Syncing`](#zero-etl.troubleshooting.syncing)
+ [Mis tablas no se replican en Amazon Redshift](#zero-etl.troubleshooting.primarykey)
+ [Una o más de mis tablas de Amazon Redshift requieren una resincronización](#zero-etl.troubleshooting.resync)
+ [Problemas de integración erróneos para las integraciones sin ETL de Amazon SageMaker AI Lakehouse](#zero-etl.troubleshooting.integration-issues)
## No puedo crear una integración sin ETL
Si no puede crear una integración sin ETL, asegúrese de que los siguientes elementos sean correctos para la base de datos de origen:
+ La base de datos de origen debe ejecutar una versión de motor de base de datos compatible. Para obtener una lista de las versiones compatibles, consulte [Regiones y motores de base de datos admitidos para las integraciones sin ETL de Amazon RDS](Concepts.RDS_Fea_Regions_DB-eng.Feature.ZeroETL.md).
+ Ha configurado correctamente los parámetros de la base de datos. Si los parámetros requeridos están configurados incorrectamente o no están asociados a la base de datos, se producirá un error en la creación. Consulte [Crear un grupo de parámetros de de base de datos personalizado](zero-etl.setting-up.md#zero-etl.parameters).
Además, asegúrese de que lo siguiente sea correcto para su almacenamiento de datos de destino:
+ La distinción entre mayúsculas y minúsculas está activada. Consulte [Turn on case sensitivity for your data warehouse](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.setting-up.html#zero-etl-setting-up.case-sensitivity).
+ Ha añadido la entidad principal autorizado y el origen de integración correctos. Consulte [Configuración de la autorización para el almacenamiento de datos de Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.setting-up.html#zero-etl-using.redshift-iam).
+ El almacenamiento de datos está cifrado (si se trata de un clúster aprovisionado). Consulte [Cifrado de la base de datos de Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-db-encryption.html).
## Mi integración está atascada en un estado de `Syncing`
Es posible que su integración muestre continuamente el estado `Syncing` si cambia el valor de uno de los parámetros de base de datos necesarios.
Para solucionarlo, compruebe los valores de los parámetros del grupo de parámetros asociado a la base de datos de origen y asegúrese de que coincidan con los valores requeridos. Para obtener más información, consulte [Crear un grupo de parámetros de de base de datos personalizado](zero-etl.setting-up.md#zero-etl.parameters).
Si modifica algún parámetro, asegúrese de reiniciar la base de datos para aplicar los cambios.
## Mis tablas no se replican en Amazon Redshift
Si no ve reflejadas una o varias tablas en Amazon Redshift, puede ejecutar el siguiente comando para volver a sincronizarlas:
```
ALTER DATABASE dbname INTEGRATION REFRESH TABLES table1, table2;
```
Para obtener más información, consulte [ALTER DATABASE](https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_DATABASE.html) en la Referencia de SQL de Amazon Redshift.
Es posible que los datos no se estén replicando porque una o varias de las tablas de origen no tienen una clave principal. El panel de supervisión de Amazon Redshift muestra el estado de estas tablas como `Failed` y el estado de la integración sin ETL global cambia a `Needs attention`. Para resolver este problema, puede identificar una clave existente en la tabla que pueda convertirse en clave principal o puede añadir una clave principal sintética. Para obtener soluciones detalladas, consulte [Handle tables without primary keys while creating Amazon Aurora MySQL or Amazon RDS for MySQL zero-ETL integrations with Amazon Redshift](https://aws.amazon.com/blogs/database/handle-tables-without-primary-keys-while-creating-amazon-aurora-mysql-or-amazon-rds-for-mysql-zero-etl-integrations-with-amazon-redshift/).
## Una o más de mis tablas de Amazon Redshift requieren una resincronización
La ejecución de algunos comandos en la base de datos de origen puede requerir que las tablas se vuelvan a sincronizar. En estos casos, la vista del sistema [SVV\$1INTEGRATION\$1TABLE\$1STATE](https://docs.aws.amazon.com/redshift/latest/dg/r_SVV_INTEGRATION_TABLE_STATE.html) muestra un `table_state` de `ResyncRequired`, lo que significa que la integración debe volver a cargar por completo los datos de esa tabla de MySQL a Amazon Redshift.
Cuando la tabla comienza a resincronizarse, entra en un estado de `Syncing`. No es necesario realizar ninguna acción manual para volver a sincronizar una tabla. Mientras se vuelven a sincronizar los datos de la tabla, no puede acceder a ellos en Amazon Redshift.
A continuación se muestran algunos ejemplos de operaciones que pueden poner una tabla en estado `ResyncRequired` y las posibles alternativas que se pueden considerar.
| Operación | Ejemplo | Alternativa |
| --- | --- | --- |
| Añadir una columna a una posición específica | ALTER TABLE table_name
ADD COLUMN column_name INTEGER
NOT NULL first;
| Amazon Redshift no admite la adición de columnas en posiciones específicas mediante las palabras clave first o after. Si el orden de las columnas de la tabla de destino no es crucial, añada la columna al final de la tabla con un comando más sencillo:ALTER TABLE table_name
ADD COLUMN column_name column_type;
|
| Añadir una columna de marca temporal con la opción predeterminada CURRENT\$1TIMESTAMP | ALTER TABLE table_name
ADD COLUMN column_name TIMESTAMP
NOT NULL DEFAULT CURRENT_TIMESTAMP;
| RDS para MySQL calcula el valor CURRENT\$1TIMESTAMP de las filas de la tabla existentes y no se puede simular en Amazon Redshift sin una resincronización completa de los datos de la tabla. Si es posible, cambie el valor predeterminado a una constante literal, por ejemplo, `2023-01-01 00:00:15` para evitar la latencia en la disponibilidad de la tabla. |
| Realizar operaciones en varias columnas con un solo comando | ALTER TABLE table_name
ADD COLUMN column_1,
RENAME COLUMN column_2 TO column_3;
| Considere la posibilidad de dividir el comando en dos operaciones distintas ADD y RENAME lo que no requerirá resincronización. |
## Problemas de integración erróneos para las integraciones sin ETL de Amazon SageMaker AI Lakehouse
Si tiene problemas con una integración sin ETL existente con un Amazon SageMaker AI Lakehouse, la única solución es eliminar la integración y crear una nueva. A diferencia de otros servicios de AWS, las integraciones sin ETL no admiten operaciones de actualización o resincronización.
Para resolver problemas de integración:
1. Elimine la integración sin ETL problemática mediante la consola, la CLI o la API.
1. Compruebe que las configuraciones de la base de datos de origen y del almacén de datos de destino sean correctas.
1. Cree una nueva integración sin ETL con la misma configuración o una actualizada.
Este proceso resultará en una reinicialización completa de la canalización de datos, lo que puede llevar tiempo en función del tamaño de la base de datos de origen.