Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Guida introduttiva alle integrazioni Zero-ETL di Aurora Prima di creare un’integrazione Zero-ETL, configura il cluster di database Aurora e il data warehouse con le autorizzazioni e i parametri richiesti. Durante la configurazione, dovrai completare i seguenti passaggi: 1. [Creazione di un gruppo di parametri per il cluster di database personalizzato](#zero-etl.parameters). 1. [Creazione di un cluster di database](#zero-etl.create-cluster) di origine. 1. [Crea un data warehouse di destinazione per Amazon Redshift](#zero-etl-setting-up.data-warehouse) o [Crea un data warehouse di destinazione per Amazon SageMaker ](#zero-etl-setting-up.sagemaker) Lakehouse. Dopo aver completato queste attività, passa a [Creazione di integrazioni Zero-ETL di Aurora con Amazon Redshift](zero-etl.creating.md) o [Creazione di integrazioni Zero-ETL di Aurora con un lakehouse Amazon SageMaker](zero-etl.creating-smlh.md). Puoi utilizzare il AWS SDKs per automatizzare il processo di configurazione per te. Per ulteriori informazioni, consulta [Configura un'integrazione utilizzando AWS SDKs](#zero-etl.setup-sdk). **Suggerimento** Puoi fare in modo che RDS completi questi passaggi di configurazione al posto tuo durante la creazione dell’integrazione, in modo da non doverli eseguire manualmente. Per iniziare subito a creare un’integrazione, consulta [Creazione di integrazioni Zero-ETL di Aurora con Amazon Redshift](zero-etl.creating.md). 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: + Scegli un data warehouse se hai bisogno di funzionalità di data warehousing tradizionali con analisi basate su SQL. + Scegli Amazon SageMaker Lakehouse se hai bisogno di funzionalità di apprendimento automatico e desideri utilizzare le funzionalità di Lakehouse per flussi di lavoro di data science e ML. ## Fase 1: creazione di un gruppo di parametri del cluster di database personalizzato Le integrazioni Zero-ETL di Aurora richiedono valori specifici per i parametri del cluster di database che controllano la replica. In particolare, Aurora MySQL richiede *il file di log binario avanzato* (`aurora_enhanced_binlog`) e Aurora PostgreSQL richiede la *replica logica avanzata* (`aurora.enhanced_logical_replication`). Per configurare la registrazione di log binari o la replica logica, è necessario creare prima un gruppo di parametri del cluster di database personalizzato e poi associarlo al cluster di database 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 sul file di log binario avanzato di Aurora MySQL, consulta [Configurazione del file di log binario avanzato per Aurora MySQL](AuroraMySQL.Enhanced.binlog.md). **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 WAL (write ahead log) anche se `REPLICA IDENTITY FULL` non è abilitata. Ciò potrebbe aumentare le IOPS per il cluster di database di origine. **Importante** Se abiliti o disabiliti il parametro del cluster di database `aurora.enhanced_logical_replication`, l’istanza database primaria invalida tutti gli slot di replica logica. Ciò interrompe la replica dall’origine alla destinazione ed è necessario ricreare gli slot di replica sull’istanza database primaria. Per evitare interruzioni, mantieni costante lo stato del parametro durante la replica. ## Passaggio 2: seleziona o crea un cluster di database di origine Dopo aver creato un gruppo di parametri personalizzato per il cluster di database, scegli o crea un cluster di database Aurora. Questo cluster sarà l’origine della replica dei dati nel data warehouse di destinazione. Puoi specificare un cluster di database che utilizza istanze database con provisioning o istanze database Aurora Serverless v2 come origine. Per istruzioni su come creare un cluster di database, consulta [Creazione di un cluster database Amazon Aurora](Aurora.CreateInstance.md) o [Creazione di un cluster di database che utilizza Aurora Serverless v2](aurora-serverless-v2.create.md). Il database deve eseguire una versione del motore di database supportata. Per un elenco delle versioni supportate, consulta [Regioni e motori di database Aurora supportati per le integrazioni Zero-ETL](Concepts.Aurora_Fea_Regions_DB-eng.Feature.Zero-ETL.md). Quando crei il database, in **Configurazione aggiuntiva** modifica il valore predefinito del **gruppo di parametri del cluster di database** impostandolo sul gruppo di parametri personalizzato creato nel passaggio precedente. **Nota** Se associ il gruppo di parametri al cluster di database *dopo che* il cluster è già stato creato, è necessario riavviare l’istanza database primaria 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](USER_RebootCluster.md). ## Passaggio 3a: creazione di un data warehouse di destinazione Dopo aver creato il cluster di database 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](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-db-encryption.html). Per istruzioni su come creare un data warehouse, consulta [Creazione di un cluster](https://docs.aws.amazon.com/redshift/latest/mgmt/create-cluster) per i cluster con provisioning o [Creazione di un gruppo di lavoro con uno spazio dei nomi](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-console-workgroups-create-workgroup-wizard.html) 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 ([https://docs.aws.amazon.com/redshift/latest/dg/r_enable_case_sensitive_identifier.html](https://docs.aws.amazon.com/redshift/latest/dg/r_enable_case_sensitive_identifier.html)) 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](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-parameter-groups-console.html) o [Configurazione dei valori di parametro mediante AWS CLI](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-parameter-groups.html#configure-parameters-using-the-clil). **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 [update-workgroup](https://docs.aws.amazon.com/cli/latest/reference/redshift-serverless/update-workgroup.html): ``` 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 un cluster di database Aurora di origine come origine autorizzata dell’integrazione. Per istruzioni, consulta [Configurazione dell’autorizzazione per il data warehouse Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.setting-up.html#zero-etl-using.redshift-iam). ## Configura un'integrazione utilizzando AWS SDKs 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)](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html) per creare un cluster di database Amazon Aurora 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`. ### Esempio di codice Python ------ #### [ 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: creazione di un AWS Glue catalogo per l'integrazione Zero-ETL con Amazon SageMaker Lakehouse Quando crei un'integrazione zero-ETL con Amazon SageMaker Lakehouse, devi creare un catalogo gestito in. AWS Glue 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. + Per informazioni sulla creazione di un catalogo gestito di Amazon Redshift, consulta [Creazione di un catalogo gestito di Amazon Redshift nel AWS Glue Data Catalog](https://docs.aws.amazon.com/lake-formation/latest/dg/create-rms-catalog.html) nella *Guida per gli sviluppatori di AWS Lake Formation *. + Per informazioni sul ruolo collegato ai servizi per Amazon Redshift, consulta l’articolo [Utilizzo di ruoli collegati ai servizi per Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/using-service-linked-roles.html) nella *Guida alla gestione di Amazon Redshift*. + Per informazioni sulle autorizzazioni di amministratore di sola lettura per Lake Formation, consulta l’articolo [Riferimento ai personaggi di Lake Formation e alle autorizzazioni IAM](https://docs.aws.amazon.com/lake-formation/latest/dg/permissions-reference.html) nella *Guida per gli sviluppatori di 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 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**. #### Ruolo di creazione di destinazioni di Lake Formation Il ruolo di creazione di destinazioni deve essere di un amministratore di Lake Formation e richiede le seguenti autorizzazioni. ------ #### [ JSON ] **** ``` { "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:*:111122223333:catalog", "arn:aws:glue:*:111122223333:catalog/*", "arn:aws:s3:::*", "arn:aws:redshift-serverless:*:111122223333:workgroup/*", "arn:aws:redshift-serverless:*:111122223333:namespace/*", "arn:aws:iam::111122223333:role/GlueDataCatalogDataTransferRole" ] } ] } ``` ------ Il ruolo di creazione di destinazioni deve avere la seguente relazione di trust. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "glue.amazonaws.com" }, "Action": "sts:AssumeRole" }, { "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::111122223333:user/Username" }, "Action": "sts:AssumeRole" } ] } ``` ------ #### Ruolo di trasferimento dei dati Glue Il ruolo di trasferimento dei dati Glue è necessario per eseguire le operazioni del catalogo MySQL e deve disporre delle seguenti autorizzazioni. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "DataTransferRolePolicy", "Effect": "Allow", "Action": [ "kms:GenerateDataKey", "kms:Decrypt", "glue:GetCatalog", "glue:GetDatabase" ], "Resource": [ "*" ] } ] } ``` ------ Il ruolo di trasferimento dei dati Glue deve avere la seguente relazione di trust. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": [ "glue.amazonaws.com", "redshift.amazonaws.com" ] }, "Action": "sts:AssumeRole" } ] } ``` ------ ## Fasi successive Con un di origine, un cluster Aurora DB e un data warehouse di destinazione Amazon Redshift o SageMaker Amazon Lakehouse, puoi creare un'integrazione zero-ETL e replicare i dati. Per istruzioni, consulta [Creazione di integrazioni Zero-ETL di Aurora con Amazon Redshift](zero-etl.creating.md).