Fase 1: creazione di un gruppo di parametri del cluster DB personalizzato Passaggio 2: selezionare o creare un cluster DB del di origine Fase 3a: Creare un data warehouse di destinazione Configurare un'integrazione utilizzando il AWS SDKs Fase 3b: Creare un AWS Glue catalogo per Amazon SageMaker l'integrazione zero-ETL Passaggi successivi

Guida introduttiva alle integrazioni Zero-ETL di Aurora

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

Creazione di un gruppo di parametri per il cluster DB personalizzato..
Crea un cluster DB
Crea un data warehouse di destinazione per Amazon Redshift o Crea un lago di destinazione Amazon SageMaker.

Dopo aver completato queste attività, continua con o. Creazione di integrazioni Zero-ETL di Aurora con Amazon Redshift Creazione di Aurora con un lago Amazon SageMaker

Puoi utilizzarli AWS SDKs per automatizzare il processo di configurazione. Per ulteriori informazioni, consulta Configurare un'integrazione utilizzando il AWS SDKs.

Suggerimento

Puoi fare in modo che RDS completi questi passaggi di configurazione al posto tuo mentre crei l'integrazione, anziché eseguirli manualmente. Per iniziare subito a creare un'integrazione, consulta Creazione di integrazioni Zero-ETL di Aurora con Amazon Redshift.

Per la Fase 3, puoi scegliere di creare un data warehouse di destinazione (Fase 3a) o un Target Lakehouse (Fase 3b) a seconda delle tue esigenze:

Scegli un data warehouse se hai bisogno di funzionalità di data warehousing tradizionali con analisi basate su SQL.
Scegli un Amazon SageMaker lakehouse se hai bisogno di funzionalità di apprendimento automatico e desideri utilizzare le funzionalità di Lakehouse per i flussi di lavoro di data science e ML.

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

Le integrazioni Aurora zero-ETL 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.

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 di binlog avanzato per Aurora MySQL

Aurora PostgreSQL (famiglia aurora-postgresql16):

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) scriverà sempre tutti i valori delle colonne nel log write ahead (WAL) anche se non è abilitata. REPLICA IDENTITY FULL Ciò potrebbe aumentare gli IOPS per il cluster DB di origine.

Importante

Se abiliti o disabiliti il parametro del cluster aurora.enhanced_logical_replication DB, l'istanza DB principale invalida tutti gli slot di replica logica. Ciò interrompe la replica dall'origine alla destinazione ed è necessario ricreare gli slot di replica sull'istanza DB principale. Per evitare interruzioni, mantenete costante lo stato dei parametri durante la replica.

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à la fonte della replica dei dati nel data warehouse di destinazione. È possibile specificare un cluster DB che utilizza istanze DB o istanze Aurora Serverless v2 DB assegnate come origine. Per istruzioni su come creare un cluster DB con , consulta o. Creazione di un cluster database Amazon Aurora Creazione di un cluster DB che utilizza Aurora Serverless v2

Il database deve eseguire una versione del motore DB supportata. Per un elenco delle versioni supportate, consulta Regioni supportate e motori Aurora DB per integrazioni zero-ETL.

Quando create il database, in Configurazione aggiuntiva, modificate il gruppo di parametri predefinito del cluster DB con il gruppo di parametri personalizzato creato nel passaggio precedente.

Nota

Se si associa il gruppo di parametri al cluster DB del dopo che il cluster di è già stato creato, è necessario riavviare l'istanza DB principale del nel cluster per applicare le modifiche prima di poter creare un'integrazione zero-ETL. Per istruzioni, consulta Riavvio di un cluster Amazon Aurora DB o di un'istanza Amazon Aurora DB.

Fase 3a: Creare un data warehouse di destinazione

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

Utilizzando un tipo di RA3 nodo con almeno due nodi 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.

Configurare un'integrazione utilizzando il AWS SDKs

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 per Python (Boto3)per creare un cluster Amazon Aurora DB di origine RDS per un'istanza DB 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. È 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.

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

Fase 3b: Creare un AWS Glue catalogo per Amazon SageMaker l'integrazione zero-ETL

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

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

Per informazioni sulla creazione di un catalogo gestito di Amazon Redshift, consulta Creating an Amazon Redshift managed catalog nella Developer AWS Glue Data Catalog Guide.AWS Lake Formation
Per informazioni sul ruolo collegato ai servizi per Amazon Redshift, consulta Using service-linked roles for Amazon Redshift nella Amazon Redshift Management Guide.
Per informazioni sulle autorizzazioni di amministratore di sola lettura per Lake Formation, consulta Lake Formation personas e IAM permissions reference nella Developer Guide.AWS Lake Formation

Configura le autorizzazioni per il catalogo di destinazione AWS Glue

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

Il ruolo di creazione del target deve essere un amministratore di Lake Formation e richiede le seguenti autorizzazioni.


{
    "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"
            ]
        }
    ]
}

Il ruolo di creazione del target deve avere la seguente relazione di fiducia.


{
    "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"
        }
    ]
}

Il ruolo di trasferimento dati Glue è necessario per le operazioni del catalogo MySQL e deve disporre delle seguenti autorizzazioni.


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

Il ruolo di trasferimento dati Glue deve avere la seguente relazione di trust.


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

Passaggi successivi

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

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Integrazioni Zero-ETL

Creazione di integrazioni zero-ETL con Amazon Redshift