Schritt 1: Erstellen einer benutzerdefinierten DB-Cluster-Parametergruppe Schritt 2: Wählen oder erstellen Sie einen Schritt 3a: Erstellen Sie ein Ziel-Data Warehouse Richten Sie eine Integration mit dem ein AWS SDKs Schritt 3b: Erstellen Sie einen AWS Glue Katalog für die Amazon SageMaker Zero-ETL-Integration Nächste Schritte

Erste Schritte mit Aurora Zero-ETL-Integrationen

Bevor Sie eine Zero-ETL-Integration erstellen, konfigurieren Sie Ihren Aurora DB-Cluster für die und Ihr Data Warehouse mit den erforderlichen Parametern und Berechtigungen. Während der Einrichtung führen Sie die folgenden Schritte aus:

Erstellen einer benutzerdefinierten DB-Cluster-Parametergruppe.
Erstellen Sie einen .
Erstellen Sie ein Ziel-Data Warehouse für Amazon Redshift oder Erstellen Sie ein Amazon SageMaker Ziel-Lakehouse.

Nachdem Sie diese Aufgaben abgeschlossen haben, fahren Sie mit oder fortErstellen von Null-ETL-Integrationen von Aurora mit Amazon Redshift. Erstellen von Aurora Zero-ETL-Integrationen mit einem Lakehouse Amazon SageMaker

Sie können den verwenden AWS SDKs , um den Einrichtungsprozess für Sie zu automatisieren. Weitere Informationen finden Sie unter Richten Sie eine Integration mit dem ein AWS SDKs.

Tipp

Sie können RDS diese Einrichtungsschritte für Sie ausführen lassen, während Sie die Integration erstellen, anstatt sie manuell durchzuführen. Um sofort mit der Erstellung einer Integration zu beginnen, siehe Erstellen von Null-ETL-Integrationen von Aurora mit Amazon Redshift.

Für Schritt 3 können Sie je nach Bedarf wählen, ob Sie entweder ein Ziel-Data Warehouse (Schritt 3a) oder ein Ziel-Lakehouse (Schritt 3b) erstellen möchten:

Wählen Sie ein Data Warehouse, wenn Sie herkömmliche Data Warehousing-Funktionen mit SQL-basierten Analysen benötigen.
Wählen Sie ein Amazon SageMaker Lakehouse, wenn Sie Funktionen für maschinelles Lernen benötigen und Lakehouse-Funktionen für Data-Science- und ML-Workflows verwenden möchten.

Schritt 1: Erstellen einer benutzerdefinierten DB-Cluster-Parametergruppe

Aurora Zero-ETL-Integrationen erfordern spezifische Werte für die DB-Cluster-Parameter, die die Replikation steuern. Insbesondere erfordert Aurora MySQL eine erweiterte binlog (aurora_enhanced_binlog), und Aurora PostgreSQL erfordert eine erweiterte logische Replikation (). aurora.enhanced_logical_replication

Um die binäre Protokollierung oder logische Replikation zu konfigurieren, müssen Sie zuerst eine benutzerdefinierte DB-Cluster-Parametergruppe erstellen und diese dann dem Quell-DB-Cluster zuordnen.

Aurora MySQL (Aurora-Mysql8.0-Familie):

aurora_enhanced_binlog=1
binlog_backup=0
binlog_format=ROW
binlog_replication_globaldb=0
binlog_row_image=full
binlog_row_metadata=full

Stellen Sie außerdem sicher, dass der binlog_transaction_compression-Parameter nicht auf ON und der binlog_row_value_options-Parameter nicht auf PARTIAL_JSON gesetzt ist.

Weitere Informationen zu Aurora MySQL Enhanced Binlog finden Sie unterErweitertes Binlog für Aurora MySQL einrichten.

Aurora PostgreSQL (Aurora-Postgresql16-Familie):

rds.logical_replication=1
aurora.enhanced_logical_replication=1
aurora.logical_replication_backup=0
aurora.logical_replication_globaldb=0

Wenn Sie die erweiterte logische Replikation (aurora.enhanced_logical_replication) aktivieren, werden immer alle Spaltenwerte in das Write-Ahead-Protokoll (WAL) geschrieben, auch wenn es nicht aktiviert ist. REPLICA IDENTITY FULL Dies kann die IOPS für Ihren Quell-DB-Cluster erhöhen.

Wichtig

Wenn Sie den aurora.enhanced_logical_replication DB-Cluster-Parameter aktivieren oder deaktivieren, macht die primäre DB-Instance alle logischen Replikationssteckplätze ungültig. Dadurch wird die Replikation von der Quelle zum Ziel gestoppt, und Sie müssen die Replikationsslots auf der primären DB-Instance neu erstellen. Um Unterbrechungen zu vermeiden, sollten Sie den Parameterstatus während der Replikation konsistent halten.

Schritt 2: Wählen oder erstellen Sie einen

Nachdem Sie eine benutzerdefinierte DB-Cluster-Parametergruppe erstellt haben, wählen oder erstellen Sie einen Aurora-DB-Cluster . Dieser wird die Quelle der Datenreplikation zum Ziel-Data Warehouse sein. Sie können einen DB-Cluster angeben, der bereitgestellte DB-Instances oder Aurora Serverless v2 DB-Instances als Quelle verwendet. Anweisungen zum Erstellen eines finden Sie unter oder. Erstellen eines Amazon Aurora-DB Clusters Erstellen eines DB-Clusters, das Aurora Serverless v2

Auf 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 Aurora-DB-Engines für Zero-ETL-Integrationen.

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

Anmerkung

Wenn Sie die Parametergruppe dem zuordnen, nachdem der bereits erstellt wurde, müssen Sie die primäre im Cluster neu starten, um die Änderungen zu übernehmen, bevor Sie eine Zero-ETL-Integration erstellen können. Anleitungen Anweisungen finden Sie unter Neustart eines Amazon Aurora DB-Clusters oder einer Amazon Aurora DB-Instance.

Schritt 3a: Erstellen Sie ein Ziel-Data Warehouse

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

Verwendung eines RA3 Knotentyps mit mindestens zwei Knoten oder Redshift Serverless.
Es muss verschlüsselt sein (bei Verwendung eines bereitgestellten Clusters). Weitere Informationen finden Sie unter Datenbankverschlüsselung in Amazon Redshift.

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:

Bereitgestellter Cluster – Um die Berücksichtigung von Groß- und Kleinschreibung in einem bereitgestellten Cluster zu aktivieren, erstellen Sie eine benutzerdefinierte Parametergruppe mit aktiviertem enable_case_sensitive_identifier-Parameter. Ordnen Sie diese Parametergruppe dann dem Cluster zu. Anweisungen finden Sie unter Verwalten von Parametergruppen mit der Konsole oder Konfigurieren von Parameterwerten mit der AWS CLI.

Anmerkung
Denken Sie daran, den Cluster neu zu starten, nachdem Sie ihm die benutzerdefinierte Parametergruppe zugeordnet haben.
Serverless-Arbeitsgruppe – Um die Berücksichtigung von Groß- und Kleinschreibung in einer Redshift-Serverless-Arbeitsgruppe zu aktivieren, müssen Sie die AWS CLI verwenden. Die Amazon-Redshift-Konsole unterstützt derzeit nicht das Ändern von Redshift-Serverless-Parameterwerten. Senden Sie die folgende Anfrage zur Aktualisierung der Arbeitsgruppe:
```
aws redshift-serverless update-workgroup \
  --workgroup-name target-workgroup \
  --config-parameters parameterKey=enable_case_sensitive_identifier,parameterValue=true
```
Sie müssen eine Arbeitsgruppe nicht neu starten, nachdem Sie ihre Parameterwerte geändert haben.

Konfigurieren der Autorisierung für das Data Warehouse

Nachdem Sie ein Data Warehouse erstellt haben, müssen Sie den Aurora-DB-Cluster der als autorisierte Integrationsquelle konfigurieren. Anweisungen finden Sie unter Konfigurieren der Autorisierung für Ihr Amazon-Redshift-Data-Warehouse.

Richten Sie eine Integration mit dem ein AWS SDKs

Anstatt jede Ressource manuell einzurichten, können Sie das folgende Python-Skript ausführen, um die erforderlichen Ressourcen automatisch für Sie einzurichten. Das Codebeispiel verwendet den AWS SDK für Python (Boto3), um einen Amazon Aurora Aurora-DB-Cluster als Quelle, eine und ein Ziel-Data Warehouse zu erstellen, jeweils mit den erforderlichen Parameterwerten. Es wartet dann, bis die Datenbanken verfügbar sind, bevor eine Zero-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, die my-integration nach der Einrichtung der Ressourcen benannt ist.

Aurora MySQL


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 binary logging'
    )
    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()

Aurora PostgreSQL


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 PostgreSQL DB cluster"""

    response = rds.create_db_cluster_parameter_group(
        DBClusterParameterGroupName=source_param_group_name,
        DBParameterGroupFamily='aurora-postgresql16',
        Description='For Aurora PostgreSQL logical replication'
    )
    print('Created source parameter group: ' + response['DBClusterParameterGroup']['DBClusterParameterGroupName'])

    response = rds.modify_db_cluster_parameter_group(
        DBClusterParameterGroupName=source_param_group_name,
        Parameters=[
            {
                'ParameterName': 'rds.logical_replication',
                'ParameterValue': '1',
                'ApplyMethod': 'pending-reboot'
            },
            {
                'ParameterName': 'aurora.enhanced_logical_replication',
                'ParameterValue': '1',
                'ApplyMethod': 'pending-reboot'
            },
            {
                'ParameterName': 'aurora.logical_replication_backup',
                'ParameterValue': '0',
                'ApplyMethod': 'pending-reboot'
            },
            {
                'ParameterName': 'aurora.logical_replication_globaldb',
                'ParameterValue': '0',
                '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-postgresql',
        EngineVersion='16.4.aurora-postgresql',
        DatabaseName='mypostgresdb',
        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-postgresql'
    )
    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 PostgreSQL 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()

Schritt 3b: Erstellen Sie einen AWS Glue Katalog für die Amazon SageMaker Zero-ETL-Integration

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

Weitere Informationen zu den vorherigen Aufgaben finden Sie in den folgenden Themen.

Informationen zum Erstellen eines von Amazon Redshift verwalteten Katalogs finden Sie unter Creating an Amazon Redshift managed catalog AWS Glue Data Catalog im AWS Lake Formation Developer Guide.
Informationen zur serviceverknüpften Rolle für Amazon Redshift finden Sie unter Verwenden von serviceverknüpften Rollen für Amazon Redshift im Amazon Redshift Management Guide.
Informationen zu Administratorberechtigungen mit Lesezugriff für Lake Formation finden Sie unter Referenz zu Lake Formation Formation-Personas und IAM-Berechtigungen im Developer Guide.AWS Lake Formation

Konfigurieren Sie die Berechtigungen für den Zielkatalog AWS Glue

Bevor Sie einen Zielkatalog für die Zero-ETL-Integration erstellen, müssen Sie die Lake Formation Formation-Zielerstellungsrolle und die AWS Glue Datenübertragungsrolle erstellen. Verwenden Sie die Rolle Lake Formation Target Creation, 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.

Die Rolle zur Zielerstellung muss ein Lake Formation-Administrator sein und erfordert die folgenden Berechtigungen.


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "VisualEditor0",
            "Effect": "Allow",
            "Action": "lakeformation:RegisterResource",
            "Resource": "*"
        },
        {
            "Sid": "VisualEditor1",
            "Effect": "Allow",
            "Action": [
                "s3:PutEncryptionConfiguration",
                "iam:PassRole",
                "glue:CreateCatalog",
                "glue:GetCatalog",
                "s3:PutBucketTagging",
                "s3:PutLifecycleConfiguration",
                "s3:PutBucketPolicy",
                "s3:CreateBucket",
                "redshift-serverless:CreateNamespace",
                "s3:DeleteBucket",
                "s3:PutBucketVersioning",
                "redshift-serverless:CreateWorkgroup"
            ],
            "Resource": [
                "arn:aws:glue:*:account-id:catalog",
                "arn:aws:glue:*:account-id:catalog/*",
                "arn:aws:s3:::*",
                "arn:aws:redshift-serverless:*:account-id:workgroup/*",
                "arn:aws:redshift-serverless:*:account-id:namespace/*",
                "arn:aws:iam::account-id:role/GlueDataCatalogDataTransferRole"
            ]
        }
    ]
}

Die Rolle zur Zielerstellung muss über die folgende Vertrauensstellung verfügen.


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service": "glue.amazonaws.com"
            },
            "Action": "sts:AssumeRole"
        },
        {
          "Effect": "Allow",
          "Principal": {
            "AWS": "arn:aws:iam::account-id:user/Username"
          },
          "Action": "sts:AssumeRole"
        }
    ]
}

Die Glue-Datenübertragungsrolle ist für MySQL-Katalogoperationen erforderlich und muss über die folgenden Berechtigungen verfügen.


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "DataTransferRolePolicy",
            "Effect": "Allow",
            "Action": [
                "kms:GenerateDataKey",
                "kms:Decrypt",
                "glue:GetCatalog",
                "glue:GetDatabase"
            ],
            "Resource": [
                "*"
            ]
        }
    ]
}

Die Glue-Datenübertragungsrolle muss über die folgende Vertrauensstellung verfügen.


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service": [
                    "glue.amazonaws.com",
                    "redshift.amazonaws.com"
                ]
            },
            "Action": "sts:AssumeRole"
        }
    ]
}

Nächste Schritte

Mit einem Aurora-DB-Cluster für die und entweder einem Amazon Redshift Redshift-Ziel-Data Warehouse oder Amazon SageMaker Lakehouse können Sie eine Zero-ETL-Integration erstellen und Daten replizieren. Detaillierte Anweisungen finden Sie unter Erstellen von Null-ETL-Integrationen von Aurora mit Amazon Redshift.

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Null-ETL-Integrationen

Erstellen von Zero-ETL-Integrationen mit Amazon Redshift