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:

Una vez que haya completado estas tareas, continúe con Creación de integraciones sin ETL de Amazon RDS con Amazon Redshift o Creación de integraciones sin ETL de Amazon RDS con un Amazon SageMaker Lakehouse.

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:

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. Se recomienda configurar todos los valores de los parámetros en la misma solicitud para evitar problemas de dependencia.

RDS para MySQL:

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. 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:

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 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.

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. 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.

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.

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.

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.

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:

Para obtener instrucciones sobre cómo crear un almacenamiento de datos, consulte la sección Creación de un clúster para clústeres aprovisionados o Creación de un grupo de trabajo con un espacio de nombres 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 (enable_case_sensitive_identifier) 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:

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.

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) 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.

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 AI

Al crear una integración sin ETL con un Amazon SageMaker AI de 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.

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.

Pasos a seguir a continuación

Con una base de datos de RDS de origen y un almacén de datos de destino de Amazon Redshift o Lakehouse de Amazon SageMaker AI, 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.