Guida introduttiva alle integrazioni Zero-ETL di Aurora con Amazon Redshift

Prima di creare un'integrazione zero-ETL con Amazon Redshift, configura il DB e il data warehouse Amazon Redshift con i parametri e le autorizzazioni richiesti. Durante la configurazione, dovrai completare i seguenti passaggi:

1. Creazione di un gruppo di parametri per il cluster DB personalizzato..

2. Crea cluster DB di database di origine.

3. Creazione di un data warehouse Amazon Redshift di destinazione.

Dopo aver completato questi passaggi, passa alla sezione Creazione di integrazioni Zero-ETL di Aurora con Amazon Redshift.

Puoi utilizzare gli AWS SDK per automatizzare il processo di configurazione. Per ulteriori informazioni, consulta Configura un'integrazione utilizzando gli AWS SDK (solo Aurora MySQL).

Fase 1: creazione di un gruppo di parametri del cluster DB personalizzato

Le integrazioni Aurora zero-ETL con Amazon Redshift richiedono valori specifici per i parametri del cluster DB che controllano la replica. In particolare, Aurora MySQL richiede binlog () avanzato e Aurora PostgreSQL richiede una replica logica avanzata ()aurora_enhanced_binlog. aurora.enhanced_logical_replication

Per configurare la registrazione binaria o la replica logica, è necessario innanzitutto creare un gruppo di parametri del cluster DB personalizzato e quindi associarlo al cluster DB di origine.

Crea un gruppo di parametri del cluster DB personalizzato con le seguenti impostazioni a seconda del motore DB di origine. Per istruzioni sulla creazione di un gruppo di parametri, consulta Utilizzo di gruppi di parametri di cluster di database.

Aurora MySQL (famiglia 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

Inoltre, assicurati che il parametro binlog_transaction_compression non sia impostato su ON e che il parametro binlog_row_value_options non sia impostato su PARTIAL_JSON.

Per ulteriori informazioni su Aurora MySQL Enhanced binlog, consulta. Configurazione del file di log binario avanzato

Aurora PostgreSQL (famiglia aurora-postgresql15):

Nota

Per i cluster Aurora PostgreSQL DB, è necessario creare il gruppo di parametri personalizzato all'interno dell'Amazon RDS Database Preview Environment, negli Stati Uniti orientali (Ohio) (us-east-2). Regione AWS

• rds.logical_replication=1

• aurora.enhanced_logical_replication=1

• aurora.logical_replication_backup=0

• aurora.logical_replication_globaldb=0

L'abilitazione della replica logica avanzata (aurora.enhanced_logical_replication) imposta automaticamente il REPLICA IDENTITY parametro suFULL, il che significa che tutti i valori delle colonne vengono scritti nel log di scrittura anticipata (WAL). Ciò aumenterà gli IOPS per il cluster DB di origine.

Passaggio 2: selezionare o creare un cluster DB del di origine

Dopo aver creato un gruppo di parametri del cluster DB personalizzato, scegli o crea un cluster . Questo cluster di sarà l'origine della replica dei dati su Amazon Redshift.

Il cluster di deve eseguire Aurora PostgreSQL (compatibile con PostgreSQL 15.4 e Zero-ETL Support). cluster DB di istanze DB Single-AZ o Multi-AZ, consulta.

Nota

È necessario creare cluster Aurora PostgreSQL DB all'interno dell'ambiente di anteprima del database Amazon RDS, negli Stati Uniti orientali (Ohio) (us-east-2). Regione AWS

In Configurazione aggiuntiva, modifica il gruppo di parametri predefinito del cluster DB con il gruppo di parametri personalizzato creato nel passaggio precedente.

Nota

Per Aurora MySQL, Per istruzioni, consulta Riavvio di un cluster Amazon Aurora DB o di un'istanza Amazon Aurora DB.

Durante la versione di anteprima delle integrazioni Aurora PostgreSQL Zero-ETL con Amazon Redshift, devi associare il cluster al gruppo di parametri del cluster DB personalizzato durante la creazione del cluster. Non è possibile eseguire questa azione dopo che il cluster DB di origine è già stato creato, altrimenti è necessario eliminare e ricreare il cluster.

Fase 3: creazione di un data warehouse Amazon Redshift di destinazione

Dopo aver creato il cluster DB del di origine, devi creare e configurare un data warehouse di destinazione in Amazon Redshift. Il data warehouse deve soddisfare i seguenti requisiti:

• Creato in anteprima (solo per sorgenti Aurora PostgreSQL). Per i sorgenti Aurora MySQL, è necessario creare cluster e gruppi di lavoro di produzione.

  • Per creare un'anteprima del cluster con provisioning, scegli Crea cluster di anteprima dal banner sulla dashboard dei cluster con provisioning. Per ulteriori informazioni, consulta Creazione di un cluster di anteprima.

    

    Quando crei il cluster, imposta Traccia anteprima su preview_2023.

  • Per creare un'anteprima del gruppo di lavoro Redshift Serverless, scegli Crea gruppo di lavoro di anteprima dal banner sulla dashboard Serverless. Per ulteriori informazioni, consulta Creazione di un gruppo di lavoro di anteprima.

    

• Utilizzando un tipo di nodo RA3 (ra3.xlplusra3.4xlarge, ora3.16xlarge) o Redshift Serverless.

• Deve essere crittografato (se si utilizza un cluster con provisioning). Per ulteriori informazioni, consulta Crittografia dei database di Amazon Redshift.

Per istruzioni su come creare un data warehouse, consulta Creazione di un cluster per i cluster con provisioning o Creazione di un gruppo di lavoro con uno spazio dei nomi per Redshift Serverless.

Abilitazione della distinzione tra maiuscole e minuscole nel data warehouse

Affinché l'integrazione venga eseguita correttamente, il parametro di distinzione tra maiuscole e minuscole (enable_case_sensitive_identifier) deve essere abilitato per il data warehouse. Per impostazione predefinita, la distinzione tra maiuscole e minuscole è disabilitata su tutti i cluster con provisioning e sui gruppi di lavoro Redshift serverless.

Per abilitare la distinzione tra maiuscole e minuscole, esegui i seguenti passaggi a seconda del tipo di data warehouse:

• Cluster con provisioning: per abilitare la distinzione tra maiuscole e minuscole su un cluster con provisioning, crea un gruppo di parametri personalizzato con il parametro enable_case_sensitive_identifier abilitato. Poi, associa il gruppo di parametri al cluster. Per istruzioni, consulta Gestione di gruppi di parametri mediante la console o Configurazione dei valori di parametro mediante AWS CLI.

  Nota

  Ricordati di riavviare il cluster dopo aver associato il gruppo di parametri personalizzati.

• Gruppo di lavoro serverless: per abilitare la distinzione tra maiuscole e minuscole su un gruppo di lavoro SRedshift Serverless, è necessario utilizzare la AWS CLI. La console Amazon Redshift attualmente non supporta la modifica dei valori dei parametri Redshift Serverless. Invia la seguente richiesta di aggiornamento al gruppo di lavoro:

  aws redshift-serverless update-workgroup \
    --workgroup-name target-workgroup \
    --config-parameters parameterKey=enable_case_sensitive_identifier,parameterValue=true

  Non è necessario riavviare un gruppo di lavoro dopo aver modificato i valori dei parametri.

Configura l'autorizzazione per il data warehouse

Dopo aver creato un data warehouse, è necessario configurare il di origine Aurora DB cluster come fonte di integrazione autorizzata. Per istruzioni, consulta Configurazione dell'autorizzazione per il data warehouse Amazon Redshift.

Configura un'integrazione utilizzando gli AWS SDK (solo Aurora MySQL)

Invece di configurare ogni risorsa manualmente, puoi eseguire il seguente script Python per configurare automaticamente le risorse richieste. L'esempio di codice lo utilizza AWS SDK for Python (Boto3)per creare un cluster DB Aurora MySQL di origine e indirizzare il data warehouse Amazon Redshift, ciascuno con i valori dei parametri richiesti. Attende quindi che i cluster siano disponibili prima di creare un'integrazione zero-ETL tra di essi. È possibile commentare diverse funzioni a seconda delle risorse che è necessario configurare.

Per installare le dipendenze richieste, eseguire i seguenti comandi:

pip install boto3
pip install time

All'interno dello script, modificate facoltativamente i nomi dei gruppi di origine, destinazione e parametri. La funzione finale crea un'integrazione che my-integration prende il nome dall'impostazione delle risorse.

Esempio di codice 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()

Passaggi successivi

Con un di origine, un cluster Aurora DB e un data warehouse di destinazione Amazon Redshift, ora puoi creare un'integrazione zero-ETL e replicare i dati. Per istruzioni, consultare Creazione di integrazioni Zero-ETL di Aurora con Amazon Redshift.