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à. # Filtro dei dati per integrazioni Zero-ETL di Aurora Le integrazioni Zero-ETL di Aurora supportano il filtro dei dati, che consente di controllare quali dati vengono replicati dal cluster di database Aurora 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ù cluster di origine diversi e non hai bisogno dei dati completi da ciascun cluster. + 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 Aurora MySQL](#zero-etl.filtering-examples-mysql) + [Esempi di Aurora PostgreSQL](#zero-etl.filtering-examples-postgres) + [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 Aurora 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 Aurora MySQL oppure nel formato `database.schema.table` per Aurora PostgreSQL. Puoi specificare nomi letterali o definire espressioni regolari. Per Aurora MySQL, le espressioni regolari sono supportate sia nel nome del database sia in quello della tabella. Per Aurora 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 cluster di database di origine Aurora 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 Aurora MySQL nella console: ![\[Filtri dei dati per un’integrazione Zero-ETL\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/AuroraUserGuide/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`: **Aurora MySQL** ``` mydb.mytable, mydb./table_\d+/ ``` **Aurora PostgreSQL** ``` mydb.myschema.mytable, mydb.myschema./table_\d+/ ``` Tuttavia, quando si utilizza il AWS CLI, lo stesso filtro dati deve avere il seguente formato: **Aurora MySQL** ``` 'include: mydb.mytable, include: mydb./table_\d+/' ``` **Aurora PostgreSQL** ``` 'include: mydb.myschema.mytable, include: mydb.myschema./table_\d+/' ``` ## Logica dei filtri Se non specifichi alcun filtro dei dati nell’integrazione, Aurora 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' ``` Aurora valuta il filtro come indicato di seguito: ``` 'exclude:*.*, include: db.table1, include: db.table2' ``` Pertanto, Aurora esegue la replica di `table1` e `table2` dal database denominato `db` al data warehouse di destinazione. ## Precedenza dei filtri Aurora 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. Aurora valuta questi modelli di filtro nell’ordine in cui li specifichi, quindi un modello potrebbe sovrascrivere quello specificato in precedenza. ## Esempi di Aurora MySQL Gli esempi seguenti mostrano come funziona il filtro dei dati per le integrazioni Zero-ETL di Aurora 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 Aurora PostgreSQL Gli esempi seguenti mostrano come funziona il filtro dei dati per le integrazioni Zero-ETL di Aurora 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' ``` ## 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, Aurora 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/AuroraUserGuide/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, Aurora 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.