Introducción a las integraciones sin ETL de Aurora con Amazon Redshift

Antes de crear una integración sin ETL con Amazon Redshift, configure su clúster de base de datos de Aurora y el almacenamiento de datos de Amazon Redshift con los parámetros y permisos necesarios. Durante la configuración, realizará los siguientes pasos:

1. Cree un grupo de parámetros de clúster de base de datos personalizado.

2. Cree un clúster de base de datos.

3. Creación de un almacén de datos de Amazon Redshift de destino.

Una vez que haya completado estos pasos, continúe con la Creación de integraciones sin ETL de Aurora con Amazon Redshift.

Puede utilizar los SDK de AWS para automatizar el proceso de configuración. Para obtener más información, consulte Configuración de una integración mediante los SDK de AWS (solo Aurora MySQL).

Crear un grupo de parámetros de clúster de base de datos personalizado

Las integraciones sin ETL de Aurora con Amazon Redshift requieren valores específicos para los parámetros del clúster de base de datos que controlan la replicación. En concreto, Aurora MySQL requiere un binlog mejorado (aurora_enhanced_binlog) y Aurora PostgreSQL requiere replicación lógica mejorada (aurora.enhanced_logical_replication).

Para configurar el registro binario o la replicación lógica, primero debe crear un grupo de parámetros personalizado del clúster de base de datos y, a continuación, asociarlo al clúster de base de datos de origen.

Cree un grupo de parámetros de clúster de base de datos personalizado con los siguientes ajustes en función del motor de base de datos de origen. Para obtener instrucciones sobre cómo crear un grupo de parámetros, consulte .

Aurora MySQL (familia aurora-mysql8.0):

• aurora_enhanced_binlog=1

• binlog_backup=0

• binlog_format=ROW

• binlog_replication_globaldb=0

• binlog_row_image=full

• binlog_row_metadata=full

Además, compruebe que el parámetro binlog_transaction_compression no esté establecido en ON y que el parámetro binlog_row_value_options no esté establecido en PARTIAL_JSON.

Para obtener más información sobre el binlog mejorado de Aurora MySQL, consulte Configuración del binlog mejorado para Aurora MySQL.

Aurora PostgreSQL (familia aurora-postgresql15):

nota

Para los clústeres de base de datos de Aurora PostgreSQL, debe crear el grupo de parámetros personalizados en el entorno de vista previa de bases de datos de Amazon RDS, en la Región de AWS de Este de EE. UU. (Ohio) (us-east-2).

• rds.logical_replication=1

• aurora.enhanced_logical_replication=1

• aurora.logical_replication_backup=0

• aurora.logical_replication_globaldb=0

Al habilitar la replicación lógica mejorada (aurora.enhanced_logical_replication), el parámetro REPLICA IDENTITY se establece automáticamente en FULL, lo que significa que todos los valores de las columnas se escriben en el registro de escritura previa (WAL). Esto aumentará las IOPS del clúster de base de datos de origen.

Paso 2: seleccionar o crear un clúster de base de datos de origen

Tras crear un grupo de parámetros personalizado del clúster de base de datos, elija o cree un clúster de base de datos de Aurora MySQL o Aurora PostgreSQL. Este clúster será el origen de la réplica de datos en Amazon Redshift.

El clúster debe ejecutar Aurora MySQL versión  3.05 (compatible con MySQL 8.0.32) o posterior o Aurora PostgreSQL (compatible con PostgreSQL 15.4 y compatibilidad sin ETL). Para obtener instrucciones sobre cómo crear un clúster de base de datos, consulte Creación de un clúster de base de datos de Amazon Aurora.

nota

Debe crear clústeres de base de datos de Aurora PostgreSQL en el entorno de vista previa de bases de datos de Amazon RDS, en la Región de AWS de Este de EE. UU. (Ohio) (us-east-2).

En Configuración adicional, cambie el Grupo de parámetros del clúster de base de datos por el grupo de parámetros personalizado que creó en el paso anterior.

nota

Para Aurora MySQL, asocia el grupo de parámetros al clúster de base de datos después de haber creado el clúster, debe reiniciar la instancia de base de datos principal en el clúster a fin de aplicar los cambios antes de poder crear una integración sin ETL. Para obtener instrucciones, consulte Reinicio de un clúster de base de datos de Amazon Aurora o de una instancia de base de datos de Amazon Aurora.

Durante la versión de vista previa de las integraciones sin ETL de Aurora PostgreSQL con Amazon Redshift, debe asociar el clúster al grupo de parámetros del clúster de base de datos personalizado al crear el clúster. No puede realizar esta acción después de haber creado el clúster de base de datos de origen; de lo contrario, tendrá que eliminar y volver a crear el clúster.

Paso 3: Creación de un almacén de datos de destino en Amazon Redshift

Tras crear el clúster de base de datos de origen, debe crear y configurar un almacenamiento de datos de destino en Amazon Redshift. El almacenamiento de datos debe cumplir los siguientes requisitos:

• Creado en vista previa (solo para orígenes de Aurora PostgreSQL). Para los orígenes de Aurora MySQL, debe crear grupos de trabajo y clústeres de producción.

  • Para crear un clúster aprovisionado en versión preliminar, seleccione Crear clúster de vista previa en el encabezado del panel de clústeres aprovisionados. Para obtener más información, consulte Creación de un clúster de previsualización..

    

    Al crear el clúster, configure la pista Vista previa en preview_2023.

  • Para crear un grupo de trabajo Redshift sin servidor en versión preliminar, seleccione Crear grupo de trabajo de vista previa en el encabezado del panel de control sin servidor.. Para obtener más información, consulte Crear un grupo de trabajo de vista previa.

    

• Uso de un tipo de nodo RA3 (ra3.xlplus, ra3.4xlarge o ra3.16xlarge) 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.

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:

• 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 o Configuración de los valores de parámetros mediante la AWS CLI.

  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:

  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 el clúster de base de datos de Aurora 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 SDK de AWS (solo Aurora MySQL)

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 un clúster de base de datos Aurora MySQL de origen y un almacenamiento de datos de Amazon Redshift de destino, cada uno con los valores de parámetros necesarios. A continuación, espera a que los clústeres estén disponibles antes de crear una integración sin ETL entre ellos. 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_cluster_name = 'my-source-cluster' # A name for the source cluster
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_cluster(*args):
    """Creates a source Aurora MySQL DB cluster"""

    response = rds.create_db_cluster_parameter_group(
        DBClusterParameterGroupName=source_param_group_name,
        DBParameterGroupFamily='aurora-mysql8.0',
        Description='For Aurora MySQL zero-ETL integrations'
    )
    print('Created source parameter group: ' + response['DBClusterParameterGroup']['DBClusterParameterGroupName'])

    response = rds.modify_db_cluster_parameter_group(
        DBClusterParameterGroupName=source_param_group_name,
        Parameters=[
            {
                'ParameterName': 'aurora_enhanced_binlog',
                'ParameterValue': '1',
                'ApplyMethod': 'pending-reboot'
            },
            {
                'ParameterName': 'binlog_backup',
                'ParameterValue': '0',
                'ApplyMethod': 'pending-reboot'
            },
            {
                'ParameterName': 'binlog_format',
                'ParameterValue': 'ROW',
                'ApplyMethod': 'pending-reboot'
            },
            {
                'ParameterName': 'binlog_replication_globaldb',
                'ParameterValue': '0',
                'ApplyMethod': 'pending-reboot'
            },
            {
                'ParameterName': 'binlog_row_image',
                'ParameterValue': 'full',
                'ApplyMethod': 'pending-reboot'
            },
            {
                'ParameterName': 'binlog_row_metadata',
                'ParameterValue': 'full',
                'ApplyMethod': 'pending-reboot'
            }
        ]
    )
    print('Modified source parameter group: ' + response['DBClusterParameterGroupName'])

    response = rds.create_db_cluster(
        DBClusterIdentifier=source_cluster_name,
        DBClusterParameterGroupName=source_param_group_name,
        Engine='aurora-mysql',
        EngineVersion='8.0.mysql_aurora.3.05.2',
        DatabaseName='myauroradb',
        MasterUsername='username',
        MasterUserPassword='Password01**'
    )
    print('Creating source cluster: ' + response['DBCluster']['DBClusterIdentifier'])
    source_arn = (response['DBCluster']['DBClusterArn'])
    create_target_cluster(target_cluster_name, source_arn, target_param_group_name)

    response = rds.create_db_instance(
        DBInstanceClass='db.r6g.2xlarge',
        DBClusterIdentifier=source_cluster_name,
        DBInstanceIdentifier=source_cluster_name + '-instance',
        Engine='aurora-mysql'
    )
    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='For Aurora 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 specifying cluster ARN 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_cluster_availability(*args):
    """Waits for both clusters to be available"""

    print('Waiting for clusters to be available...')

    response = rds.describe_db_clusters(
        DBClusterIdentifier=source_cluster_name
    )
    source_status = response['DBClusters'][0]['Status']
    source_arn = response['DBClusters'][0]['DBClusterArn']

    response = rds.describe_db_instances(
        DBInstanceIdentifier=source_cluster_name + '-instance'
    )
    source_instance_status = response['DBInstances'][0]['DBInstanceStatus']

    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 clusters are available.
    if source_status != 'available' or target_status != 'available' or  source_instance_status != 'available':
        time.sleep(60)
        response = wait_for_cluster_availability(
            source_cluster_name, target_cluster_name)
    else:
        print('Clusters 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 clusters"""

    response = rds.create_integration(
        SourceArn=source_arn,
        TargetArn=target_arn,
        IntegrationName='my-integration'
    )
    print('Creating integration: ' + response['IntegrationName'])
    
def main():
    """main function"""
    create_source_cluster(source_cluster_name, source_param_group_name)
    wait_for_cluster_availability(source_cluster_name, target_cluster_name)

if __name__ == "__main__":
    main()

Siguientes pasos

Ahora que tiene un clúster de base de datos de Aurora de origen y un almacenamiento de datos de destino de Amazon Redshift, puede crear una integración sin ETL y empezar a replicar los datos. Para obtener instrucciones, consulte Creación de integraciones sin ETL de Aurora con Amazon Redshift.