Erste Schritte mit Null-ETL-Integrationen von Amazon RDS

Bevor Sie eine Null-ETL-Integration erstellen, konfigurieren Sie Ihre RDS-Datenbank und Ihr Data Warehouse mit den erforderlichen Parametern und Berechtigungen. Während der Einrichtung führen Sie die folgenden Schritte aus:

Wenn Sie diese Aufgaben abgeschlossen haben, fahren Sie mit Erstellen von Null-ETL-Integrationen von Amazon RDS mit Amazon Redshift oder Erstellen von Null-ETL-Integrationen von Amazon RDS mit einem Amazon SageMaker Lakehouse fort.

In Schritt 3 können Sie je nach Ihren Anforderungen entweder ein Ziel-Data-Warehouse (Schritt 3a) oder ein Ziel-Lakehouse (Schritt 3b) erstellen:

Schritt 1: Erstellen einer benutzerdefinierten DB--Parametergruppe

Null-ETL-Integrationen von Amazon RDS erfordern bestimmte Werte für die DB-Parameter, die die Datenreplikation steuern. Die konkreten Parameter hängen von Ihrer Quell-DB-Engine ab. Um diese Parameter zu konfigurieren, müssen Sie zunächst eine benutzerdefinierte DB-Parametergruppe erstellen und sie dann mit der Quelldatenbank verknüpfen. Konfigurieren Sie die folgenden Parameterwerte je nach Ihrer Quell-DB-Engine. Anleitungen zum Erstellen einer Parametergruppe finden Sie unter DB-Parametergruppen für DB-Instances von Amazon RDS. Wir empfehlen, alle Parameterwerte innerhalb derselben Anfrage zu konfigurieren, um Abhängigkeitsprobleme zu vermeiden.

RDS für MySQL:

Stellen Sie außerdem sicher, dass der binlog_row_value_options-Parameter nicht auf PARTIAL_JSON gesetzt ist. Wenn die Quelldatenbank ein DB-Cluster mit Multi-AZ ist, stellen Sie sicher, dass der Parameter binlog_transaction_compression nicht auf ON festgelegt ist.

Einige dieser Parameter (z. B. binlog_format) sind dynamisch, was bedeutet, dass Sie Änderungen am Parameter vornehmen können, ohne einen Neustart auszulösen. Dies bedeutet, dass einige bestehende Sitzungen möglicherweise weiterhin den alten Wert des Parameters verwenden. Um zu verhindern, dass dies zu Problemen bei der Erstellung einer Null-ETL-Integration führt, aktivieren Sie das Leistungsschema. Das Leistungsschema stellt sicher, dass Null-ETL-Vorabprüfungen ausgeführt werden, mit deren Hilfe fehlende Parameter frühzeitig im Prozess erkannt werden können.

RDS für PostgreSQL:

Bei mehreren PostgreSQL-Integrationen wird pro Integration ein logischer Replikationsslot verwendet. Überprüfen Sie die Parameter max_replication_slots und max_wal_senders je nach Nutzung.

Für eine effiziente Datensynchronisation in Null-ETL-Integrationen legen Sie rds.replica_identity_full in Ihrer Quell-DB-Instance fest. Dadurch wird die Datenbank angewiesen, während der UPDATE- und DELETE-Operationen vollständige Zeilendaten im Write-Ahead-Protokoll (WAL) zu protokollieren, nicht nur Primärschlüsselinformationen. Null-ETL benötigt vollständige Zeilendaten, auch wenn für alle replizierten Tabellen Primärschlüssel erforderlich sind. Um festzustellen, welche Daten bei Abfragen sichtbar sind, verwendet Amazon Redshift eine spezielle Anti-Join-Strategie, um Ihre Daten zur Nachverfolgung von Löschvorgängen mit einer internen Tabelle zu vergleichen. Durch das Protokollieren vollständiger Zeilenbilder kann Amazon Redshift diese Anti-Joins effizient durchführen. Ohne vollständige Zeilendaten müsste Amazon Redshift zusätzliche Suchvorgänge durchführen, was die Leistung bei Vorgängen mit hohem Durchsatz in der von Amazon Redshift verwendeten Spalten-Engine beeinträchtigen könnte.

RDS für Oracle:

Bei RDS für Oracle sind keine Parameteränderungen erforderlich.

Schritt 2: Wählen oder Erstellen einer Quelldatenbank

Nachdem Sie eine benutzerdefinierte DB-Parametergruppe erstellt haben, wählen oder erstellen Sie eine DB-Instance von RDS für MySQL . Diese Datenbank dient als Quelle der Datenreplikation in das Ziel-Data-Warehouse. Anleitungen zum Erstellen einer DB-Instance mit Single-AZ oder Multi-AZ finden Sie unter Erstellen einer Amazon-RDS-DB-Instance. Anleitungen zum Erstellen eines DB-Clusters mit Multi-AZ finden Sie unter Erstellen eines Multi-AZ-DB-Clusters für Amazon RDS.

In der Datenbank muss eine unterstützte DB-Engine-Version ausgeführt werden. Eine Liste der unterstützten Versionen finden Sie unter Unterstützte Regionen und DB-Engines für Amazon-RDS-Null-ETL-Integrationen.

Wenn Sie die Datenbank erstellen, ändern Sie unter Zusätzliche Konfiguration die standardmäßige DB-Parametergruppe in die benutzerdefinierte Parametergruppe, die Sie im vorherigen Schritt erstellt haben.

Stellen Sie außerdem sicher, dass automatisierte Backups in der Datenbank aktiviert sind. Weitere Informationen finden Sie unter Aktivieren von automatisierten Backups.

Schritt 3a: Erstellen eines Ziel-Data-Warehouse

Nachdem Sie die Quelldatenbank erstellt haben, müssen Sie ein Ziel-Data-Warehouse erstellen und konfigurieren. Das Data Warehouse muss die folgenden Anforderungen erfüllen:

Anweisungen zum Erstellen eines Data Warehouse finden Sie unter Erstellen eines Clusters für bereitgestellte Cluster oder Erstellen einer Arbeitsgruppe mit einem Namespace für Redshift Serverless.

Aktivieren Sie die Berücksichtigung von Groß- und Kleinschreibung im Data Warehouse

Damit die Integration erfolgreich ist, muss der Parameter für die Berücksichtigung von Groß- und Kleinschreibung (enable_case_sensitive_identifier) für das Data Warehouse aktiviert sein. Standardmäßig ist die Berücksichtigung von Groß- und Kleinschreibung auf allen bereitgestellten Clustern und Redshift-Serverless-Arbeitsgruppen deaktiviert.

Um die Berücksichtigung von Groß- und Kleinschreibung zu aktivieren, führen Sie je nach Data-Warehouse-Typ die folgenden Schritte aus:

Konfigurieren der Autorisierung für das Data Warehouse

Nachdem Sie ein Data Warehouse erstellt haben, müssen Sie die RDS-Quelldatenbank als autorisierte Integrationsquelle konfigurieren. Anleitungen finden Sie unter Konfigurieren der Autorisierung für Ihr Amazon-Redshift-Data-Warehouse.

Einrichten einer Integration mithilfe der AWS-SDKs

Anstatt jede Ressource manuell einzurichten, können Sie das folgende Python-Skript ausführen, um die erforderlichen Ressourcen automatisch einzurichten. Das Codebeispiel verwendet das AWS SDK für Python (Boto3), um eine DB-Instance von RDS für MySQL und ein Ziel-Data-Warehouse zu erstellen, jeweils mit den erforderlichen Parameterwerten. Dann wird abgewartet, bis die Datenbanken verfügbar sind, bevor eine Null-ETL-Integration zwischen ihnen erstellt wird. Sie können verschiedene Funktionen auskommentieren, je nachdem, welche Ressourcen Sie einrichten müssen.

Führen Sie die folgenden Befehle aus, um die erforderlichen Abhängigkeiten zu installieren:

pip install boto3
pip install time

Innerhalb des Skripts können Sie optional die Namen der Quell-, Ziel- und Parametergruppen ändern. Die letzte Funktion erstellt eine Integration namens my-integration nach der Einrichtung der Ressourcen.

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

Schritt 3b: Erstellen eines AWS Glue-Katalogs für die Null-ETL-Integration von Amazon SageMaker AI

Wenn Sie eine Null-ETL-Integration mit einem Amazon SageMaker AI Lakehouse erstellen, müssen Sie einen von AWS Glue verwalteten Katalog in AWS Lake Formation erstellen. Der Zielkatalog muss ein von Amazon Redshift verwalteter Katalog sein. Um einen von Amazon Redshift verwalteten Katalog zu erstellen, erstellen Sie zunächst die serviceverknüpfte Rolle AWSServiceRoleForRedshift. Fügen Sie in der Lake-Formation-Konsole AWSServiceRoleForRedshift als Administrator mit Leseberechtigung hinzu.

Weitere Informationen zu den oben genannten Aufgaben finden Sie in den folgenden Themen.

Konfigurieren von Berechtigungen für den AWS Glue-Zielkatalog

Bevor Sie einen Zielkatalog für die Null-ETL-Integration erstellen, müssen Sie die Lake-Formation-Zielerstellungsrolle und die AWS Glue-Datenübertragungsrolle erstellen. Verwenden Sie die Lake-Formation-Zielerstellungsrolle, um den Zielkatalog zu erstellen. Geben Sie bei der Erstellung des Zielkatalogs die Glue-Datenübertragungsrolle in das Feld IAM-Rolle im Abschnitt „Zugriff von Engines“ ein.

Nächste Schritte

Wenn Sie über eine RDS-Quelldatenbank und entweder ein Ziel-Data-Warehouse in Amazon Redshift oder ein Amazon SageMaker AI Lakehouse verfügen, können Sie eine Null-ETL-Integration erstellen und mit der Datenreplikation beginnen. Detaillierte Anweisungen finden Sie unter Erstellen von Null-ETL-Integrationen von Amazon RDS mit Amazon Redshift.