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à.
# Integrazioni Zero-ETL di Amazon RDS
È una soluzione completamente gestita per rendere disponibili i dati transazionali nella destinazione di analisi dopo la scrittura su un database RDS. *Estrazione, trasformazione* e *caricamento* (ETL) è il processo di combinazione di dati provenienti da più origini in un grande data warehouse centrale.
Un’integrazione Zero-ETL rende disponibili i dati del database RDS in Amazon Redshift o in un lakehouse Amazon SageMaker AI quasi in tempo reale. Una volta che i dati sono nel data warehouse o data lake di destinazione, puoi potenziare i tuoi carichi di lavoro di analisi, ML e intelligenza artificiale utilizzando le funzionalità integrate, come machine learning, viste materializzate, condivisione dei dati, accesso federato a più data store e data lake e integrazioni con SageMaker Amazon AI, Quick e altro. Servizi AWS
Per creare un’integrazione Zero-ETL, è necessario specificare un database RDS come *origine* e un lakehouse o un data warehouse supportato come *destinazione*. L’integrazione replica i dati dal database di origine nel lakehouse o data warehouse di destinazione.
Il diagramma seguente illustra questa funzionalità per l’integrazione Zero-ETL con Amazon Redshift:
![\[Integrazione Zero-ETL\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/zero-etl-integrations.png)
Il diagramma seguente illustra questa funzionalità per l’integrazione Zero-ETL con un Amazon SageMaker AI Lakehouse:
![\[Un'integrazione zero-ETL con un lago Amazon SageMaker AI\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/zero-etl-rds-lakehouse.png)
L’integrazione monitora lo stato della pipeline dei dati ed esegue il ripristino in caso di problemi quando possibile. Puoi creare integrazioni da più database RDS in un unico lakehouse o data warehouse di destinazione così da ottenere informazioni dettagliate da diverse applicazioni.
**Topics**
+ [Vantaggi](#zero-etl.benefits)
+ [Concetti chiave](#zero-etl.concepts)
+ [Limitazioni](#zero-etl.reqs-lims)
+ [Quote](#zero-etl.quotas)
+ [Regioni supportate](#zero-etl.regions)
+ [Guida introduttiva alle integrazioni Zero-ETL di Amazon RDS](zero-etl.setting-up.md)
+ [Creazione di integrazioni Zero-ETL di Amazon RDS con Amazon Redshift](zero-etl.creating.md)
+ [Creazione di integrazioni Zero-ETL di Amazon RDS con un lakehouse Amazon SageMaker](zero-etl.creating-smlh.md)
+ [Filtro dei dati per integrazioni Zero-ETL di Amazon RDS](zero-etl.filtering.md)
+ [Aggiunta di dati a un database RDS di origine ed esecuzione di query al suo interno](zero-etl.querying.md)
+ [Visualizzazione e monitoraggio delle integrazioni Zero-ETL Amazon RDS](zero-etl.describingmonitoring.md)
+ [Modifica delle integrazioni Zero-ETL Amazon RDS](zero-etl.modifying.md)
+ [Eliminazione delle integrazioni Zero-ETL Amazon RDS](zero-etl.deleting.md)
+ [Risoluzione dei problemi delle integrazioni Zero-ETL di Amazon RDS](zero-etl.troubleshooting.md)
## Vantaggi
Le integrazioni Zero-ETL di RDS offrono i seguenti vantaggi:
+ Ti consentono di ottenere approfondimenti di tipo olistico da più origini dati.
+ Eliminano la necessità di creare e gestire pipeline dei dati complesse che eseguono operazioni di estrazione, trasformazione e caricamento (ETL). Le integrazioni Zero-ETL forniscono e gestiscono le pipeline per te, eliminando le sfide legate alla loro creazione e gestione.
+ Ti consentono di ridurre il carico e i costi operativi e di concentrarti sul miglioramento delle applicazioni.
+ Puoi utilizzare le funzionalità di analisi e machine learning della destinazione per ricavare informazioni dettagliate da dati transazionali e di altro tipo e reagire in modo efficace in caso di eventi critici e urgenti.
## Concetti chiave
Per iniziare a utilizzare le integrazioni Zero-ETL, tieni presente i seguenti concetti:
**Integrazione**
Una pipeline dei dati completamente gestita che replica automaticamente i dati transazionali e gli schemi da un database RDS a un data warehouse o un catalogo.
**Database di origine**
Il database RDS da cui viene eseguita la replica dei dati. È possibile specificare un'istanza DB Single-AZ o Multi-AZ o un cluster DB Multi-AZ (solo per RDS per MySQL).
**Target**
Si tratta del lakehouse o data warehouse in cui viene eseguita la replica dei dati. Esistono due tipi di data warehouse: un data warehouse [con cluster con provisioning](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-clusters.html) e un data warehouse [serverless](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-workgroup-namespace.html). Un data warehouse con cluster con provisioning è costituito da un insieme di risorse di calcolo denominate nodi, strutturate in un gruppo denominato *cluster*. Un data warehouse serverless è composto da un gruppo di lavoro che archivia le risorse di calcolo e da un spazio dei nomi che ospita gli oggetti e gli utenti del database. Entrambi i data warehouse utilizzano un motore di analisi e contengono uno o più database.
Un lakehouse di destinazione è costituito da cataloghi, database, tabelle e viste. Per ulteriori informazioni sull’architettura lakehouse, consulta [https://docs.aws.amazon.com/sagemaker-unified-studio/latest/userguide/lakehouse-components.html](https://docs.aws.amazon.com/sagemaker-unified-studio/latest/userguide/lakehouse-components.html) nella *Guida per l’utente di Amazon SageMaker AI Unified Studio*.
Più database di destinazione possono scrivere nella stessa destinazione.
Per ulteriori informazioni sui nodi principali e sui nodi di calcolo, consulta [Architettura del sistema di data warehouse](https://docs.aws.amazon.com/redshift/latest/dg/c_high_level_system_architecture.html) nella *Guida per sviluppatori di database di Amazon Redshift*.
## Limitazioni
Le seguenti limitazioni si applicano alle integrazioni Zero-ETL di RDS.
**Topics**
+ [Limitazioni generali](#zero-etl.reqs-lims-general)
+ [Limitazioni di RDS per MySQL](#zero-etl.reqs-lims-mysql)
+ [Limitazioni di RDS per PostgreSQL](#zero-etl.reqs-lims-rds-postgres)
+ [Limitazioni di RDS per Oracle](#zero-etl.reqs-lims-oracle)
+ [Limitazioni di Amazon Redshift](#zero-etl.reqs-lims-redshift)
+ [Amazon SageMaker AI limitazioni di Lakehouse](#zero-etl.reqs-lims-sagemaker-)
### Limitazioni generali
+ Il database di origine deve trovarsi nella stessa Regione della destinazione.
+ Non è possibile rinominare un database se include integrazioni esistenti.
+ Non è possibile creare più integrazioni tra gli stessi database di origine e destinazione.
+ Non è possibile eliminare un database con integrazioni esistenti. Devi prima eliminare tutte le integrazioni associate.
+ Se il database di origine viene arrestato, è possibile che le ultime transazioni non vengano replicate nella destinazione finché non si riprende il database.
+ Non è possibile eliminare un’integrazione se il database di origine viene arrestato.
+ Se il database è l’origine di un’implementazione blu/verde, gli ambienti blu e verde non possono avere integrazioni Zero-ETL esistenti durante lo switchover. Occorre eliminare l’integrazione, eseguire lo switchover e poi ricrearla.
+ Non è possibile creare un’integrazione per un database di origine in cui un’altra integrazione è attivamente in fase di creazione.
+ Durante la fase iniziale della creazione di un’integrazione o quando una tabella viene risincronizzata, il seeding dei dati dall’origine alla destinazione può richiedere 20-25 minuti o più, a seconda delle dimensioni del database di origine. Ciò può causare un aumento del ritardo di replica.
+ Alcuni tipi di dati non sono supportati. Per ulteriori informazioni, consulta [Differenze tra i tipi di dati tra i database RDS e Amazon Redshift](zero-etl.querying.md#zero-etl.data-type-mapping).
+ Le tabelle di sistema, le tabelle temporanee e le viste non vengono replicate nei warehouse di destinazione.
+ L’esecuzione di comandi DDL (ad esempio `ALTER TABLE`) su una tabella di origine può attivare una risincronizzazione della tabella. Durante tale operazione non sarà possibile utilizzare la tabella per le query. Per ulteriori informazioni, consulta [Una o più tabelle Amazon Redshift richiedono una risincronizzazione](zero-etl.troubleshooting.md#zero-etl.troubleshooting.resync).
### Limitazioni di RDS per MySQL
+ Il database di origine deve eseguire una versione supportata di RDS per MySQL. Per un elenco delle versioni supportate, consulta [Regioni e motori di database supportati per le integrazioni Zero-ETL di Amazon RDS](Concepts.RDS_Fea_Regions_DB-eng.Feature.ZeroETL.md).
+ Le integrazioni zero-ETL non sono supportate sia sull'istanza principale che su un'istanza di replica di lettura nella stessa regione. AWS
+ Le integrazioni Zero-ETL si basano sui log binari MySQL (binlog) per acquisire le modifiche continue dei dati. Il filtraggio dei dati basato su binlog è sconsigliato, poiché può causare incoerenze nei dati tra il database di origine e quello di destinazione.
+ Le integrazioni Zero-ETL sono supportate solo per i database configurati per l’utilizzo del motore di storage InnoDB.
+ I riferimenti a chiavi esterne con aggiornamenti di tabella predefiniti non sono supportati. In particolare, le regole `ON DELETE` e `ON UPDATE` non sono supportate nelle operazioni `CASCADE`, `SET NULL` e `SET DEFAULT`. Se si tenta di creare o aggiornare una tabella con tali riferimenti a un’altra tabella, la tabella entrerà in uno stato di errore.
+ Non è possibile creare un'integrazione per un database di origine che utilizza l'archiviazione magnetica.
### Limitazioni di RDS per PostgreSQL
+ Il database di origine deve essere un’istanza RDS per PostgreSQL che esegue la versione 15.7\$1, 16.3\$1 o 17.1\$1. Le versioni precedenti non sono supportate.
+ Le integrazioni Zero-ETL di RDS per PostgreSQL non supportano i cluster DB Multi-AZ come database di origine.
+ Non è possibile creare un’integrazione Zero-ETL da un’istanza di replica di lettura di RDS per PostgreSQL.
+ Le viste materializzate e le tabelle non registrate di PostgreSQL non vengono replicate su Amazon Redshift.
+ La replica di determinati tipi di dati PostgreSQL, ad esempio i [tipi di dati di geometria](https://www.postgresql.org/docs/current/datatype-geometric.html) e i dati con dimensioni superiori a 64 KB, non è supportata a causa delle limitazioni di Amazon Redshift. Per ulteriori informazioni sulle differenze dei tipi di dati tra RDS per PostgreSQL e Amazon Redshift, consulta l’articolo [RDS per PostgreSQL](zero-etl.querying.md#zero-etl.data-type-mapping-postgres) nella sezione **Differenze tra i tipi di dati**.
+ Non è possibile eseguire un [aggiornamento a una versione principale](USER_UpgradeDBInstance.PostgreSQL.md) sull’istanza RDS per PostgreSQL di origine se è presente un’integrazione Zero-ETL attiva. Per aggiornare l’istanza di origine, è necessario eliminare prima tutte le integrazioni Zero-ETL. Al termine dell’aggiornamento alla versione principale, è possibile ricreare le integrazioni Zero-ETL.
+ Se esegui transazioni di [partizionamento dichiarativo](https://www.postgresql.org/docs/current/ddl-partitioning.html#DDL-PARTITIONING-DECLARATIVE) sull’istanza del database di origine, tutte le tabelle interessate entrano in uno stato di errore e non sono più accessibili.
### Limitazioni di RDS per Oracle
+ Il database di origine deve essere un’istanza di RDS per Oracle che esegue la versione 19c Enterprise Edition o Standard Edition 2, aggiornamento della versione di luglio 2019 o successiva. Le versioni precedenti non sono supportate.
+ Non è possibile creare un’integrazione Zero-ETL da un’istanza di replica di lettura di RDS per Oracle.
+ Non è possibile rinominare un [database del tenant](Oracle.Concepts.CDBs.md) se su tale database esiste un’integrazione zero-ETL.
+ Un database del tenant può avere una sola integrazione Zero-ETL.
+ RDS per Oracle e Amazon Redshift presentano alcune differenze tra i tipi di dati. Per ulteriori informazioni, consulta [RDS per Oracle](zero-etl.querying.md#zero-etl.data-type-mapping-oracle) nella sezione **Differenze tra i tipi di dati**.
### Limitazioni di Amazon Redshift
Per un elenco delle limitazioni di Amazon Redshift relative alle integrazioni Zero-ETL, consulta la pagina delle [Considerazioni sull’utilizzo delle integrazioni Zero-ETL con Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl.reqs-lims.html) nella *Guida alla gestione di Amazon Redshift*.
### Amazon SageMaker AI limitazioni di Lakehouse
Di seguito è riportata una limitazione per le integrazioni Amazon SageMaker AI Lakehouse Zero-ETL.
+ I nomi dei cataloghi hanno un limite di lunghezza di 19 caratteri.
## Quote
Sul tuo account sono disponibili le seguenti quote relative alle integrazioni Zero-ETL di RDS. Salvo dove diversamente specificato, ogni quota fa riferimento a una Regione specifica.
| Name | Predefinito | Description |
| --- | --- | --- |
| Integrazioni | 100 | Numero totale di integrazioni all’interno di un Account AWS. |
| Integrazioni per destinazione | 50 | Numero di integrazioni che inviano dati a un unico lakehouse o data warehouse di destinazione. |
| Integrazioni per istanza di origine | 5 | Numero di integrazioni che inviano dati da un’unica istanza database di origine. |
Inoltre, il warehouse di destinazione pone determinati limiti al numero di tabelle consentite in ogni istanza database o nodo del cluster. Per informazioni su quote e limiti di Amazon Redshift, consulta [Quote e limiti in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) nella *Guida alla gestione di Amazon Redshift*.
## Regioni supportate
Le integrazioni RDS Zero-ETL sono disponibili in un sottoinsieme di. Regioni AWS Per un elenco delle regioni supportate, consulta [Regioni e motori di database supportati per le integrazioni Zero-ETL di Amazon RDS](Concepts.RDS_Fea_Regions_DB-eng.Feature.ZeroETL.md).
# Guida introduttiva alle integrazioni Zero-ETL di Amazon RDS
Prima di creare un’integrazione Zero-ETL, configura il database RDS e il data warehouse con le autorizzazioni e i parametri richiesti. Durante la configurazione, dovrai completare i seguenti passaggi:
1. [Creazione di un gruppo di parametri per il database personalizzato](#zero-etl.parameters).
1. [Creazione di un 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 Amazon RDS con Amazon Redshift](zero-etl.creating.md) o [Creazione di integrazioni Zero-ETL di Amazon RDS con un lakehouse Amazon SageMaker](zero-etl.creating-smlh.md).
**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 Amazon RDS 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 di database personalizzato
Le integrazioni Zero-ETL di Amazon RDS richiedono valori specifici per i parametri del database che controllano la replica dei dati. I parametri specifici dipendono dal motore del database di origine. Per configurare questi parametri, devi prima creare un gruppo di parametri del database personalizzato e quindi associarlo al database di origine. Configura i seguenti valori dei parametri in base al motore del database di origine. Per istruzioni sulla creazione di un gruppo di parametri, consulta [Gruppi di parametri database per istanze database Amazon RDS](USER_WorkingWithDBInstanceParamGroups.md). Si consiglia di configurare tutti i valori dei parametri all’interno della medesima richiesta per evitare problemi legati alle dipendenze.
**RDS per MySQL**:
+ `binlog_format=ROW`
+ `binlog_row_image=full`
Inoltre, assicurati che il parametro `binlog_row_value_options` *non* sia impostato su `PARTIAL_JSON`. Se il database di origine è un cluster di database Multi-AZ, assicurati che il parametro `binlog_transaction_compression` *non* sia impostato su `ON`.
Alcuni di questi parametri (ad esempio `binlog_format`) sono dinamici, quindi puoi applicare modifiche al parametro senza eseguire un riavvio. Ciò significa che alcune sessioni esistenti potrebbero continuare a utilizzare il vecchio valore del parametro. Per evitare che ciò causi problemi durante la creazione di un’integrazione Zero-ETL, abilita lo [ schema delle prestazioni](USER_PerfInsights.EnableMySQL.md). Lo schema delle prestazioni garantisce l’esecuzione di controlli Zero-ETL preliminari, che aiutano a rilevare i parametri mancanti nelle prime fasi del processo.
**RDS per PostgreSQL**:
+ `rds.logical_replication = 1`
+ `rds.replica_identity_full = 1`
+ `session_replication_role = origin`
+ `wal_sender_timeout ≥ 20000 or = 0`
+ `max_wal_senders ≥ 20`
+ `max_replication_slots ≥ 20`
Per più integrazioni PostgreSQL, verrà utilizzato uno slot di replica logica per integrazione. Rivedi i parametri `max_replication_slots` e `max_wal_senders` in base al tuo utilizzo.
Per una sincronizzazione efficiente dei dati nelle integrazioni Zero-ETL, imposta `rds.replica_identity_full` nell’istanza del database di origine. Ciò indica al database di [registrare i dati di riga completi](https://www.postgresql.org/docs/current/sql-altertable.html#SQL-ALTERTABLE-REPLICA-IDENTITY) nel WAL (write-ahead log) durante le operazioni `UPDATE` e `DELETE`, anziché registrare solo le informazioni sulla chiave primaria. Zero-ETL richiede dati di riga completi anche quando tutte le tabelle replicate devono disporre di chiavi primarie. Per stabilire quali dati sono visibili durante le query, Amazon Redshift utilizza una strategia anti-join specializzata per confrontare i dati con una tabella per il tracciamento delle operazioni interne di eliminazione. La registrazione di log di immagini a riga intera aiuta Amazon Redshift a eseguire questi anti-join in modo efficiente. Senza i dati di riga completi, Amazon Redshift dovrebbe eseguire ricerche aggiuntive, che potrebbero rallentare le prestazioni durante le operazioni ad alto throughput nel motore a colonne utilizzato da Amazon Redshift.
**Importante**
L'impostazione dell'identità di replica per registrare righe complete [aumenta il volume WAL, il](https://www.postgresql.org/docs/current/runtime-config-wal.html#GUC-WAL-LEVEL) che può portare a un aumento dell'amplificazione e dell' I/O utilizzo della scrittura, soprattutto per tabelle di grandi dimensioni o aggiornamenti frequenti. Per prepararti a questi impatti, pianifica la capacità e i I/O requisiti di archiviazione, monitora la crescita del WAL e monitora il ritardo di replica nei carichi di lavoro che richiedono molta scrittura.
**RDS per Oracle**:
Non è richiesta alcuna modifica dei parametri per RDS per Oracle.
## Passaggio 2: seleziona o crea un database di origine
Dopo aver creato un gruppo di parametri personalizzato per il di database, scegli o crea un’istanza database RDS. Questo database sarà l’origine della replica dei dati nel data warehouse di destinazione. Per istruzioni su come creare un’istanza database Single-AZ o Multi-AZ, consulta [Creazione di un'istanza database Amazon RDS](USER_CreateDBInstance.md). Per istruzioni sulla creazione di un cluster DB Multi-AZ (solo RDS per MySQL), vedere. [Creazione di un cluster di database Multi-AZ per Amazon RDS](create-multi-az-db-cluster.md)
Il database deve eseguire una versione del motore di database supportata. Per un elenco delle versioni supportate, consulta [Regioni e motori di database supportati per le integrazioni Zero-ETL di Amazon RDS](Concepts.RDS_Fea_Regions_DB-eng.Feature.ZeroETL.md).
Quando crei il database, in **Configurazione aggiuntiva** modifica il valore predefinito del **gruppo di parametri del di database** impostandolo sul gruppo di parametri personalizzato creato nel passaggio precedente.
**Nota**
Se associ il gruppo di parametri al database *dopo che* il database è già stato creato, è necessario riavviare il database per applicare le modifiche prima di poter creare un’integrazione Zero-ETL. Per istruzioni, consulta [Riavvio di un'istanza DB DB](USER_RebootInstance.md) o [Riavvio di un cluster di database Multi-AZ e di istanze database di lettura per Amazon RDS](multi-az-db-clusters-concepts-rebooting.md).
Inoltre, assicurati che siano abilitati i backup automatici sul database. Per ulteriori informazioni, consulta [Abilitazione dei backup automatici](USER_WorkingWithAutomatedBackups.Enabling.md).
## Passaggio 3a: creazione di un data warehouse di destinazione
Dopo aver creato il database di origine, è necessario creare e configurare un data warehouse di destinazione. Il data warehouse deve soddisfare i seguenti requisiti:
+ 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 database RDS 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’istanza database RDS per MySQL di origine e un data warehouse di destinazione, ciascuno con i valori dei parametri richiesti. Attende quindi che i database siano disponibili prima di creare un’integrazione Zero-ETL tra di essi. Puoi commentare diverse funzioni a seconda delle risorse che è necessario configurare.
Per installare le dipendenze richieste, esegui i seguenti comandi:
```
pip install boto3
pip install time
```
All’interno dello script, è possibile modificare i nomi dei gruppi di origine, destinazione e parametri. Una volta che le risorse sono state impostate, la funzione finale crea un’integrazione che viene denominata `my-integration`.
### Esempio di codice Python
```
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()
```
## 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 database RDS di origine, un cluster 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 Amazon RDS con Amazon Redshift](zero-etl.creating.md).
# Creazione di integrazioni Zero-ETL di Amazon RDS con Amazon Redshift
Quando crei un’integrazione Zero-ETL di Amazon RDS, specifichi il database RDS di origine e il data warehouse Amazon Redshift di destinazione. Puoi anche personalizzare le impostazioni di crittografia e aggiungere tag. Amazon RDS crea un’integrazione tra il database di origine e la sua destinazione. Dopo aver attivato l’integrazione, tutti i dati che inserisci nel database di origine verranno replicati nella destinazione Amazon Redshift configurata.
## Prerequisiti
Prima di creare un’integrazione Zero-ETL, devi creare un database di origine e un data warehouse Amazon Redshift di destinazione. Devi anche consentire la replica nel data warehouse aggiungendo il database Aurora come origine di integrazione autorizzata.
Per istruzioni su come completare ciascuno di questi passaggi, consulta [Guida introduttiva alle integrazioni Zero-ETL di Amazon RDS](zero-etl.setting-up.md).
## Autorizzazioni richieste
Per creare un’integrazione Zero-ETL, occorrono alcune autorizzazioni IAM. Come requisito minimo, dovrai disporre delle autorizzazioni per eseguire le seguenti operazioni:
+ Creazione di integrazioni Zero-ETL per il database RDS di origine.
+ Visualizzazione ed eliminazione di tutte le integrazioni Zero-ETL.
+ Creazione di integrazioni in entrata nel data warehouse di destinazione.
Le seguenti policy di esempio mostrano le [autorizzazioni con privilegi minimi](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege) richieste per creare e gestire le integrazioni. Potresti non aver bisogno di queste stesse autorizzazioni se il tuo utente o ruolo dispone di autorizzazioni più ampie, come una policy gestita di `AdministratorAccess`.
**Nota**
Redshift Amazon Resource Names (ARNs) hanno il seguente formato. Nota l’uso di una barra (`(/`) anziché dei due punti (`:`) prima dell’UUID dello spazio dei nomi serverless.
Cluster con provisioning: `arn:aws:redshift:{region}:{account-id}:namespace:namespace-uuid`
Serverless: `arn:aws:redshift-serverless:{region}:{account-id}:namespace/namespace-uuid`
### Policy di esempio per la destinazione Redshift
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "CreateIntegration",
"Effect": "Allow",
"Action": [
"rds:CreateIntegration"
],
"Resource": [
"arn:aws:rds:us-east-1:123456789012:db:source-db",
"arn:aws:rds:us-east-1:123456789012:integration:*"
]
},
{
"Sid": "DescribeIntegrationDetails",
"Effect": "Allow",
"Action": [
"rds:DescribeIntegrations"
],
"Resource": [
"arn:aws:rds:us-east-1:123456789012:integration:*"
]
},
{
"Sid": "ChangeIntegrationDetails",
"Effect": "Allow",
"Action": [
"rds:DeleteIntegration",
"rds:ModifyIntegration"
],
"Resource": [
"arn:aws:rds:us-east-1:123456789012:integration:*"
]
},
{
"Sid": "AllowRedShiftIntegration",
"Effect": "Allow",
"Action": [
"redshift:CreateInboundIntegration"
],
"Resource": [
"arn:aws:redshift:us-east-1:123456789012:namespace:namespace-uuid"
]
}
]
}
```
------
### Scelta di un data warehouse di destinazione in un account diverso
Se prevedi di specificare un data warehouse Amazon Redshift di destinazione che si trova in un altro Account AWS, devi creare un ruolo che consenta agli utenti dell'account corrente di accedere alle risorse nell'account di destinazione. Per ulteriori informazioni, consulta [Fornire l'accesso a un utente IAM in un altro utente Account AWS di tua proprietà.](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_aws-accounts.html)
Il ruolo deve disporre delle seguenti autorizzazioni, che consentono all’utente di visualizzare i cluster Amazon Redshift con provisioning e gli spazi dei nomi Redshift Serverless disponibili nell’account di destinazione.
#### Autorizzazioni richieste e policy di attendibilità
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"redshift:DescribeClusters",
"redshift-serverless:ListNamespaces"
],
"Resource":[
"*"
]
}
]
}
```
------
Il ruolo deve avere la seguente policy di attendibilità, che specifica l’ID dell’account di destinazione.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:root"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Per istruzioni sulla creazione del ruolo, consulta [Creazione di un ruolo utilizzando policy di attendibilità personalizzate](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-custom.html).
## Creazione di integrazioni Zero-ETL
Puoi creare un'integrazione zero-ETL utilizzando l'API Console di gestione AWS AWS CLI, the o RDS.
**Importante**
Le integrazioni Zero-ETL non supportano le operazioni di aggiornamento o risincronizzazione. Se riscontri problemi con un’integrazione dopo la creazione, devi eliminarla e crearne una nuova.
Per impostazione predefinita, RDS per MySQL elimina immediatamente i file di log binari. Poiché le integrazioni Zero-ETL si basano sui log binari per replicare i dati dall’origine alla destinazione, il periodo di conservazione del database di origine deve essere di almeno un’ora. Non appena crei un’integrazione, Amazon RDS verifica il periodo di conservazione dei file di log binari per il database di origine selezionato. Se il valore corrente è 0 ore, Amazon RDS lo modifica automaticamente in 1 ora. In caso contrario, il valore rimane invariato.
### Console RDS
**Creazione di un’integrazione Zero-ETL**
1. Accedi a Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nel pannello di navigazione a sinistra, scegli **Interfacce di rete**.
1. Scegli **Crea un’integrazione Zero-ETL**.
1. In **Identificatore dell’integrazione**, inserisci un nome per l’integrazione. Il nome può contenere fino a 63 caratteri alfanumerici e può includere trattini.
**Importante**
I nomi dei cataloghi hanno un limite di lunghezza di 19 caratteri. Assicurati che il tuo identificatore di integrazione soddisfi questo requisito se verrà utilizzato come nome di catalogo.
1. Scegli **Next (Successivo)**.
1. In **Origine**, seleziona il database RDS da cui provengono i dati.
**Nota**
RDS avvisa l’utente se i parametri del DB non sono configurati correttamente. Se ricevi questo messaggio, puoi scegliere **Correggi per me** o configurarli manualmente. Per istruzioni su come correggerli manualmente, consulta [Fase 1: creazione di un gruppo di parametri del di database personalizzato](zero-etl.setting-up.md#zero-etl.parameters).
La modifica dei parametri del DB richiede un riavvio. Prima di poter creare l’integrazione, è necessario completare il riavvio e applicare correttamente i nuovi valori del parametro al database.
1. Una volta completata la configurazione del database di origine, scegli **Avanti**.
1. Per **Destinazione**, esegui queste operazioni:
1. (Facoltativo) Per utilizzare un account diverso Account AWS per il target Amazon Redshift, scegli **Specificare un account diverso**. Quindi, inserisci l’ARN di un ruolo IAM con le autorizzazioni per visualizzare i data warehouse. Per istruzioni su come creare il ruolo IAM, consulta [Scelta di un data warehouse di destinazione in un account diverso](#zero-etl.create-permissions-cross-account).
1. Per **Data warehouse Amazon Redshift**, seleziona la destinazione per i dati replicati dal database di origine. Puoi scegliere un *cluster* Amazon Redshift con provisioning o uno *spazio dei nomi* Redshift Serverless come destinazione.
**Nota**
RDS ti avvisa se le policy relative alle risorse o le impostazioni di distinzione tra maiuscole e minuscole per il data warehouse specificato non sono configurate correttamente. Se ricevi questo messaggio, puoi scegliere **Correggi per me** o configurarli manualmente. Per istruzioni su come correggerli manualmente, consulta [Attivazione della distinzione tra maiuscole e minuscole per il data warehouse](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.setting-up.html#zero-etl-setting-up.case-sensitivity) e [Configurazione dell’autorizzazione per il data warehouse](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.setting-up.html#zero-etl-using.redshift-iam) nella *Guida alla gestione di Amazon Redshift*.
La modifica della distinzione tra maiuscole e minuscole per un cluster Redshift *con provisioning* richiede un riavvio. Prima di poter creare l’integrazione, è necessario completare il riavvio e applicare correttamente il nuovo valore del parametro al cluster.
Se l’origine e la destinazione selezionate si trovano in Account AWS diversi, Amazon RDS non può correggere queste impostazioni per te. Devi accedere all’altro account e correggerle manualmente in Amazon Redshift.
1. Una volta configurato correttamente il data warehouse di destinazione, scegli **Avanti**.
1. (Facoltativo) In **Tag**, aggiungi uno o più tag all’integrazione. Per ulteriori informazioni, consulta [Etichettatura delle Amazon RDS](USER_Tagging.md).
1. In **Crittografia**, specifica come eseguire la crittografia dell’integrazione. Per impostazione predefinita, RDS crittografa tutte le integrazioni con un. Chiave di proprietà di AWS Per scegliere invece una chiave gestita dal cliente, abilita **Personalizza le impostazioni di crittografia** e scegli una chiave KMS da utilizzare per la crittografia. Per ulteriori informazioni, consulta [Crittografia delle risorse Amazon RDS](Overview.Encryption.md).
Aggiungi un contesto di crittografia (facoltativo). Per ulteriori informazioni, consultare [Contesto della crittografia](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context) nella *Guida per gli sviluppatori di AWS Key Management Service *.
**Nota**
Amazon RDS aggiunge le seguenti coppie di contesti di crittografia oltre a quelle che aggiungi tu:
`aws:redshift:integration:arn` - `IntegrationArn`
`aws:servicename:id` - `Redshift`
Ciò riduce il numero complessivo di coppie che puoi aggiungere da 8 a 6 e contribuisce al limite complessivo di caratteri del vincolo di concessione. Per ulteriori informazioni sulle autorizzazioni, consulta [Utilizzo dei vincoli di concessione](https://docs.aws.amazon.com/kms/latest/developerguide/create-grant-overview.html#grant-constraints) nella *Guida per gli sviluppatori di AWS Key Management Service *.
1. Scegli **Next (Successivo)**.
1. Rivedi le impostazioni dell'integrazione e scegli **Crea integrazione Zero-ETL**.
Se la creazione ha esito negativo, consulta [Non riesco a creare un’integrazione Zero-ETL](zero-etl.troubleshooting.md#zero-etl.troubleshooting.creation) per la procedura di risoluzione dei problemi.
Lo stato dell’integrazione è `Creating` mentre l’integrazione è in fase di creazione, mentre lo stato del data warehouse Amazon Redshift di destinazione è `Modifying`. Durante questo periodo, non puoi eseguire query sul data warehouse o apportare modifiche alla configurazione.
Quando la creazione dell’integrazione viene completata correttamente, lo stato dell’integrazione e del data warehouse Amazon Redshift di destinazione cambia in `Active`.
### AWS CLI
Per creare un'integrazione zero-ETL utilizzando il AWS CLI, utilizza il comando [create-integration](https://docs.aws.amazon.com/cli/latest/reference/rds/create-integration.html) con le seguenti opzioni:
**Nota**
Ricorda che i nomi dei cataloghi hanno un limite di 19 caratteri. Scegli il nome dell’integrazione tenendo conto del fatto che potrà essere utilizzato come nome di catalogo.
+ `--integration-name`: specifica un nome per l’integrazione.
+ `--source-arn`: specifica l’ARN del database RDS che sarà l’origine dell’integrazione.
+ `--target-arn`: specifica l’ARN del data warehouse di Amazon Redshift che sarà la destinazione dell’integrazione.
**Example**
Per Linux, macOS o Unix:
```
aws rds create-integration \
--integration-name my-integration \
--source-arn arn:aws:rds:{region}:{account-id}:my-db \
--target-arn arn:aws:redshift:{region}:{account-id}:namespace:namespace-uuid
```
Per Windows:
```
aws rds create-integration ^
--integration-name my-integration ^
--source-arn arn:aws:rds:{region}:{account-id}:my-db ^
--target-arn arn:aws:redshift:{region}:{account-id}:namespace:namespace-uuid
```
### API RDS
Per creare un’integrazione Zero-ETL con l’API Amazon RDS, utilizza l’operazione [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateIntegration.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateIntegration.html) con i seguenti parametri:
**Nota**
I nomi dei cataloghi hanno un limite di 19 caratteri. Assicuratevi che il IntegrationName parametro soddisfi questo requisito se verrà utilizzato come nome di catalogo.
+ `IntegrationName`: specifica un nome per l’integrazione.
+ `SourceArn`: specifica l’ARN del database RDS che sarà l’origine dell’integrazione.
+ `TargetArn`: specifica l’ARN del data warehouse di Amazon Redshift che sarà la destinazione dell’integrazione.
## Crittografia delle integrazioni con una chiave gestita dal cliente
Se specifichi una chiave KMS personalizzata anziché una Chiave di proprietà di AWS quando crei un'integrazione, la policy chiave deve fornire al servizio Amazon Redshift l'accesso principale all'`CreateGrant`azione. Inoltre, deve consentire all’utente corrente di eseguire le operazioni `DescribeKey` e `CreateGrant`.
La seguente policy di esempio mostra come fornire le autorizzazioni richieste nella policy della chiave. Include chiavi contestuali per ridurre ulteriormente l’ambito delle autorizzazioni.
### Policy della chiave di esempio
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "Key policy",
"Statement": [
{
"Sid": "Enables IAM user permissions",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:root"
},
"Action": "kms:*",
"Resource": "*"
},
{
"Sid": "Allows the Redshift service principal to add a grant to a KMS key",
"Effect": "Allow",
"Principal": {
"Service": "redshift.amazonaws.com"
},
"Action": "kms:CreateGrant",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:EncryptionContext:{context-key}": "{context-value}"
},
"ForAllValues:StringEquals": {
"kms:GrantOperations": [
"Decrypt",
"GenerateDataKey",
"CreateGrant"
]
}
}
},
{
"Sid": "Allows the current user or role to add a grant to a KMS key",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/{role-name}"
},
"Action": "kms:CreateGrant",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:EncryptionContext:{context-key}": "{context-value}",
"kms:ViaService": "rds.us-east-1.amazonaws.com"
},
"ForAllValues:StringEquals": {
"kms:GrantOperations": [
"Decrypt",
"GenerateDataKey",
"CreateGrant"
]
}
}
},
{
"Sid": "Allows the current uer or role to retrieve information about a KMS key",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/{role-name}"
},
"Action": "kms:DescribeKey",
"Resource": "*"
}
]
}
```
------
Per ulteriori informazioni, consulta [Creazione di una policy delle chiavi](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-overview.html) nella *Guida per gli sviluppatori di AWS Key Management Service *.
## Fasi successive
Dopo aver creato correttamente un’integrazione Zero-ETL, devi creare un database di destinazione all’interno del cluster o del gruppo di lavoro Amazon Redshift di destinazione. Quindi, puoi iniziare ad aggiungere dati al database RDS ed eseguirvi query in Amazon Redshift. Per istruzioni, consulta [Creazione di database di destinazione in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.creating-db.html).
# Creazione di integrazioni Zero-ETL di Amazon RDS con un lakehouse Amazon SageMaker
Quando crei un'integrazione Zero-ETL di Amazon RDS con Amazon SageMaker un lakehouse, specifichi il database RDS di origine, il cluster DB e il catalogo gestito di destinazione. AWS Glue Puoi anche personalizzare le impostazioni di crittografia e aggiungere tag. Amazon RDS crea un’integrazione tra il database di origine e la sua destinazione. Dopo aver attivato l’integrazione, tutti i dati che inserisci nel database di origine verranno replicati nella destinazione configurata.
## Prerequisiti
AWS Glue Devi anche consentire la replica nel catalogo aggiungendo database come origine di integrazione autorizzata.
Per istruzioni su come completare ciascuno di questi passaggi, consulta [Guida introduttiva alle integrazioni Zero-ETL di Amazon RDS](zero-etl.setting-up.md).
## Autorizzazioni richieste
Per creare un’integrazione Zero-ETL, occorrono alcune autorizzazioni IAM con un lakehouse Amazon SageMaker. Come requisito minimo, dovrai disporre delle autorizzazioni per eseguire le seguenti operazioni:
+ Creazione di integrazioni Zero-ETL per il database RDS di origine.
+ Visualizzazione ed eliminazione di tutte le integrazioni Zero-ETL.
+ Crea integrazioni in entrata nel catalogo gestito di destinazione. AWS Glue
+ Accedi ai bucket Amazon S3 utilizzati dal catalogo gestito. AWS Glue
+ Usa AWS KMS le chiavi per la crittografia se è configurata una crittografia personalizzata.
+ Registra le risorse con Lake Formation.
+ Inserisci la politica delle risorse nel catalogo AWS Glue gestito per autorizzare le integrazioni in entrata.
La seguente policy di esempio mostra le [autorizzazioni con privilegi minimi](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege) richieste per creare e gestire le integrazioni con un lakehouse Amazon SageMaker. Potresti non aver bisogno di queste autorizzazioni esatte se il tuo utente o ruolo dispone di autorizzazioni più ampie, come una policy gestita `AdministratorAccess`.
Inoltre, è necessario configurare una politica delle risorse sul catalogo AWS Glue gestito di destinazione per autorizzare le integrazioni in entrata. Utilizza il AWS CLI comando seguente per applicare la politica delle risorse.
### AWS CLI Comando di esempio per autorizzare le integrazioni in entrata sul catalogo di destinazione
```
aws glue put-resource-policy \
--policy-in-json '{
"Version": "2012-10-17",
"Statement": [{
"Effect": "Allow",
"Principal": {
"Service": "glue.amazonaws.com"
},
"Action": [
"glue:AuthorizeInboundIntegration"
],
"Resource": ["arn:aws:glue:region:account_id:catalog/catalog_name"],
"Condition": {
"StringEquals": {
"aws:SourceArn": "arn:aws:rds:region:account_id:db:source_name"
}
}
},
{
"Effect": "Allow",
"Principal": {
"AWS": "account_id"
},
"Action": ["glue:CreateInboundIntegration"],
"Resource": ["arn:aws:glue:region:account_id:catalog/catalog_name"]
}
]
}' \
--region region
```
**Nota**
Il catalogo Glue Amazon Resource Names (ARNs) ha il seguente formato:
Catalogo Glue — `arn:aws:glue:{region}:{account-id}:catalog/catalog-name`
### Scelta di un catalogo AWS Glue gestito di destinazione in un account diverso
Se prevedi di specificare un catalogo AWS Glue gestito di destinazione che si trova in un altro Account AWS, devi creare un ruolo che consenta agli utenti dell'account corrente di accedere alle risorse nell'account di destinazione. Per ulteriori informazioni, consulta [Fornire l'accesso a un utente IAM in un altro Account AWS utente di tua proprietà](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_aws-accounts.html).
Il ruolo deve disporre delle seguenti autorizzazioni, che consentono all'utente di visualizzare AWS Glue i cataloghi disponibili nell'account di destinazione.
#### Autorizzazioni richieste e policy di attendibilità
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"glue:GetCatalog"
],
"Resource":[
"*"
]
}
]
}
```
------
Il ruolo deve avere la seguente policy di attendibilità, che specifica l’ID dell’account di destinazione.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Principal":{
"AWS": "arn:aws:iam::111122223333:root"
},
"Action":"sts:AssumeRole"
}
]
}
```
------
Per istruzioni sulla creazione del ruolo, consulta [Creazione di un ruolo utilizzando policy di attendibilità personalizzate](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-custom.html).
## Creazione di integrazioni Zero-ETL con un lakehouse Amazon SageMaker
Puoi creare un'integrazione zero-ETL con un Amazon SageMaker lakehouse utilizzando l'API Console di gestione AWS, the o RDS. AWS CLI
**Importante**
Le integrazioni Zero-ETL con un lakehouse Amazon SageMaker non supportano le operazioni di aggiornamento o risincronizzazione. Se riscontri problemi con un’integrazione dopo la creazione, devi eliminarla e crearne una nuova.
Per impostazione predefinita, RDS per MySQL elimina immediatamente i file di log binari. Poiché le integrazioni Zero-ETL si basano sui log binari per replicare i dati dall’origine alla destinazione, il periodo di conservazione del database di origine deve essere di almeno un’ora. Non appena crei un’integrazione, Amazon RDS verifica il periodo di conservazione dei file di log binari per il database di origine selezionato. Se il valore corrente è 0 ore, Amazon RDS lo modifica automaticamente in 1 ora. In caso contrario, il valore rimane invariato.
### Console RDS
**Per creare un’integrazione Zero-ETL con un lakehouse Amazon SageMaker**
1. Accedi a Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nel pannello di navigazione a sinistra, scegli **Interfacce di rete**.
1. Scegli **Crea un’integrazione Zero-ETL**.
1. In **Identificatore dell’integrazione**, inserisci un nome per l’integrazione. Il nome può contenere fino a 63 caratteri alfanumerici e può includere trattini.
1. Scegli **Next (Successivo)**.
1. In **Origine**, seleziona il database RDS da cui provengono i dati.
**Nota**
RDS avvisa l’utente se i parametri del DB non sono configurati correttamente. Se ricevi questo messaggio, puoi scegliere **Correggi per me** o configurarli manualmente. Per istruzioni su come correggerli manualmente, consulta [Fase 1: creazione di un gruppo di parametri del di database personalizzato](zero-etl.setting-up.md#zero-etl.parameters).
La modifica dei parametri del DB richiede un riavvio. Prima di poter creare l’integrazione, è necessario completare il riavvio e applicare correttamente i nuovi valori del parametro al database.
1. Una volta completata la configurazione del database di origine, scegli **Avanti**.
1. Per **Destinazione**, esegui queste operazioni:
1. (Facoltativo) Per utilizzarne uno diverso Account AWS per Amazon SageMaker Lakehouse Target, scegli **Specificare un account** diverso. Quindi, inserisci l'ARN di un ruolo IAM con le autorizzazioni per visualizzare i tuoi cataloghi. AWS Glue Per istruzioni su come creare il ruolo IAM, consulta [Scelta di un catalogo AWS Glue gestito di destinazione in un account diverso](#zero-etl.create-permissions-cross-account-smlh).
1. Per **Catalogo AWS Glue **, seleziona la destinazione per i dati replicati dal database di origine. Puoi selezionare un catalogo AWS Glue gestito esistente come destinazione.
1. Il ruolo IAM di destinazione deve descrivere le autorizzazioni nel catalogo di destinazione e deve disporre delle seguenti autorizzazioni:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": "glue:GetCatalog",
"Resource": [
"arn:aws:glue:us-east-1:111122223333:catalog/*",
"arn:aws:glue:us-east-1:111122223333:catalog"
]
}
]
}
```
------
Il ruolo IAM deve avere la relazione di trust seguente:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "glue.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. È necessario concedere al ruolo IAM di destinazione le autorizzazioni di descrizione del ruolo per il catalogo AWS Glue gestito di destinazione con il ruolo di amministratore Lake Formation creato in[Fase 3b: creazione di un AWS Glue catalogo per l'integrazione Zero-ETL con Amazon SageMaker Lakehouse](zero-etl.setting-up.md#zero-etl-setting-up.sagemaker).
**Nota**
RDS ti avvisa se la politica delle risorse o le impostazioni di configurazione per il catalogo AWS Glue gestito specificato non sono configurate correttamente. Se ricevi questo messaggio, puoi scegliere **Correggi per me** o configurarli manualmente.
Se l’origine e la destinazione selezionate si trovano in Account AWS diversi, Amazon RDS non può correggere queste impostazioni per te. Devi accedere all’altro account e correggerli manualmente in SageMaker Unified Studio.
1. **Una volta configurato correttamente il catalogo AWS Glue gestito di destinazione, scegli Avanti.**
1. (Facoltativo) In **Tag**, aggiungi uno o più tag all’integrazione. Per ulteriori informazioni, consulta [Etichettatura delle Amazon RDS](USER_Tagging.md).
1. In **Crittografia**, specifica come eseguire la crittografia dell’integrazione. Per impostazione predefinita, RDS crittografa tutte le integrazioni con un. Chiave di proprietà di AWS Per scegliere invece una chiave gestita dal cliente, abilita **Personalizza le impostazioni di crittografia** e scegli una chiave KMS da utilizzare per la crittografia. Per ulteriori informazioni, consulta [Crittografia delle risorse Amazon RDS](Overview.Encryption.md).
Aggiungi un contesto di crittografia (facoltativo). Per ulteriori informazioni, consultare [Contesto della crittografia](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context) nella *Guida per gli sviluppatori di AWS Key Management Service *.
**Nota**
Amazon RDS aggiunge le seguenti coppie di contesti di crittografia oltre a quelle che aggiungi tu:
`aws:glue:integration:arn` - `IntegrationArn`
`aws:servicename:id` - `glue`
Ciò riduce il numero complessivo di coppie che puoi aggiungere da 8 a 6 e contribuisce al limite complessivo di caratteri del vincolo di concessione. Per ulteriori informazioni sulle autorizzazioni, consulta [Utilizzo dei vincoli di concessione](https://docs.aws.amazon.com/kms/latest/developerguide/create-grant-overview.html#grant-constraints) nella *Guida per gli sviluppatori di AWS Key Management Service *.
1. Scegli **Next (Successivo)**.
1. Rivedi le impostazioni dell'integrazione e scegli **Crea integrazione Zero-ETL**.
Se la creazione ha esito negativo, consulta [Risoluzione dei problemi delle integrazioni Zero-ETL di Amazon RDS](zero-etl.troubleshooting.md) per la procedura di risoluzione dei problemi.
Lo stato dell’integrazione è `Creating` mentre l’integrazione è in fase di creazione, mentre il lakehouse Amazon SageMaker di destinazione ha uno stato di `Modifying`. Durante questo periodo, non puoi eseguire query sul catalogo o apportare modifiche alla configurazione.
Quando la creazione dell’integrazione viene completata correttamente, lo stato dell’integrazione e del lakehouse Amazon SageMaker di destinazione cambia in `Active`.
### AWS CLI
Per preparare un catalogo AWS Glue gestito di destinazione per l'integrazione zero-ETL utilizzando il AWS CLI, è necessario innanzitutto utilizzare il comando con le [create-integration-resource-property](https://docs.aws.amazon.com/cli/latest/reference/rds/create-integration.html)seguenti opzioni:
+ `--resource-arn`— Specificare l'ARN del catalogo AWS Glue gestito che sarà la destinazione per l'integrazione.
+ `--target-processing-properties`— Specificare l'ARN del ruolo IAM per accedere al catalogo gestito di destinazione AWS Glue
```
aws glue create-integration-resource-property --region us-east-1
--resource-arn arn:aws:glue:region:account_id:catalog/catalog_name \
--target-processing-properties '{"RoleArn" : "arn:aws:iam::account_id:role/TargetIamRole"}'
```
Per creare un'integrazione zero-ETL con un Amazon SageMaker lakehouse utilizzando il AWS CLI, utilizza il comando [create-integration](https://docs.aws.amazon.com/cli/latest/reference/rds/create-integration.html) con le seguenti opzioni:
+ `--integration-name`: specifica un nome per l’integrazione.
+ `--source-arn`: specificare l’ARN del database RDS che sarà l’origine dell’integrazione.
+ `--target-arn`— Specificare l'ARN del catalogo AWS Glue gestito che sarà la destinazione per l'integrazione.
**Example**
Per Linux, macOS o Unix:
```
aws rds create-integration \
--integration-name my-sagemaker-integration \
--source-arn arn:aws:rds:{region}:{account-id}:cluster:my-db \
--target-arn arn:aws:glue:{region}:{account-id}:catalog/catalog-name
```
Per Windows:
```
aws rds create-integration ^
--integration-name my-sagemaker-integration ^
--source-arn arn:aws:rds:{region}:{account-id}:cluster:my-db ^
--target-arn arn:aws:glue:{region}:{account-id}:catalog/catalog-name
```
### API RDS
Per creare un’integrazione Zero-ETL con Amazon SageMaker mediante l’API Amazon RDS, utilizza l’operazione [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateIntegration.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateIntegration.html) con i seguenti parametri:
**Nota**
I nomi dei cataloghi sono limitati a 19 caratteri. Assicurati che il IntegrationName parametro soddisfi questo requisito se verrà utilizzato come nome di catalogo.
+ `IntegrationName`: specifica un nome per l’integrazione.
+ `SourceArn`: specificare l’ARN del database RDS che sarà l’origine dell’integrazione.
+ `TargetArn`— Specificare l'ARN del catalogo AWS Glue gestito che sarà la destinazione per l'integrazione.
## Crittografia delle integrazioni con una chiave gestita dal cliente
Se si specifica una chiave KMS personalizzata anziché una chiave Chiave di proprietà di AWS quando si crea un'integrazione conAmazon SageMaker, la politica chiave deve fornire al SageMaker Unified Studio servizio principale l'accesso all'azione. `CreateGrant` Inoltre, deve consentire all’utente corrente di eseguire le operazioni `DescribeKey` e `CreateGrant`.
La seguente policy di esempio mostra come fornire le autorizzazioni richieste nella policy della chiave. Include chiavi contestuali per ridurre ulteriormente l’ambito delle autorizzazioni.
### Policy della chiave di esempio
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "Key policy",
"Statement": [
{
"Sid": "EnablesIAMUserPermissions",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:root"
},
"Action": "kms:*",
"Resource": "*"
},
{
"Sid": "GlueServicePrincipalAddGrant",
"Effect": "Allow",
"Principal": {
"Service": "glue.amazonaws.com"
},
"Action": "kms:CreateGrant",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:EncryptionContext:{context-key}":"{context-value}"
},
"ForAllValues:StringEquals": {
"kms:GrantOperations": [
"Decrypt",
"GenerateDataKey",
"CreateGrant"
]
}
}
},
{
"Sid": "AllowsCurrentUserRoleAddGrantKMSKey",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/{role-name}"
},
"Action": "kms:CreateGrant",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:EncryptionContext:{context-key}":"{context-value}",
"kms:ViaService": "rds.us-east-1.amazonaws.com"
},
"ForAllValues:StringEquals": {
"kms:GrantOperations": [
"Decrypt",
"GenerateDataKey",
"CreateGrant"
]
}
}
},
{
"Sid": "AllowsCurrentUserRoleRetrieveKMSKeyInformation",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/{role-name}"
},
"Action": "kms:DescribeKey",
"Resource": "*"
}
]
}
```
------
Per ulteriori informazioni, consulta [Creazione di una policy delle chiavi](https://docs.aws.amazon.com/kms/latest/developerguide/key-policy-overview.html) nella *Guida per gli sviluppatori di AWS Key Management Service *.
## Fasi successive
Dopo aver creato con successo un’integrazione Zero-ETL con Amazon SageMaker, puoi iniziare ad aggiungere dati al database RDS di origine ed eseguire query su di essi nel tuo lakehouse Amazon SageMaker. I dati verranno replicati automaticamente e resi disponibili per analisi e carichi di lavoro di machine learning.
# Filtro dei dati per integrazioni Zero-ETL di Amazon RDS
Le integrazioni Zero-ETL di Amazon RDS supportano il filtro dei dati, che consente di controllare quali dati vengono replicati dal database Amazon RDS di origine al data warehouse di destinazione. Invece di replicare l’intero database, puoi applicare uno o più filtri per includere o escludere selettivamente delle tabelle specifiche. Ciò consente di ottimizzare le prestazioni di archiviazione e query assicurando che vengano trasferiti solo i dati pertinenti. Attualmente, il filtro è limitato a livello di database e tabella. Il filtro a livello di colonna e riga non è supportato.
Il filtro dei dati può essere utile se desideri:
+ Unire determinate tabelle da due o più database di origine diversi e non hai bisogno dei dati completi da ciascun database.
+ Risparmiare sui costi eseguendo analisi che utilizzano solo un sottoinsieme di tabelle anziché un intero parco di database.
+ Filtrare le informazioni sensibili, come numeri di telefono, indirizzi o dettagli delle carte di credito, da determinate tabelle.
Puoi aggiungere filtri di dati a un'integrazione zero-ETL utilizzando Console di gestione AWS, the AWS Command Line Interface (AWS CLI) o l'API Amazon RDS.
Se l’integrazione ha come destinazione un cluster con provisioning, per utilizzare il filtro dei dati è necessario che il cluster utilizzi la [patch 180](https://docs.aws.amazon.com/redshift/latest/mgmt/cluster-versions.html#cluster-version-180) o una versione successiva.
**Topics**
+ [Formato di un filtro dei dati](#zero-etl.filtering-format)
+ [Logica dei filtri](#zero-etl.filtering-evaluate)
+ [Precedenza dei filtri](#zero-etl.filtering-precedence)
+ [Esempi di RDS per MySQL](#zero-etl.filtering-examples-mysql)
+ [Esempi di RDS per PostgreSQL](#zero-etl.filtering-examples-postgres)
+ [Esempi di RDS per Oracle](#zero-etl.filtering-examples-oracle)
+ [Aggiunta di filtri dei dati a un’integrazione](#zero-etl.add-filter)
+ [Rimozione di filtri dei dati da un’integrazione](#zero-etl.remove-filter)
## Formato di un filtro dei dati
Puoi definire diversi filtri per una singola integrazione. Ogni filtro include o esclude tutte le tabelle di database esistenti e future che corrispondono a uno dei modelli nell’espressione di filtro. Le integrazioni Zero-ETL di Amazon RDS utilizzano la [sintassi del filtro Maxwell](https://maxwells-daemon.io/filtering/) per il filtro dei dati.
Ogni filtro contiene i seguenti elementi:
| Elemento | Description |
| --- | --- |
| Tipo di filtro | Un tipo di filtro `Include` *include* tutte le tabelle che corrispondono a uno dei modelli nell’espressione di filtro. Un tipo di filtro `Exclude` *esclude* tutte le tabelle che corrispondono a uno dei modelli. |
| Espressione filtro | Un elenco di modelli separato da virgole. Le espressioni devono utilizzare la [sintassi del filtro Maxwell](https://maxwells-daemon.io/filtering/). |
| Pattern | Un modello di filtro nel formato `database.table` per RDS per MySQL oppure nel formato `database.schema.table` per RDS per PostgreSQL. Puoi specificare nomi letterali o definire espressioni regolari. Per RDS per MySQL, le espressioni regolari sono supportate sia nel nome del database sia in quello della tabella. Per RDS per PostgreSQL, le espressioni regolari sono supportate solo nel nome dello schema e della tabella, non in quello del database. Non è possibile includere filtri o elenco elementi non consentiti a livello di colonna. Una singola integrazione può avere un massimo di 99 modelli totali. Nella console, è possibile inserire modelli all’interno di una singola espressione di filtro o distribuirli tra diverse espressioni. Un singolo modello non può superare i 256 caratteri. |
**Importante**
Se selezioni un database di origine RDS per PostgreSQL, è necessario specificare almeno un modello di filtro dei dati. Come minimo, il modello deve includere un singolo database (`database-name.*.*`) per la replica nel data warehouse di destinazione.
L’immagine seguente mostra la struttura dei filtri dei dati di RDS per MySQL nella console:
![\[Filtri dei dati per un’integrazione Zero-ETL\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/zero-etl-filter.png)
**Importante**
Non includere informazioni riservate, sensibili o di identificazione personale nei modelli di filtro.
### Filtri di dati in AWS CLI
Quando si utilizza AWS CLI per aggiungere un filtro dati, la sintassi è leggermente diversa da quella della console. È necessario assegnare un tipo di filtro (`Include` o `Exclude`) a ciascun modello singolarmente, in modo da non poter raggruppare diversi modelli in un unico tipo di filtro.
Ad esempio, nella console puoi raggruppare i seguenti modelli separati da virgola in un’unica istruzione `Include`:
**RDS per MySQL**
```
mydb.mytable, mydb./table_\d+/
```
**RDS per PostgreSQL**
```
mydb.myschema.mytable, mydb.myschema./table_\d+/
```
Tuttavia, quando si utilizza il AWS CLI, lo stesso filtro dati deve avere il seguente formato:
**RDS per MySQL**
```
'include: mydb.mytable, include: mydb./table_\d+/'
```
**RDS per PostgreSQL**
```
'include: mydb.myschema.mytable, include: mydb.myschema./table_\d+/'
```
## Logica dei filtri
Se non specifichi alcun filtro dei dati nell’integrazione, Amazon RDS presuppone un filtro predefinito `include:*.*`, che replica tutte le tabelle nel data warehouse di destinazione. Tuttavia, se aggiungi almeno un filtro, la logica predefinita passa a `exclude:*.*`, che esclude tutte le tabelle per impostazione predefinita. Ciò consente di definire in modo esplicito quali database e tabelle includere nella replica.
Ad esempio, se definisci il filtro seguente:
```
'include: db.table1, include: db.table2'
```
Amazon RDS valuta il filtro come indicato di seguito:
```
'exclude:*.*, include: db.table1, include: db.table2'
```
Pertanto, Amazon RDS esegue la replica di `table1` e `table2` dal database denominato `db` al data warehouse di destinazione.
## Precedenza dei filtri
Amazon RDS valuta i filtri dei dati nell’ordine specificato. In Console di gestione AWS, elabora le espressioni di filtro da sinistra a destra e dall'alto verso il basso. Un secondo filtro o un modello individuale che segue il primo può sovrascriverlo.
Ad esempio, se il primo filtro è `Include books.stephenking`, include solo la tabella `stephenking` del database `books`. Tuttavia, se aggiungi un secondo filtro `Exclude books.*`, questo sostituisce il primo. Ciò impedisce che le tabelle dell’indice `books` vengano replicate nel data warehouse di destinazione.
Quando si specifica almeno un filtro, la logica parte presupponendo `exclude:*.*` per impostazione predefinita, che *esclude* automaticamente tutte le tabelle dalla replica. Come best practice, definisci i filtri dal più ampio al più specifico. Inizia con una o più istruzioni `Include` per specificare i dati da replicare, quindi aggiungi i filtri `Exclude` per rimuovere selettivamente determinate tabelle.
Lo stesso principio si applica ai filtri definiti utilizzando AWS CLI. Amazon RDS valuta questi modelli di filtro nell’ordine in cui li specifichi, quindi un modello potrebbe sovrascrivere quello specificato in precedenza.
## Esempi di RDS per MySQL
Gli esempi seguenti mostrano come funziona il filtro dei dati per le integrazioni Zero-ETL di RDS per MySQL:
+ Includi tutti i database e tutte le tabelle:
```
'include: *.*'
```
+ Includi tutte le tabelle all’interno del database `books`:
```
'include: books.*'
```
+ Escludi tutte le tabelle denominate `mystery`:
```
'include: *.*, exclude: *.mystery'
```
+ Includi due tabelle specifiche all’interno del database `books`:
```
'include: books.stephen_king, include: books.carolyn_keene'
```
+ Includi tutte le tabelle del database `books`, ad eccezione di quelle contenenti la sottostringa `mystery`:
```
'include: books.*, exclude: books./.*mystery.*/'
```
+ Includi tutte le tabelle del database `books`, ad eccezione di quelle che iniziano con `mystery`:
```
'include: books.*, exclude: books./mystery.*/'
```
+ Includi tutte le tabelle del database `books`, ad eccezione di quelle che terminano con `mystery`:
```
'include: books.*, exclude: books./.*mystery/'
```
+ Includi tutte le tabelle del database `books` che iniziano con `table_`, ad eccezione di quella denominata `table_stephen_king`. Ad esempio, `table_movies` o `table_books` verrebbe replicato, ma `table_stephen_king` non verrebbe replicato.
```
'include: books./table_.*/, exclude: books.table_stephen_king'
```
## Esempi di RDS per PostgreSQL
Gli esempi seguenti mostrano come funziona il filtro dei dati per le integrazioni Zero-ETL di RDS per PostgreSQL:
+ Includi tutte le tabelle all’interno del database `books`:
```
'include: books.*.*'
```
+ Escludi tutte le tabelle denominate `mystery` nel database `books`:
```
'include: books.*.*, exclude: books.*.mystery'
```
+ Includi una tabella all’interno del database `books` nello schema `mystery` e una tabella nel database `employee` nello schema `finance`:
```
'include: books.mystery.stephen_king, include: employee.finance.benefits'
```
+ Includi tutte le tabelle del database `books` e dello schema `science_fiction`, ad eccezione di quelle contenenti la sottostringa `king`:
```
'include: books.science_fiction.*, exclude: books.*./.*king.*/
```
+ Includi tutte le tabelle del database `books`, ad eccezione di quelle con un nome di schema che inizia con`sci`:
```
'include: books.*.*, exclude: books./sci.*/.*'
```
+ Includi tutte le tabelle del database `books`, ad eccezione di quelle nello schema `mystery` che termina con `king`:
```
'include: books.*.*, exclude: books.mystery./.*king/'
```
+ Includi tutte le tabelle del database `books` che iniziano con `table_`, ad eccezione di quella denominata `table_stephen_king`. Ad esempio, `table_movies` nello schema `fiction` e `table_books` nello schema `mystery` vengono replicati, ma `table_stephen_king` non verrà replicato in nessuno dei due schemi:
```
'include: books.*./table_.*/, exclude: books.*.table_stephen_king'
```
## Esempi di RDS per Oracle
Gli esempi seguenti mostrano come funziona il filtro dei dati per le integrazioni Zero-ETL di RDS per Oracle:
+ Includi tutte le tabelle all’interno del database books:
```
'include: books.*.*'
```
+ Escludi tutte le tabelle denominate mystery nel database books:
```
'include: books.*.*, exclude: books.*.mystery'
```
+ Includi una tabella all’interno del database books nello schema mystery e una tabella nel database employee nello schema finance:
```
'include: books.mystery.stephen_king, include: employee.finance.benefits'
```
+ Includi tutte le tabelle dello schema mystery nel database books:
```
'include: books.mystery.*'
```
### Considerazioni sulla distinzione tra lettere maiuscole e minuscole
Oracle Database e Amazon Redshift gestiscono le lettere maiuscole e minuscole del nome oggetto in modo diverso. Ciò influisce sia sulla configurazione del filtro dei dati sia sulle query di destinazione. Tenere presente quanto segue:
+ Oracle Database memorizza i nomi di database, schemi e oggetti con le lettere maiuscole, a meno che non vengano esplicitamente inseriti tra virgolette nell’istruzione `CREATE`. Ad esempio, se si crea `mytable` (senza virgolette), il dizionario dei dati Oracle memorizza il nome della tabella come `MYTABLE`. Se metti il nome dell’oggetto tra virgolette, il dizionario dei dati mantiene le lettere minuscole.
+ I filtri dei dati Zero-ETL fanno distinzione tra maiuscole e minuscole e devono corrispondere esattamente alle maiuscole e minuscole dei nomi degli oggetti così come appaiono nel dizionario dei dati Oracle.
+ Le query di Amazon Redshift utilizzano per impostazione predefinita i nomi di oggetti in minuscolo, a meno che non vengano esplicitamente inseriti tra virgolette. Ad esempio, una query di `MYTABLE` (senza virgolette) cerca `mytable`.
Tieni presente le differenze tra maiuscole e minuscole quando crei il filtro Amazon Redshift ed esegui query sui dati.
#### Creazione di un’integrazione con lettere maiuscole
Quando crei una tabella senza specificare il nome tra virgolette doppie, il database Oracle memorizza il nome in lettere maiuscole nel dizionario dei dati. Ad esempio, puoi creare `MYTABLE` utilizzando una delle istruzioni SQL elencate di seguito.
```
CREATE TABLE REINVENT.MYTABLE (id NUMBER PRIMARY KEY, description VARCHAR2(100));
CREATE TABLE reinvent.mytable (id NUMBER PRIMARY KEY, description VARCHAR2(100));
CREATE TABLE REinvent.MyTable (id NUMBER PRIMARY KEY, description VARCHAR2(100));
CREATE TABLE reINVENT.MYtabLE (id NUMBER PRIMARY KEY, description VARCHAR2(100));
```
Poiché non hai citato il nome della tabella nelle istruzioni precedenti, il database Oracle memorizza il nome dell’oggetto in lettere maiuscole, ossia `MYTABLE`.
Per replicare questa tabella su Amazon Redshift, è necessario specificare il nome in lettere maiuscole nel filtro dei dati del comando `create-integration`. Il nome del filtro Zero-ETL e il nome del dizionario dati Oracle devono corrispondere.
```
aws rds create-integration \
--integration-name upperIntegration \
--data-filter "include: ORCL.REINVENT.MYTABLE" \
...
```
Per impostazione predefinita, Amazon Redshift archivia i dati in lettere minuscole. Per eseguire una query `MYTABLE` nel database replicato in Amazon Redshift, è necessario inserire tra virgolette il nome `MYTABLE` in lettere maiuscole in modo che corrisponda al nome con lettere maiuscole nel dizionario dei dati Oracle.
```
SELECT * FROM targetdb1."REINVENT"."MYTABLE";
```
Le query elencate di seguito non utilizzano il meccanismo di inserimento tra virgolette. Tutte restituiscono un errore perché cercano una tabella Amazon Redshift denominata `mytable`, che utilizza il nome minuscolo per impostazione predefinita, ma la tabella è denominata `MYTABLE` nel dizionario dei dati Oracle.
```
SELECT * FROM targetdb1."REINVENT".MYTABLE;
SELECT * FROM targetdb1."REINVENT".MyTable;
SELECT * FROM targetdb1."REINVENT".mytable;
```
Le seguenti query utilizzano il meccanismo di inserimento tra virgolette per specificare un nome con formato misto, ossia con lettere maiuscole e minuscole. Tutte le query restituiscono un errore perché cercano una tabella Amazon Redshift che non è denominata `MYTABLE`.
```
SELECT * FROM targetdb1."REINVENT"."MYtablE";
SELECT * FROM targetdb1."REINVENT"."MyTable";
SELECT * FROM targetdb1."REINVENT"."mytable";
```
#### Creazione di un’integrazione con lettere minuscole
Nel seguente esempio alternativo, si utilizzano le virgolette doppie per memorizzare il nome della tabella in lettere minuscole nel dizionario dei dati Oracle. Crei `mytable` come indicato di seguito.
```
CREATE TABLE REINVENT."mytable" (id NUMBER PRIMARY KEY, description VARCHAR2(100));
```
Il database Oracle memorizza il nome della tabella `mytable` con lettere minuscole. Per replicare questa tabella in Amazon Redshift, è necessario specificare il nome `mytable` in lettere minuscole nel filtro dei dati Zero-ETL.
```
aws rds create-integration \
--integration-name lowerIntegration \
--data-filter "include: ORCL.REINVENT.mytable" \
...
```
Quando esegui una query su questa tabella nel database replicato in Amazon Redshift, puoi specificare il nome `mytable` in lettere minuscole. La query ha esito positivo perché cerca una tabella denominata `mytable`, che è il nome della tabella nel dizionario dei dati Oracle.
```
SELECT * FROM targetdb1."REINVENT".mytable;
```
Poiché Amazon Redshift utilizza per impostazione predefinita i nomi degli oggetti in lettere minuscole, anche le seguenti query riescono a trovare `mytable`.
```
SELECT * FROM targetdb1."REINVENT".MYtablE;
SELECT * FROM targetdb1."REINVENT".MYTABLE;
SELECT * FROM targetdb1."REINVENT".MyTable;
```
Le query indicate di seguito utilizzano il meccanismo di inserimento tra virgolette per il nome dell’oggetto. Tutte restituiscono un errore perché cercano una tabella Amazon Redshift il cui nome è diverso da `mytable`.
```
SELECT * FROM targetdb1."REINVENT"."MYTABLE";
SELECT * FROM targetdb1."REINVENT"."MyTable";
SELECT * FROM targetdb1."REINVENT"."MYtablE";
```
#### Creazione di una tabella con un’integrazione tra lettere maiuscole e minuscole
Nell’esempio seguente, si utilizzano le virgolette doppie per memorizzare il nome della tabella in lettere minuscole nel dizionario dei dati Oracle. Crei `MyTable` come indicato di seguito.
```
CREATE TABLE REINVENT."MyTable" (id NUMBER PRIMARY KEY, description VARCHAR2(100));
```
Il database Oracle memorizza questo nome di tabella come `MyTable` con formato misto di lettere maiuscole e minuscole. Per replicare questa tabella su Amazon Redshift, è necessario specificare il nome con formato misto di lettere maiuscole e minuscole nel filtro dei dati.
```
aws rds create-integration \
--integration-name mixedIntegration \
--data-filter "include: ORCL.REINVENT.MyTable" \
...
```
Quando esegui una query su questa tabella nel database replicato in Amazon Redshift, è necessario specificare il nome con formato misto di lettere maiuscole e minuscole `MyTable` citando il nome dell’oggetto.
```
SELECT * FROM targetdb1."REINVENT"."MyTable";
```
Poiché Amazon Redshift utilizza per impostazione predefinita i nomi degli oggetti con lettere minuscole, le seguenti query non trovano l’oggetto perché cercano il nome `mytable` con lettere minuscole.
```
SELECT * FROM targetdb1."REINVENT".MYtablE;
SELECT * FROM targetdb1."REINVENT".MYTABLE;
SELECT * FROM targetdb1."REINVENT".mytable;
```
**Nota**
Non è possibile utilizzare espressioni regolari nel valore del filtro per il nome di database, schemi o tabelle nelle integrazioni RDS per Oracle.
## Aggiunta di filtri dei dati a un’integrazione
Puoi configurare il filtraggio dei dati utilizzando Console di gestione AWS l'API AWS CLI Amazon RDS o la.
**Importante**
Se aggiungi un filtro dopo aver creato un’integrazione, Amazon RDS lo considera come se fosse sempre esistito. Rimuove tutti i dati nel data warehouse di destinazione che non corrispondono ai nuovi criteri di filtro e risincronizza tutte le tabelle interessate.
### Console RDS
**Per aggiungere i filtri dei dati a un’integrazione Zero-ETL**
1. Accedi a Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nel pannello di navigazione, scegli **Integrazioni zero-ETL**. Seleziona l’integrazione a cui desideri aggiungere i filtri dei dati, quindi scegli **Modifica.**
1. In **Origine**, aggiungi una o più istruzioni `Include` e `Exclude`.
La seguente immagina mostra un esempio di filtri dei dati per un’integrazione MySQL:
![\[Filtri di dati per un’integrazione Zero-ETL nella console RDS\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/zero-etl-filter-data.png)
1. Una volta completate le modifiche, scegli **Continua**, quindi **Salva modifiche**.
### AWS CLI
[Per aggiungere filtri di dati a un'integrazione zero-ETL utilizzando AWS CLI, chiama il comando modify-integration.](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/rds/modify-integration.html) Oltre all’identificatore di integrazione, specifica il parametro `--data-filter` con un elenco separato da virgola di filtri Maxwell `Include` e `Exclude`.
**Example**
Nell’esempio seguente si aggiungono modelli di filtro a `my-integration`.
Per Linux, macOS o Unix:
```
aws rds modify-integration \
--integration-identifier my-integration \
--data-filter 'include: foodb.*, exclude: foodb.tbl, exclude: foodb./table_\d+/'
```
Per Windows:
```
aws rds modify-integration ^
--integration-identifier my-integration ^
--data-filter 'include: foodb.*, exclude: foodb.tbl, exclude: foodb./table_\d+/'
```
### API RDS
Per modificare un'integrazione zero-ETL utilizzando l'API RDS, chiama l'operazione. [ModifyIntegration](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyIntegration.html) Specifica l’identificatore di integrazione e fornisci un elenco separato da virgola di modelli di filtro.
## Rimozione di filtri dei dati da un’integrazione
Quando rimuovi un filtro dei dati da un’integrazione, Amazon RDS rivaluta i filtri rimanenti come se il filtro rimosso non fosse mai esistito. Successivamente, replica tutti i dati precedentemente esclusi che ora soddisfano i criteri nel data warehouse di destinazione. Ciò attiva una risincronizzazione di tutte le tabelle interessate.
# Aggiunta di dati a un database RDS di origine ed esecuzione di query al suo interno
Per completare la creazione di un’integrazione Zero-ETL che replichi i dati da Amazon RDS in Amazon Redshift, devi creare un database nella destinazione.
Per le connessioni con Amazon Redshift, connettiti al cluster o al gruppo di lavoro Amazon Redshift e crea un database con un riferimento al tuo identificatore di integrazione. Quindi, puoi aggiungere dati al database RDS e vederli replicati in Amazon Redshift o Amazon SageMaker.
**Topics**
+ [Creazione di un database di destinazione](#zero-etl.create-db)
+ [Aggiunta di dati al database di origine](#zero-etl.add-data-rds)
+ [Interrogazione dei dati Amazon RDS in Amazon Redshift](#zero-etl.query-data-redshift)
+ [Differenze tra i tipi di dati tra i database RDS e Amazon Redshift](#zero-etl.data-type-mapping)
+ [Operazioni DDL per RDS per PostgreSQL](#zero-etl.ddl-postgres)
## Creazione di un database di destinazione
Prima di poter iniziare a replicare i dati in Amazon Redshift dopo aver creato un’integrazione, devi creare un database nel data warehouse di destinazione. Questo database deve includere un riferimento all’identificatore di integrazione. Puoi utilizzare la console Amazon Redshift o Editor di query v2 per creare il database.
Per istruzioni sulla creazione di un database di destinazione, consulta [Creazione di un database di destinazione in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.creating-db.html#zero-etl-using.create-db).
## Aggiunta di dati al database di origine
Dopo aver configurato l’integrazione, puoi popolare il database RDS di origine con i dati che desideri replicare nel data warehouse.
**Nota**
Esistono differenze tra i tipi di dati in Amazon RDS e il warehouse di analisi di destinazione. Per una tabella di mappature dei tipi di dati, consulta [Differenze tra i tipi di dati tra i database RDS e Amazon Redshift](#zero-etl.data-type-mapping).
Innanzitutto, connettiti al database di origine utilizzando il client MySQL di tua scelta. Per istruzioni, consulta [Connessione all’istanza database MySQL](USER_ConnectToInstance.md).
Quindi, crea una tabella e inserisci una riga di dati di esempio.
**Importante**
Assicurati che la tabella abbia una chiave primaria. Altrimenti, non può essere replicata nel data warehouse di destinazione.
**RDS per MySQL**
L’esempio seguente utilizza [l’utilità MySQL Workbench](https://dev.mysql.com/downloads/workbench/).
```
CREATE DATABASE my_db;
USE my_db;
CREATE TABLE books_table (ID int NOT NULL, Title VARCHAR(50) NOT NULL, Author VARCHAR(50) NOT NULL,
Copyright INT NOT NULL, Genre VARCHAR(50) NOT NULL, PRIMARY KEY (ID));
INSERT INTO books_table VALUES (1, 'The Shining', 'Stephen King', 1977, 'Supernatural fiction');
```
**RDS per PostgreSQL**
L’esempio seguente utilizza il terminale interattivo PostgreSQL `[psql](https://www.postgresql.org/docs/current/app-psql.html)`. Quando ti connetti al database, includi il nome del database che desideri replicare.
```
psql -h mydatabase.123456789012.us-east-2.rds.amazonaws.com -p 5432 -U username -d named_db;
named_db=> CREATE TABLE books_table (ID int NOT NULL, Title VARCHAR(50) NOT NULL, Author VARCHAR(50) NOT NULL,
Copyright INT NOT NULL, Genre VARCHAR(50) NOT NULL, PRIMARY KEY (ID));
named_db=> INSERT INTO books_table VALUES (1, 'The Shining', 'Stephen King', 1977, 'Supernatural fiction');
```
**RDS per Oracle**
L’esempio seguente utilizza SQL\$1Plus per connettersi al database RDS per Oracle.
```
sqlplus 'user_name@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=dns_name)(PORT=port))(CONNECT_DATA=(SID=database_name)))'
SQL> CREATE TABLE books_table (ID int NOT NULL, Title VARCHAR(50) NOT NULL, Author VARCHAR(50) NOT NULL,
Copyright INT NOT NULL, Genre VARCHAR(50) NOT NULL, PRIMARY KEY (ID));
SQL> INSERT INTO books_table VALUES (1, 'The Shining', 'Stephen King', 1977, 'Supernatural fiction');
```
## Interrogazione dei dati Amazon RDS in Amazon Redshift
Dopo aver aggiunto i dati al database RDS, questi vengono replicati nel database di destinazione e sono pronti per essere sottoposti a query.
**Esecuzione di query sui dati replicati**
1. Vai alla console Amazon Redshift e scegli **Editor di query v2** nel riquadro di navigazione a sinistra.
1. Connettiti al cluster o al gruppo di lavoro e scegli il database di destinazione (creato dall’integrazione) dal menu a tendina (**destination\$1database** in questo esempio). Per istruzioni sulla creazione di un database di destinazione, consulta [Creazione di un database di destinazione in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.creating-db.html#zero-etl-using.create-db).
1. Utilizzo di un’istruzione SELECT per eseguire query sui dati. In questo esempio, puoi eseguire il comando seguente per selezionare tutti i dati dalla tabella creata nel database RDS di origine:
```
SELECT * from my_db."books_table";
```
![\[Esegui un’istruzione SELECT nell’editor di query. Il risultato è una singola riga di dati di esempio che è stata aggiunta al database Amazon RDS.\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/zero-etl-redshift-editor.png)
+ `my_db` è il nome dello schema del database RDS.
+ `books_table` è il nome della tabella RDS.
Puoi anche eseguire query sui dati utilizzando il client della riga di comando. Esempio:
```
destination_database=# select * from my_db."books_table";
ID | Title | Author | Copyright | Genre | txn_seq | txn_id
----+–------------+---------------+-------------+------------------------+----------+--------+
1 | The Shining | Stephen King | 1977 | Supernatural fiction | 2 | 12192
```
**Nota**
Per distinguere tra maiuscole e minuscole, usa le virgolette doppie (" ") per i nomi di schemi, tabelle e colonne. Per ulteriori informazioni, consulta [enable\$1case\$1sensitive\$1identifier](https://docs.aws.amazon.com/redshift/latest/dg/r_enable_case_sensitive_identifier.html).
## Differenze tra i tipi di dati tra i database RDS e Amazon Redshift
Di seguito, le tabelle mostrano le mappature dei tipi di dati RDS per MySQL, RDS per PostgreSQL e RDS per Oracle ai tipi di dati di destinazione corrispondenti. *Amazon RDS attualmente supporta solo questi tipi di dati per le integrazioni Zero-ETL.*
Se una tabella nel database di origine include un tipo di dato non supportato, la tabella non viene sincronizzata e non è utilizzabile dalla destinazione. Lo streaming dall’origine alla destinazione va avanti, ma la tabella con il tipo di dato non supportato non è disponibile. Per correggere la tabella e renderla disponibile nella destinazione, devi annullare manualmente la modifica iniziale e aggiornare l’integrazione eseguendo `[ALTER DATABASE...INTEGRATION REFRESH](https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_DATABASE.html)`.
**Nota**
Non puoi aggiornare le integrazioni Zero-ETL con un Amazon SageMaker Lakehouse. Piuttosto, elimina e prova a creare nuovamente l’integrazione.
**Topics**
+ [RDS per MySQL](#zero-etl.data-type-mapping-mysql)
+ [RDS per PostgreSQL](#zero-etl.data-type-mapping-postgres)
+ [RDS per Oracle](#zero-etl.data-type-mapping-oracle)
### RDS per MySQL
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/zero-etl.querying.html)
### RDS per PostgreSQL
Le integrazioni Zero-ETL per RDS per PostgreSQL non supportano tipi di dati personalizzati né tipi di dati creati da estensioni.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/zero-etl.querying.html)
### RDS per Oracle
**Tipi di dati non supportati**
I seguenti tipi di dati RDS per Oracle non sono supportati da Amazon Redshift:
+ `ANYDATA`
+ `BFILE`
+ `REF`
+ `ROWID`
+ `UROWID`
+ `VARRAY`
+ `SDO_GEOMETRY`
+ Tipi di dati definiti dall’utente
**Differenze dei tipi di dati**
La tabella seguente mostra le differenze tra i tipi di dati che influiscono su un’integrazione Zero-ETL quando RDS per Oracle è l’origine e Amazon Redshift è la destinazione.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/zero-etl.querying.html)
## Operazioni DDL per RDS per PostgreSQL
Amazon Redshift è derivato da PostgreSQL, quindi condivide diverse funzionalità con RDS per PostgreSQL a causa dell’architettura comune di PostgreSQL. Le integrazioni Zero-ETL sfruttano queste somiglianze per semplificare la replica dei dati da RDS per PostgreSQL ad Amazon Redshift, la mappatura di database per nome e l’utilizzo della struttura di tabella, schema e database condivisa.
Considera i seguenti punti quando gestisci le integrazioni Zero-ETL di RDS per PostgreSQL:
+ L’isolamento è gestito a livello di database.
+ La replica avviene a livello di database.
+ I database RDS per PostgreSQL sono mappati ai database Amazon Redshift per nome, con i dati che fluiscono verso il corrispondente database Redshift rinominato se l’originale viene rinominato.
Nonostante le loro somiglianze, Amazon Redshift e RDS per PostgreSQL presentano differenze importanti. Le seguenti sezioni descrivono le risposte del sistema Amazon Redshift per le operazioni DDL comuni.
**Topics**
+ [operazioni database](#zero-etl.ddl-postgres-database)
+ [Operazioni dello schema](#zero-etl.ddl-postgres-schema)
+ [Operazioni sulle tabelle](#zero-etl.ddl-postgres-table)
### operazioni database
La tabella seguente mostra le risposte del sistema per le operazioni DDL del database.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/zero-etl.querying.html)
### Operazioni dello schema
La tabella seguente mostra le risposte del sistema per le operazioni DDL dello schema.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/zero-etl.querying.html)
### Operazioni sulle tabelle
La tabella seguente mostra le risposte del sistema per le operazioni DDL della tabella.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/zero-etl.querying.html)
# Visualizzazione e monitoraggio delle integrazioni Zero-ETL Amazon RDS
Puoi visualizzare i dettagli di un'integrazione Zero-ETL di Amazon RDS per visualizzarne le informazioni di configurazione e lo stato attuale. Puoi anche monitorare lo stato della tua integrazione eseguendo query sulle viste di sistema specifiche in Amazon Redshift. Inoltre, Amazon Redshift pubblica alcuni parametri relativi all'integrazione su Amazon, che puoi visualizzare all'interno della CloudWatch console Amazon Redshift.
**Topics**
+ [Visualizzazione delle integrazioni](#zero-etl.describing)
+ [Monitoraggio delle integrazioni tramite tabelle di sistema per Amazon Redshift](#zero-etl.monitoring)
+ [Monitoraggio delle integrazioni con Amazon EventBridge per Amazon Redshift](#zero-etl.eventbridge)
## Visualizzazione delle integrazioni
Puoi visualizzare le integrazioni zero-ETL di Amazon RDS utilizzando Console di gestione AWS l'API RDS o la AWS CLI.
### Console
**Visualizzazione dei dettagli di un'integrazione Zero-ETL**
1. Accedi a Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nel riquadro di navigazione a sinistra, scegli **Integrazioni Zero-ETL**.
1. Seleziona un’integrazione per visualizzarne ulteriori dettagli, ad esempio il database di origine e il data warehouse di destinazione.
![\[Dettagli relativi a un'integrazione Zero-ETL\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/zero-etl-integration-view.png)
Un'integrazione può avere i seguenti stati:
+ `Creating`: l'integrazione è in fase di creazione.
+ `Active`: l'integrazione sta inviando dati transazionali al data warehouse di destinazione.
+ `Syncing`: l'integrazione ha rilevato un errore recuperabile e deve reimpostare i dati. Le tabelle interessate non sono disponibili per l’esecuzione di query fino al termine della risincronizzazione.
+ `Needs attention`: l'integrazione ha rilevato un evento o un errore che richiede un intervento manuale per la risoluzione. Per correggere il problema, segui le istruzioni nel messaggio di errore nella pagina dei dettagli dell'integrazione.
+ `Failed`: l'integrazione ha rilevato un evento o un errore irreversibile che non può essere risolto. È necessario eliminare e ricreare l’integrazione.
+ `Deleting`: l'integrazione è in fase di eliminazione.
### AWS CLI
Per visualizzare tutte le integrazioni zero-ETL nell'account corrente utilizzando AWS CLI, usa il comando [describe-integrations e specifica l'opzione](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-integrations.html). `--integration-identifier`
**Example**
Per Linux, macOS o Unix:
```
aws rds describe-integrations \
--integration-identifier ee605691-6c47-48e8-8622-83f99b1af374
```
Per Windows:
```
aws rds describe-integrations ^
--integration-identifier ee605691-6c47-48e8-8622-83f99b1af374
```
### API RDS
Per visualizzare l'integrazione Zero-ETL utilizzando l'API Amazon RDS, usa l'operazione [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeIntegrations.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeIntegrations.html) con il parametro `IntegrationIdentifier`.
## Monitoraggio delle integrazioni tramite tabelle di sistema per Amazon Redshift
Amazon Redshift include tabelle e viste di sistema che contengono informazioni sul funzionamento del sistema. Puoi eseguire delle query su queste tabelle e viste esattamente come faresti con qualsiasi altra tabella di database. Per ulteriori informazioni sulle tabelle e viste di sistema in Amazon Redshift, consulta [Riferimento di tabelle e viste di sistema](https://docs.aws.amazon.com//redshift/latest/dg/cm_chap_system-tables.html) nella *Guida per sviluppatori di database di Amazon Redshift*.
Puoi eseguire query sulle seguenti viste e tabelle di sistema per ottenere informazioni sulle integrazioni Zero-ETL :
+ [SVV\$1INTEGRATION](https://docs.aws.amazon.com/redshift/latest/dg/r_SVV_INTEGRATION.html): fornisce i dettagli relativi alla configurazione delle integrazioni.
+ [SVV\$1INTEGRATION\$1TABLE\$1STATE](https://docs.aws.amazon.com/redshift/latest/dg/r_SVV_INTEGRATION_TABLE_STATE.html): descrive lo stato di ogni tabella all'interno di un'integrazione.
+ [SYS\$1INTEGRATION\$1TABLE\$1STATE\$1CHANGE](https://docs.aws.amazon.com/redshift/latest/dg/r_SYS_INTEGRATION_TABLE_STATE_CHANGE.html): visualizza i log delle modifiche dello stato della tabella per un'integrazione.
+ [SYS\$1INTEGRATION\$1ACTIVITY](https://docs.aws.amazon.com/redshift/latest/dg/r_SYS_INTEGRATION_ACTIVITY.html): fornisce informazioni sulle esecuzioni completate delle integrazioni.
Tutte le metriche Amazon relative all'integrazione provengono da CloudWatch Amazon Redshift. Per ulteriori informazioni, consulta [Metriche per le integrazioni Zero-ETL](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.monitoring.html) nella *Guida alla gestione di Amazon Redshift*. Attualmente, Amazon RDS Aurora non pubblica alcun parametro di integrazione su. CloudWatch
## Monitoraggio delle integrazioni con Amazon EventBridge per Amazon Redshift
Amazon Redshift invia eventi relativi all'integrazione ad Amazon. EventBridge *Per un elenco di eventi e l'evento corrispondente IDs, consulta Notifiche degli eventi di [integrazione Zero-ETL con Amazon EventBridge nella Amazon](https://docs.aws.amazon.com/redshift/latest/mgmt/integration-event-notifications) Redshift Management Guide.*
# Modifica delle integrazioni Zero-ETL Amazon RDS
È possibile modificare solo il nome, la descrizione e le opzioni di filtro dei dati per un’integrazione Zero-ETL in un data warehouse supportato. Non è possibile modificare la chiave AWS KMS utilizzata per crittografare l’integrazione o i database di origine o di destinazione.
Se aggiungi un filtro dati a un’integrazione esistente, Amazon RDS valuta nuovamente il filtro come se fosse sempre esistito. Rimuove tutti i dati attualmente presenti nel data warehouse di destinazione che non corrispondono ai nuovi criteri di filtro. Se *rimuovi* un filtro dati da un’integrazione, verranno replicati tutti i dati che in precedenza non corrispondevano ai criteri di filtro (ma che ora lo fanno) nel data warehouse di destinazione. Per ulteriori informazioni, consulta [Filtro dei dati per integrazioni Zero-ETL di Amazon RDS](zero-etl.filtering.md).
Puoi modificare un’integrazione Zero-ETL utilizzando la Console di gestione AWS, l’interfaccia AWS CLI o l’API Amazon RDS.
## console RDS
**Come modificare un’integrazione Zero-ETL**
1. Accedi alla Console di gestione AWS e apri la console Amazon RDS all’indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nel riquadro di navigazione, scegli **Integrazioni Zero-ETL**, quindi seleziona l’integrazione che desideri modificare.
1. Scegli **Modifica** e apporta modifiche a tutte le impostazioni disponibili.
1. Una volta apportate tutte le modifiche, seleziona **Modifica**.
## AWS CLI
Per modificare un’integrazione Zero-ETL utilizzando l’interfaccia AWS CLI, chiama il comando [modify-integration](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-integration.html). Oltre a `--integration-identifier`, specifica una delle seguenti opzioni:
+ `--integration-name`: specifica un nuovo nome per l’integrazione.
+ `--description`: specifica una nuova descrizione per l’integrazione.
+ `--data-filter`: specifica le opzioni di filtro dei dati per l’integrazione. Per ulteriori informazioni, consulta [Filtro dei dati per integrazioni Zero-ETL di Amazon RDS](zero-etl.filtering.md).
**Example**
La richiesta seguente modifica un’integrazione esistente.
Per Linux, macOS o Unix:
```
aws rds modify-integration \
--integration-identifier ee605691-6c47-48e8-8622-83f99b1af374 \
--integration-name my-renamed-integration
```
Per Windows:
```
aws rds modify-integration ^
--integration-identifier ee605691-6c47-48e8-8622-83f99b1af374 ^
--integration-name my-renamed-integration
```
## API RDS
Per modificare un’integrazione Zero-ETL utilizzando l’API RDS, chiama l’operazione [ModifyIntegration](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyIntegration.html). Specifica l’identificatore di integrazione e i parametri che desideri modificare.
# Eliminazione delle integrazioni Zero-ETL Amazon RDS
Quando elimini un’integrazione Zero-ETL, Amazon RDS la rimuove dal database di origine. I dati transazionali non vengono eliminati da Amazon RDS o dalla destinazione di analisi, ma Amazon RDS, ma non invia nuovi dati ad Amazon Redshift o Amazon SageMaker.
È possibile eliminare un’integrazione solo quando ha lo stato `Active`, `Failed`, `Syncing` o `Needs attention`.
È possibile eliminare le integrazioni Zero-ETL utilizzando la Console di gestione AWS, l’interfaccia AWS CLI o l’API RDS.
## Console
**Eliminazione di un'integrazione Zero-ETL**
1. Accedi alla Console di gestione AWS e apri la console Amazon RDS all’indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nel riquadro di navigazione a sinistra, scegli **Integrazioni Zero-ETL**.
1. Seleziona l'integrazione Zero-ETL che desideri eliminare.
1. Scegli **Operazioni**, **Elimina dominio**, quindi conferma l'eliminazione.
## AWS CLI
Per eliminare un'integrazione Zero-ETL, usa il comando [delete-integration](https://docs.aws.amazon.com/cli/latest/reference/rds/delete-integration.html) e specifica l'opzione `--integration-identifier`.
**Example**
Per Linux, macOS o Unix:
```
aws rds delete-integration \
--integration-identifier ee605691-6c47-48e8-8622-83f99b1af374
```
Per Windows:
```
aws rds delete-integration ^
--integration-identifier ee605691-6c47-48e8-8622-83f99b1af374
```
## API RDS
Per eliminare un'integrazione Zero-ETL utilizzando l'API Amazon RDS, usa l'operazione [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DeleteIntegration.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DeleteIntegration.html) con il parametro `IntegrationIdentifier`.
# Risoluzione dei problemi delle integrazioni Zero-ETL di Amazon RDS
Puoi verificare lo stato di un’integrazione Zero-ETL eseguendo query sulla tabella di sistema [SVV\$1INTEGRATION](https://docs.aws.amazon.com/redshift/latest/dg/r_SVV_INTEGRATION.html) nella destinazione di analisi. Se la colonna `state` include il valore `ErrorState`, significa che si è verificato un problema. Per ulteriori informazioni, consulta [Monitoraggio delle integrazioni tramite tabelle di sistema per Amazon Redshift](zero-etl.describingmonitoring.md#zero-etl.monitoring).
Usa le seguenti informazioni per risolvere i problemi comuni con le integrazioni Zero-ETL di Amazon RDS.
**Importante**
Le operazioni di risincronizzazione e aggiornamento non sono disponibili per le integrazioni Zero-ETL con un Amazon SageMaker AI Lakehouse. In caso di problemi con un’integrazione, è necessario eliminare l’integrazione e crearne una nuova. Non è possibile aggiornare né risincronizzare un’integrazione esistente.
**Topics**
+ [Non riesco a creare un’integrazione Zero-ETL](#zero-etl.troubleshooting.creation)
+ [La mia integrazione è bloccata in uno stato di `Syncing`](#zero-etl.troubleshooting.syncing)
+ [Le mie tabelle non si replicano su Amazon Redshift](#zero-etl.troubleshooting.primarykey)
+ [Una o più tabelle Amazon Redshift richiedono una risincronizzazione](#zero-etl.troubleshooting.resync)
+ [Problemi di integrazione non riusciti per le integrazioni Amazon SageMaker AI Lakehouse Zero-ETL](#zero-etl.troubleshooting.integration-issues)
## Non riesco a creare un’integrazione Zero-ETL
Se non riesci a creare un’integrazione Zero-ETL, assicurati che quanto segue sia corretto per il database di origine:
+ Il database di origine deve eseguire una versione del motore di database supportata. Per un elenco delle versioni supportate, consulta [Regioni e motori di database supportati per le integrazioni Zero-ETL di Amazon RDS](Concepts.RDS_Fea_Regions_DB-eng.Feature.ZeroETL.md).
+ I parametri del database sono stati configurati correttamente. Se i parametri obbligatori sono impostati in modo errato o non sono associati al database, la creazione ha esito negativo. Per informazioni, consulta [Fase 1: creazione di un gruppo di parametri del di database personalizzato](zero-etl.setting-up.md#zero-etl.parameters).
Inoltre, assicurati che quanto segue sia corretto per il data warehouse di destinazione:
+ È abilitata la distinzione tra maiuscole e minuscole. Consulta [Attivazione della distinzione tra maiuscole e minuscole per il data warehouse](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.setting-up.html#zero-etl-setting-up.case-sensitivity).
+ Hai aggiunto il principale autorizzato e l’origine dell’integrazione corretti. Consulta l’articolo [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).
+ Il data warehouse è crittografato (se si tratta di un cluster con provisioning). Consulta l’articolo [Crittografia dei database di Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-db-encryption.html).
## La mia integrazione è bloccata in uno stato di `Syncing`
L’integrazione potrebbe mostrare costantemente uno stato di `Syncing` se modifichi il valore di uno dei parametri richiesti per il database.
Per risolvere questo problema, controlla i valori dei parametri nel gruppo di parametri associato al database di origine e assicurati che corrispondano ai valori richiesti. Per ulteriori informazioni, consulta [Fase 1: creazione di un gruppo di parametri del di database personalizzato](zero-etl.setting-up.md#zero-etl.parameters).
Se modifichi qualsiasi parametro, assicurati di riavviare il database per applicare le modifiche apportate.
## Le mie tabelle non si replicano su Amazon Redshift
Se una o più tabelle non sono riflesse in Amazon Redshift, è possibile eseguire il comando riportato di seguito per risincronizzarle:
```
ALTER DATABASE dbname INTEGRATION REFRESH TABLES table1, table2;
```
Per ulteriori informazioni, consulta [ALTER DATABASE](https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_DATABASE.html) nella Referenza SQL di Amazon Redshift.
È possibile che i dati non vengano replicati perché una o più tabelle di origine non dispongono di una chiave primaria. La dashboard di monitoraggio in Amazon Redshift visualizza lo stato di queste tabelle come `Failed` e lo stato dell’integrazione Zero-ETL complessiva diventa `Needs attention`. Per risolvere questo problema, puoi identificare una chiave esistente nella tabella che può diventare una chiave primaria oppure puoi aggiungere una chiave primaria sintetica. Per soluzioni dettagliate, consulta [Handle tables without primary keys while creating Amazon Aurora MySQL or Amazon RDS per MySQL zero-ETL integrations with Amazon Redshift](https://aws.amazon.com/blogs/database/handle-tables-without-primary-keys-while-creating-amazon-aurora-mysql-or-amazon-rds-for-mysql-zero-etl-integrations-with-amazon-redshift/).
## Una o più tabelle Amazon Redshift richiedono una risincronizzazione
L’esecuzione di determinati comandi sul database di origine potrebbe richiedere la risincronizzazione delle tabelle. In questi casi, la vista di sistema [SVV\$1INTEGRATION\$1TABLE\$1STATE](https://docs.aws.amazon.com/redshift/latest/dg/r_SVV_INTEGRATION_TABLE_STATE.html) mostra un valore di `table_state` pari a `ResyncRequired`, il che significa che l’integrazione deve ricaricare completamente i dati di quella tabella specifica da MySQL in Amazon Redshift.
Quando viene avviata la risincronizzazione della tabella, lo stato diventa `Syncing`. Non è necessario eseguire alcuna azione manuale per risincronizzare una tabella. Non potrai accedere ai dati della tabella in Amazon Redshift mentre è in esecuzione la loro risincronizzazione.
Di seguito sono riportati alcuni esempi di operazioni che possono modificare lo stato di una tabella in `ResyncRequired` e le possibili alternative da considerare.
| Operation | Esempio | In alternativa |
| --- | --- | --- |
| Aggiunta di una colonna in una posizione specifica | ALTER TABLE table_name
ADD COLUMN column_name INTEGER
NOT NULL first;
| Amazon Redshift non supporta l’aggiunta di colonne in posizioni specifiche utilizzando le parole chiave first o after. Se l’ordine delle colonne nella tabella di destinazione non è rilevante, aggiungi la colonna alla fine della tabella utilizzando un comando più semplice:ALTER TABLE table_name
ADD COLUMN column_name column_type;
|
| Aggiunta di una colonna timestamp con il valore predefinito CURRENT\$1TIMESTAMP | ALTER TABLE table_name
ADD COLUMN column_name TIMESTAMP
NOT NULL DEFAULT CURRENT_TIMESTAMP;
| Il valore CURRENT\$1TIMESTAMP per le righe tabelle esistenti viene calcolato da RDS per MySQL e non può essere simulato in Amazon Redshift senza eseguire la risincronizzazione completa dei dati della tabella. Se possibile, converti il valore predefinito in una costante letterale, ad esempio `2023-01-01 00:00:15`, per evitare la latenza a livello di disponibilità della tabella. |
| Esecuzione di operazioni su più colonne all’interno di un unico comando | ALTER TABLE table_name
ADD COLUMN column_1,
RENAME COLUMN column_2 TO column_3;
| Prendi in considerazione la possibilità di suddividere il comando in due operazioni distinte, ADD e RENAME, che non richiedono la risincronizzazione. |
## Problemi di integrazione non riusciti per le integrazioni Amazon SageMaker AI Lakehouse Zero-ETL
Se riscontri problemi con un'integrazione zero-ETL esistente con un Amazon SageMaker AI lakehouse, l'unica soluzione è eliminare l'integrazione e crearne una nuova. A differenza di altri AWS servizi, le integrazioni zero-ETL non supportano le operazioni di aggiornamento o risincronizzazione.
Per risolvere i problemi di integrazione:
1. Elimina l’integrazione Zero-ETL problematica utilizzando la console, l’interfaccia a riga di comando o l’API.
1. Verifica che le configurazioni del database di origine e del data warehouse di destinazione siano corrette.
1. Crea una nuova integrazione Zero-ETL con la stessa configurazione o con una configurazione aggiornata.
Questo processo comporterà una reinizializzazione completa della pipeline di dati, che potrebbe richiedere del tempo a seconda delle dimensioni del database di origine.