Guida introduttiva alle integrazioni Zero-ETL di Amazon RDS

Prima di creare un’integrazione Zero-ETL, configura il database RDS e il data warehouse con le autorizzazioni e i parametri richiesti. Durante la configurazione, dovrai completare i seguenti passaggi:

Dopo aver completato queste attività, passa a Creazione di integrazioni Zero-ETL di Amazon RDS con Amazon Redshift o Creazione di integrazioni Zero-ETL di Amazon RDS con un Amazon SageMaker Lakehouse.

Per il Passaggio 3, puoi scegliere di creare un data warehouse di destinazione (Passaggio 3a) o un lakehouse di destinazione (Passaggio 3b) a seconda delle tue esigenze:

Fase 1: creazione di un gruppo di parametri del di database personalizzato

Le integrazioni Zero-ETL di Amazon RDS richiedono valori specifici per i parametri del database che controllano la replica dei dati. I parametri specifici dipendono dal motore del database di origine. Per configurare questi parametri, devi prima creare un gruppo di parametri del database personalizzato e quindi associarlo al database di origine. Configura i seguenti valori dei parametri in base al motore del database di origine. Per istruzioni sulla creazione di un gruppo di parametri, consulta Gruppi di parametri database per istanze database Amazon RDS. Si consiglia di configurare tutti i valori dei parametri all’interno della medesima richiesta per evitare problemi legati alle dipendenze.

RDS per MySQL:

Inoltre, assicurati che il parametro binlog_row_value_options non sia impostato su PARTIAL_JSON. Se il database di origine è un cluster di database Multi-AZ, assicurati che il parametro binlog_transaction_compression non sia impostato su ON.

Alcuni di questi parametri (ad esempio binlog_format) sono dinamici, quindi puoi applicare modifiche al parametro senza eseguire un riavvio. Ciò significa che alcune sessioni esistenti potrebbero continuare a utilizzare il vecchio valore del parametro. Per evitare che ciò causi problemi durante la creazione di un’integrazione Zero-ETL, abilita lo schema delle prestazioni. Lo schema delle prestazioni garantisce l’esecuzione di controlli Zero-ETL preliminari, che aiutano a rilevare i parametri mancanti nelle prime fasi del processo.

RDS per PostgreSQL:

Per più integrazioni PostgreSQL, verrà utilizzato uno slot di replica logica per integrazione. Rivedi i parametri max_replication_slots e max_wal_senders in base al tuo utilizzo.

Per una sincronizzazione efficiente dei dati nelle integrazioni Zero-ETL, imposta rds.replica_identity_full nell’istanza del database di origine. Ciò indica al database di registrare i dati di riga completi nel WAL (write-ahead log) durante le operazioni UPDATE e DELETE, anziché registrare solo le informazioni sulla chiave primaria. Zero-ETL richiede dati di riga completi anche quando tutte le tabelle replicate devono disporre di chiavi primarie. Per stabilire quali dati sono visibili durante le query, Amazon Redshift utilizza una strategia anti-join specializzata per confrontare i dati con una tabella per il tracciamento delle operazioni interne di eliminazione. La registrazione di log di immagini a riga intera aiuta Amazon Redshift a eseguire questi anti-join in modo efficiente. Senza i dati di riga completi, Amazon Redshift dovrebbe eseguire ricerche aggiuntive, che potrebbero rallentare le prestazioni durante le operazioni ad alto throughput nel motore a colonne utilizzato da Amazon Redshift.

RDS per Oracle:

Non è richiesta alcuna modifica dei parametri per RDS per Oracle.

Passaggio 2: seleziona o crea un database di origine

Dopo aver creato un gruppo di parametri personalizzato per il di database, scegli o crea un’istanza database RDS. Questo database sarà l’origine della replica dei dati nel data warehouse di destinazione. Per istruzioni su come creare un’istanza database Single-AZ o Multi-AZ, consulta Creazione di un'istanza database Amazon RDS. Per istruzioni su come creare un cluster di database Multi-AZ, consulta Creazione di un cluster di database Multi-AZ per Amazon RDS.

Il database deve eseguire una versione del motore di database supportata. Per un elenco delle versioni supportate, consulta Regioni e motori di database supportati per le integrazioni Zero-ETL di Amazon RDS.

Quando crei il database, in Configurazione aggiuntiva modifica il valore predefinito del gruppo di parametri del di database impostandolo sul gruppo di parametri personalizzato creato nel passaggio precedente.

Inoltre, assicurati che siano abilitati i backup automatici sul database. Per ulteriori informazioni, consulta Abilitazione dei backup automatici.

Passaggio 3a: creazione di un data warehouse di destinazione

Dopo aver creato il database di origine, è necessario creare e configurare un data warehouse di destinazione. Il data warehouse deve soddisfare i seguenti requisiti:

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:

Configura l’autorizzazione per il data warehouse

Dopo aver creato un data warehouse, è necessario configurare un database RDS di origine come origine autorizzata dell’integrazione. Per istruzioni, consulta Configurazione dell’autorizzazione per il data warehouse Amazon Redshift.

Configurazione di un’integrazione mediante gli SDK AWS

Invece di configurare ogni risorsa manualmente, puoi eseguire lo script Python riportato di seguito per configurare automaticamente le risorse richieste. L’esempio di codice utilizza AWS SDK per Python (Boto3) per creare un’istanza database RDS per MySQL di origine e un data warehouse di destinazione, ciascuno con i valori dei parametri richiesti. Attende quindi che i database siano disponibili prima di creare un’integrazione Zero-ETL tra di essi. Puoi commentare diverse funzioni a seconda delle risorse che è necessario configurare.

Per installare le dipendenze richieste, esegui i seguenti comandi:

pip install boto3
pip install time

All’interno dello script, è possibile modificare i nomi dei gruppi di origine, destinazione e parametri. Una volta che le risorse sono state impostate, la funzione finale crea un’integrazione che viene denominata my-integration.

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

Passaggio 3b: creazione di un catalogo AWS Glue per l’integrazione Zero-ETL con Amazon SageMaker AI

Quando crei un’integrazione Zero-ETL con un lakehouse Amazon SageMaker AI, è necessario creare un catalogo AWS Glue gestito in AWS Lake Formation. Il catalogo di destinazione deve essere un catalogo gestito di Amazon Redshift. Per creare un catalogo gestito di Amazon Redshift, crea innanzitutto il ruolo collegato al servizio AWSServiceRoleForRedshift. Nella console Lake Formation, aggiungi AWSServiceRoleForRedshift come amministratore di sola lettura.

Per ulteriori informazioni sulle attività precedenti, consulta i seguenti argomenti.

Configurazione delle autorizzazioni per il catalogo AWS Glue di destinazione

Prima di creare un catalogo di destinazioni per l’integrazione Zero-ETL, è necessario creare il ruolo di creazione di destinazioni di Lake Formation e il ruolo di trasferimento dei dati di AWS Glue. Usa il ruolo di creazione di destinazioni di Lake Formation per creare il catalogo di destinazioni. Quando crei il catalogo di destinazione, inserisci il ruolo di trasferimento dei dati Glue nel campo Ruolo IAM nella sezione Accesso dai motori.

Passaggi successivi

Utilizzando un database RDS di origine e un data warehouse Amazon Redshift di destinazione o un lakehouse Amazon SageMaker AI puoi creare un’integrazione Zero-ETL e replicare i dati. Per istruzioni, consultare Creazione di integrazioni Zero-ETL di Amazon RDS con Amazon Redshift.