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à.
# Creazione di oggetti in AWS Glue Data Catalog
AWS Lake Formation utilizza AWS Glue Data Catalog (Data Catalog) per archiviare metadati su data lake, origini dati, trasformazioni e destinazioni. I metadati sono dati relativi ai dati sottostanti nel set di dati. Ogni AWS account dispone di un catalogo dati per regione. AWS
I metadati nel Data Catalog sono organizzati in una gerarchia di dati a tre livelli che comprende cataloghi, database e tabelle. Organizza i dati provenienti da varie fonti in contenitori logici chiamati cataloghi. Ogni catalogo rappresenta dati provenienti da fonti come data warehouse Amazon Redshift, Amazon DynamoDB database e fonti di dati di terze parti come Snowflake, MySQL e oltre 30 fonti di dati esterne, integrate tramite connettori federati. Puoi anche creare nuovi cataloghi nel Data Catalog per archiviare i dati in S3 Table Bucket o Redshift Managed Storage (RMS).
Le tabelle memorizzano informazioni sui dati sottostanti, tra cui informazioni sullo schema, sulle partizioni e sulla posizione dei dati. I database sono raccolte di tabelle. Il Data Catalog contiene anche collegamenti a risorse, che sono collegamenti a cataloghi, database e tabelle condivisi in account esterni e vengono utilizzati per l'accesso tra account diversi ai dati nel data lake.
Il Data Catalog è un oggetto di catalogo annidato che contiene cataloghi, database e tabelle. È referenziato dall' Account AWS ID ed è il catalogo predefinito in un account e in un. Regione AWS Il Data Catalog utilizza una gerarchia a tre livelli (catalog.database.table) per organizzare le tabelle.
+ Catalogo: il livello più alto della gerarchia dei metadati a tre livelli di Data Catalog. È possibile aggiungere più cataloghi in un Data Catalog tramite la federazione.
+ Database: il secondo livello della gerarchia dei metadati che comprende tabelle e viste. Un database viene anche definito schema in molti sistemi di dati come Amazon Redshift e Trino.
+ Tabella e visualizzazione: il terzo livello della gerarchia dei dati a 3 livelli del Data Catalog.
Tutte le tabelle Iceberg in Amazon S3 sono archiviate nel Data Catalog predefinito con Catalog ID = ID Account AWS . Puoi creare cataloghi federati in AWS Glue Data Catalog cui archiviare le definizioni delle tabelle in Amazon Redshift, Amazon S3 Table Storage o altre fonti di dati di terze parti tramite la federazione.
**Topics**
+ [
# Creare un catalogo
](creating-catalog.md)
+ [
# Creazione di un database
](creating-database.md)
+ [
# Creazione di tabelle
](creating-tables.md)
+ [
# AWS Glue Data Catalog Viste dell'edificio
](working-with-views.md)
# Creare un catalogo
I cataloghi rappresentano il livello più alto o più alto nella gerarchia dei metadati a tre livelli di. AWS Glue Data CatalogÈ possibile utilizzare diversi metodi per inserire i dati nel Data Catalog e creare cataloghi a più livelli.
Per ulteriori informazioni sulla creazione di cataloghi da fonti di dati esterne, consulta. [Inserire i dati nel AWS Glue Data Catalog](bring-your-data-overview.md)
Per creare un catalogo utilizzando la console Lake Formation, devi accedere come amministratore del data lake o *creatore di cataloghi*. Un creatore di cataloghi è un preside a cui è stata concessa l'`CREATE_CATALOG`autorizzazione Lake Formation. Puoi vedere un elenco dei creatori del catalogo nella pagina **Ruoli e attività amministrative** della console Lake Formation. Per visualizzare questo elenco, devi disporre dell'autorizzazione `lakeformation:ListPermissions` IAM ed essere registrato come amministratore del data lake o come creatore di cataloghi con l'opzione di concessione sull'`CREATE_CATALOG`autorizzazione.
# Creazione di un database
Le tabelle di metadati nel Data Catalog sono archiviate all'interno di database. Puoi creare tutti i database di cui hai bisogno e puoi concedere diverse autorizzazioni Lake Formation su ciascun database.
I database possono avere una proprietà di localizzazione opzionale. Questa sede si trova in genere all'interno di una sede Amazon Simple Storage Service (Amazon S3) registrata presso Lake Formation. Quando specifichi una posizione, i responsabili non necessitano delle autorizzazioni per la localizzazione dei dati per creare tabelle Data Catalog che puntano a posizioni all'interno della posizione del database. Per ulteriori informazioni, consulta [Underlying data access control](access-control-underlying-data.md#data-location-permissions).
Per creare un database utilizzando la console Lake Formation, devi accedere come amministratore del data lake o *creatore del database*. Un creatore di database è un responsabile a cui è stata concessa l'`CREATE_DATABASE`autorizzazione Lake Formation. Puoi vedere un elenco dei creatori di database nella pagina **Ruoli e attività amministrative** della console Lake Formation. Per visualizzare questo elenco, è necessario disporre dell'autorizzazione `lakeformation:ListPermissions` IAM e accedere come amministratore del data lake o come creatore di database con l'opzione di concessione sull'`CREATE_DATABASE`autorizzazione.
**Come creare un database**
1. Apri la AWS Lake Formation console all'indirizzo [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/)e accedi come amministratore del data lake o creatore di database.
1. Nel riquadro di navigazione, in **Catalogo dati**, scegli **Database**.
1. Scegliere **Crea database**.
1. Nella finestra di dialogo **Crea database**, inserisci un nome di database, una posizione opzionale e una descrizione facoltativa.
1. Facoltativamente, seleziona **Usa solo il controllo di accesso IAM per le nuove tabelle in questo database**.
Per ulteriori informazioni su questa opzione, consulta [Modifica delle impostazioni predefinite per il data lake](change-settings.md).
1. Scegliere **Crea database**.
# Creazione di tabelle
AWS Lake Formation le tabelle di metadati contengono informazioni sui dati nel data lake, incluse informazioni sullo schema, sulle partizioni e sulla posizione dei dati. Queste tabelle sono archiviate nel AWS Glue Data Catalog. Li usi per accedere ai dati sottostanti nel data lake e gestirli con le autorizzazioni di Lake Formation. Le tabelle vengono archiviate all'interno dei database del Data Catalog.
Esistono diversi modi per creare tabelle Data Catalog:
+ Esegui un crawler. AWS Glue *Vedi [Definizione dei crawler nella Guida per gli](https://docs.aws.amazon.com/glue/latest/dg/add-crawler.html) sviluppatori.AWS Glue *
+ Crea ed esegui un flusso di lavoro. Per informazioni, consulta [Importazione di dati utilizzando i flussi di lavoro in Lake Formation](workflows.md).
+ Crea una tabella manualmente utilizzando la console di Lake Formation, AWS Glue l'API o AWS Command Line Interface (AWS CLI).
+ Crea una tabella utilizzando Amazon Athena.
+ Crea un collegamento di risorsa a una tabella in un account esterno. Per informazioni, consulta [Creazione di collegamenti alle risorse](creating-resource-links.md).
# Creazione di tabelle Apache Iceberg
AWS Lake Formation supporta la creazione di tabelle Apache Iceberg che utilizzano il formato di dati Apache Parquet AWS Glue Data Catalog con dati che risiedono in Amazon S3. Una tabella nel catalogo dati è la definizione dei metadati che rappresenta i dati in un datastore. Per impostazione predefinita, Lake Formation crea tabelle Iceberg v2. Per la differenza tra le tabelle v1 e v2, consulta [Modifiche al tipo di formato](https://iceberg.apache.org/spec/#appendix-e-format-version-changes) nella documentazione di Apache Iceberg.
[Apache Iceberg](https://iceberg.apache.org/) è un formato a tabella aperta per set di dati analitici di dimensioni molto grandi. Iceberg consente di modificare facilmente lo schema, operazione nota anche come evoluzione dello schema, il che significa che gli utenti possono aggiungere, rinominare o rimuovere colonne da una tabella di dati senza pregiudicare i dati sottostanti. Iceberg fornisce anche supporto per il controllo delle versioni dei dati, che consente agli utenti di tenere traccia delle modifiche apportate ai dati nel tempo. Ciò abilita la funzionalità di query temporale, che consente agli utenti di accedere e interrogare le versioni storiche dei dati e analizzare le modifiche ai dati tra aggiornamenti ed eliminazioni.
Puoi utilizzare la console Lake Formation o l'`CreateTable`operazione nell' AWS Glue API per creare una tabella Iceberg nel Data Catalog. Per ulteriori informazioni, vedere [CreateTable action (Python: create\$1table](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-tables.html#aws-glue-api-catalog-tables-CreateTable)).
Quando si crea una tabella Iceberg nel catalogo dati, occorre specificare il formato della tabella e il percorso del file dei metadati in Amazon S3 per poter eseguire letture e scritture.
Puoi usare Lake Formation per proteggere la tua tabella Iceberg utilizzando autorizzazioni di controllo degli accessi granulari quando registri la posizione dati di Amazon S3 con. AWS Lake Formation Per i dati di origine in Amazon S3 e i metadati non registrati con Lake Formation, l'accesso è determinato dalle politiche di autorizzazione IAM per Amazon S3 e dalle azioni. AWS Glue Per ulteriori informazioni, consulta [Gestione delle autorizzazioni di Lake Formation](managing-permissions.md).
**Nota**
Il catalogo dati non supporta la creazione di partizioni e l'aggiunta di proprietà delle tabelle Iceberg.
**Topics**
+ [
## Prerequisiti
](#iceberg-prerequisites)
+ [
## Creazione di una tabella Iceberg
](#create-iceberg-table)
## Prerequisiti
Per creare tabelle Iceberg nel catalogo dati e configurare le autorizzazioni di accesso ai dati di Lake Formation, occorre soddisfare i seguenti requisiti:
1.
**Autorizzazioni richieste per creare tabelle Iceberg senza i dati registrati con Lake Formation.**
Oltre alle autorizzazioni richieste per creare una tabella nel catalogo dati, il creatore della tabella richiede le seguenti autorizzazioni:
+ `s3:PutObject` sulla risorsa arn:aws:s3:::\$1bucketName\$1
+ `s3:GetObject` sulla risorsa arn:aws:s3:::\$1bucketName\$1
+ `s3:DeleteObject` sulla risorsa arn:aws:s3:::\$1bucketName\$1
1.
**Autorizzazioni richieste per creare tabelle Iceberg con dati registrati con Lake Formation:**
Per utilizzare Lake Formation per gestire e proteggere i dati nel data lake, registrare la posizione Amazon S3 che contiene i dati per le tabelle con Lake Formation. In questo modo Lake Formation può fornire credenziali a servizi di AWS analisi come Athena, Redshift Spectrum e Amazon EMR per accedere ai dati. Per ulteriori informazioni sulla registrazione di una sede Amazon S3, consulta. [Aggiungere una posizione Amazon S3 al tuo data lake](register-data-lake.md)
Un principale che legge e scrive i dati sottostanti registrati con Lake Formation richiede le seguenti autorizzazioni:
+ `lakeformation:GetDataAccess`
+ `DATA_LOCATION_ACCESS`
Un principale che dispone di autorizzazioni di localizzazione dei dati in una sede dispone anche delle autorizzazioni di localizzazione su tutte le sedi secondarie.
Per ulteriori informazioni sulle autorizzazioni relative alla localizzazione dei dati, consulta. [Controllo sottostante dell'accesso ai dati](access-control-underlying-data.md)
Per abilitare la compattazione, il servizio deve assumere un ruolo IAM con le autorizzazioni per aggiornare le tabelle nel catalogo dati. Per i dettagli, consulta [Prerequisiti per l'ottimizzazione delle tabelle](https://docs.aws.amazon.com/glue/latest/dg/optimization-prerequisites.html).
## Creazione di una tabella Iceberg
Puoi creare tabelle Iceberg v1 e v2 utilizzando la console Lake Formation o AWS Command Line Interface come documentato in questa pagina. Puoi anche creare tabelle Iceberg usando la console o. AWS Glue Crawler di AWS Glue Per ulteriori informazioni, consultare [Catalogo dati e crawler](https://docs.aws.amazon.com/glue/latest/dg/catalog-and-crawler.html) nella Guida per gli sviluppatori di AWS Glue .
**Per creare una tabella Iceberg**
------
#### [ Console ]
1. Accedi a Console di gestione AWS, e apri la console Lake Formation all'indirizzo [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).
1. In catalogo dati, scegliere **Tabelle** e utilizzare il pulsante **Crea tabella** per specificare i seguenti attributi:
+ **Nome tabella**: inserisci un nome per la tabella. Se si utilizza Athena per accedere alle tabelle, utilizzare questi [suggerimenti per la denominazione](https://docs.aws.amazon.com/athena/latest/ug/tables-databases-columns-names.html) della Guida per l'utente di Amazon Athena.
+ **Database**: scegli un database esistente o creane uno nuovo.
+ **Descrizione: la descrizione della** tabella. È possibile scrivere una descrizione per aiutare a comprendere i contenuti della tabella.
+ **Formato tabella: per il formato** **tabella**, scegli Apache Iceberg.
![\[Opzione di tabella Apache Iceberg selezionata con opzioni di ottimizzazione della tabella.\]](http://docs.aws.amazon.com/it_it/lake-formation/latest/dg/images/table-optimization.png)
+ **Ottimizzazione della tabella**
+ **Compattazione**: I file di dati vengono uniti e riscritti per rimuovere i dati obsoleti e consolidare i dati frammentati in file più grandi ed efficienti.
+ **Conservazione degli snapshot**: gli snapshot sono versioni con data e ora di una tabella Iceberg. Le configurazioni di conservazione degli snapshot consentono ai clienti di stabilire per quanto tempo conservare gli snapshot e quanti snapshot conservare. La configurazione di un ottimizzatore di conservazione degli snapshot può aiutare a gestire il sovraccarico di archiviazione rimuovendo gli snapshot più vecchi e non necessari e i relativi file sottostanti.
+ **Eliminazione di file orfani**: i file orfani sono file a cui non fanno più riferimento i metadati della tabella Iceberg. Questi file possono accumularsi nel tempo, soprattutto dopo operazioni come l'eliminazione di tabelle o i processi ETL non riusciti. L'abilitazione dell'eliminazione dei file orfani AWS Glue consente di identificare e rimuovere periodicamente questi file non necessari, liberando spazio di archiviazione.
Per ulteriori informazioni, consulta [Ottimizzazione delle tabelle Iceberg](https://docs.aws.amazon.com/glue/latest/dg/table-optimizers.html).
+ **Ruolo IAM**: per eseguire la compattazione, il servizio assume un ruolo IAM per conto dell'utente. Puoi scegliere un ruolo IAM utilizzando il menu a discesa. Assicurati che il ruolo disponga delle autorizzazioni necessarie per abilitare la compattazione.
Per ulteriori informazioni sulle autorizzazioni richieste, consulta Prerequisiti per l'ottimizzazione delle [tabelle.](https://docs.aws.amazon.com/glue/latest/dg/optimization-prerequisites.html)
+ **Posizione**: specifica il percorso della cartella in Amazon S3 che memorizza la tabella dei metadati. Iceberg ha bisogno di un file di metadati e di una posizione nel catalogo dati per poter eseguire letture e scritture.
+ **Schema**: scegli **Aggiungi colonne** per aggiungere colonne e tipi di dati delle colonne. Si dispone della possibilità di creare una tabella vuota e di aggiornare lo schema in un secondo momento. Il catalogo dati supporta i tipi di dati Hive. Per ulteriori informazioni, consultare [Tipi di dati Hive](https://cwiki.apache.org/confluence/plugins/servlet/mobile?contentId=27838462#content/view/27838462).
Iceberg consente di evolvere lo schema e la partizione dopo aver creato la tabella. È possibile usare le [query di Athena](https://docs.aws.amazon.com/athena/latest/ug/querying-iceberg-evolving-table-schema.html) per aggiornare lo schema della tabella e le [query Spark](https://iceberg.apache.org/docs/latest/spark-ddl/#alter-table-sql-extensions) per aggiornare le partizioni.
------
#### [ AWS CLI ]
```
aws glue create-table \
--database-name iceberg-db \
--region us-west-2 \
--open-table-format-input '{
"IcebergInput": {
"MetadataOperation": "CREATE",
"Version": "2"
}
}' \
--table-input '{"Name":"test-iceberg-input-demo",
"TableType": "EXTERNAL_TABLE",
"StorageDescriptor":{
"Columns":[
{"Name":"col1", "Type":"int"},
{"Name":"col2", "Type":"int"},
{"Name":"col3", "Type":"string"}
],
"Location":"s3://DOC_EXAMPLE_BUCKET_ICEBERG/"
}
}'
```
------
# Ottimizzazione delle tabelle Iceberg
Lake Formation supporta diverse opzioni di ottimizzazione delle tabelle per migliorare la gestione e le prestazioni delle tabelle Apache Iceberg utilizzate dai motori AWS analitici e dai job ETL. Questi ottimizzatori offrono un utilizzo efficiente dello storage, prestazioni di query migliorate e una gestione efficace dei dati. In Lake Formation sono disponibili tre tipi di ottimizzatori di tabelle:
+ **Compattazione**: la compattazione dei dati compatta file di dati di piccole dimensioni per ridurre l'utilizzo dell'archiviazione e migliorare le prestazioni di lettura. I file di dati vengono uniti e riscritti per rimuovere i dati obsoleti e consolidare i dati frammentati in file più grandi ed efficienti. La compattazione può essere configurata per funzionare automaticamente o attivata manualmente secondo necessità.
+ **Conservazione degli snapshot**: gli snapshot sono versioni con data e ora di una tabella Iceberg. Le configurazioni di conservazione degli snapshot consentono ai clienti di stabilire per quanto tempo conservare gli snapshot e quanti snapshot conservare. La configurazione di un ottimizzatore di conservazione degli snapshot può aiutare a gestire il sovraccarico di archiviazione rimuovendo gli snapshot più vecchi e non necessari e i relativi file sottostanti.
+ **Eliminazione di file orfani**: i file orfani sono file a cui non fanno più riferimento i metadati della tabella Iceberg. Questi file possono accumularsi nel tempo, soprattutto dopo operazioni come l'eliminazione di tabelle o i processi ETL non riusciti. L'abilitazione dell'eliminazione dei file orfani consente di AWS Glue identificare e rimuovere periodicamente questi file non necessari, liberando spazio di archiviazione.
Puoi abilitare o disabilitare gli ottimizzatori di compattazione, conservazione delle istantanee e eliminazione dei file orfani per le singole tabelle Iceberg nel Data Catalog utilizzando la console o le AWS Glue operazioni API. AWS CLI AWS Glue
Per ulteriori informazioni, consulta [Optimizing Iceberg](https://docs.aws.amazon.com/glue/latest/dg/table-optimizers.html) tables nella Developer Guide. AWS Glue
# Ricerca di tabelle
Puoi usare la AWS Lake Formation console per cercare le tabelle del Data Catalog per nome, posizione, database contenente e altro. I risultati della ricerca mostrano solo le tabelle per le quali disponi delle autorizzazioni Lake Formation.
**Per cercare tabelle (console)**
1. Accedi a Console di gestione AWS e apri la console Lake Formation all'indirizzo [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).
1. Nel pannello di navigazione, seleziona **Tabelle**.
1. Posiziona il cursore nel campo di ricerca nella parte superiore della pagina. Il campo ha il testo segnaposto *Trova tabella per proprietà.*
Viene visualizzato il menu **Proprietà**, che mostra le varie proprietà della tabella in base alle quali effettuare la ricerca.
![\[Il menu delle proprietà viene visualizzato dal campo di ricerca e contiene le seguenti voci: Nome, Classificazione, Database, Ubicazione, ID catalogo\]](http://docs.aws.amazon.com/it_it/lake-formation/latest/dg/images/search-for-tables.png)
1. Esegui una delle seguenti operazioni:
+ Ricerca per database contenente.
1. Scegli **Database** dal menu **Proprietà**, quindi scegli un database dal menu **Database** visualizzato oppure digita il nome del database e premi **Invio**.
Vengono elencate le tabelle per le quali disponi delle autorizzazioni nel database.
1. **(Facoltativo) Per restringere l'elenco a una singola tabella del database, posizionate nuovamente il cursore nel campo di ricerca, scegliete **Nome** dal menu **Proprietà** e scegliete il nome di una tabella dal menu **Tabelle** visualizzato oppure digitate un nome di tabella e premete Invio.**
Viene elencata la singola tabella e sia il nome del database che il nome della tabella vengono visualizzati come riquadri sotto il campo di ricerca.
![\[Sotto il campo di ricerca ci sono due riquadri: uno etichettato Database, che include il nome del database selezionato, e uno etichettato Table, che include il nome della tabella selezionata. A destra dei riquadri c'è un pulsante Cancella filtro.\]](http://docs.aws.amazon.com/it_it/lake-formation/latest/dg/images/search-for-tables-with-filter.png)
Per regolare il filtro, chiudi uno dei riquadri o scegli **Cancella filtro**.
+ Cerca per altre proprietà.
1. Scegliete una proprietà di ricerca dal menu **Proprietà**.
**Per eseguire la ricerca in base all'ID AWS dell'account, scegliete **ID catalogo** dal menu **Proprietà**, immettete un ID AWS account valido (ad esempio, 111122223333) e premete Invio.**
Per effettuare una ricerca per località, scegli **Posizione** dal menu **Proprietà** e seleziona una località dal menu **Posizioni** visualizzato. Vengono restituite tutte le tabelle nella posizione principale della posizione selezionata (ad esempio, Amazon S3).
**Ricerca nelle tabelle utilizzando AWS CLI**
+ L'esempio seguente mostra come eseguire una ricerca parziale. Il `--search-text` parametro consente di cercare tabelle che contengono il testo specificato nei relativi metadati. In questo caso, restituisce tutte le tabelle che contengono «cliente» nel nome, nella descrizione o in altri campi di metadati.
```
aws glue search-tables
--search-text "customer"
--region Regione AWS
--max-results 10
--sort-criteria "FieldName=Name,Sort=ASC"
```
# Condivisione di tabelle e database del Data Catalog tra più account AWS
Puoi condividere le risorse del Data Catalog (database e tabelle) con AWS account esterni concedendo le autorizzazioni di Lake Formation sulle risorse agli account esterni. Gli utenti possono quindi eseguire query e lavori che uniscono e interrogano tabelle su più account. Con alcune restrizioni, quando condividi una risorsa del Catalogo dati con un altro account, i responsabili di quell'account possono utilizzare quella risorsa come se la risorsa fosse nel loro Catalogo dati.
Non condividi le risorse con responsabili specifici negli AWS account esterni, ma con un account o un'organizzazione. AWS Quando condividi una risorsa con un' AWS organizzazione, la condividi con tutti gli account a tutti i livelli dell'organizzazione. L'amministratore del data lake di ogni account esterno deve quindi concedere le autorizzazioni sulle risorse condivise ai responsabili del proprio account.
Per ulteriori informazioni, consultare [Condivisione dei dati tra account in Lake Formation](cross-account-permissions.md) e [Concessione delle autorizzazioni per le risorse del Data Catalog](granting-catalog-permissions.md).
**Consulta anche:**
[Accesso e visualizzazione di tabelle e database di Data Catalog condivisi](viewing-shared-resources.md)
[Prerequisiti](cross-account-prereqs.md)
# AWS Glue Data Catalog Viste dell'edificio
In AWS Glue Data Catalog, una *vista* è una tabella virtuale in cui i contenuti sono definiti da una query SQL che fa riferimento a una o più tabelle. Puoi creare una vista del catalogo dati che faccia riferimento a un massimo di 10 tabelle utilizzando editor SQL per Amazon Athena, Amazon Redshift o Apache Spark utilizzando EMR Serverless o la versione 5.0. AWS Glue Le tabelle di riferimento sottostanti per una vista possono appartenere allo stesso database o a database diversi all'interno dello stesso Data Catalog. Account AWS
Puoi fare riferimento a AWS Glue tabelle e tabelle standard in formati di tabelle aperte (OTF) come [Apache Hudi](https://hudi.incubator.apache.org/), Linux Foundation [Delta Lake](https://delta.io/) e [Apache Iceberg](https://iceberg.apache.org/), con i dati sottostanti archiviati in posizioni Amazon S3 registrati con. AWS Lake Formation Inoltre, puoi creare viste da tabelle federate da condivisioni di dati Amazon Redshift condivise con Lake Formation.
## Differenziazione delle viste del Data Catalog da altri tipi di visualizzazione
Le visualizzazioni del catalogo dati sono diverse da quelle di Apache Hive, Apache Spark e Amazon Athena. La visualizzazione Data Catalog è una funzionalità nativa di AWS Glue Data Catalog, ed è una visualizzazione multidialettale creata da un definitore. Puoi creare una vista del catalogo dati utilizzando uno dei servizi di analisi supportati, come Athena o Amazon Redshift Spectrum, e accedere alla stessa vista utilizzando altri servizi di analisi supportati. D'altra parte, le viste Apache Hive, Apache Spark e Athena vengono create indipendentemente in ogni servizio di analisi, come Athena e Amazon Redshift, e sono visibili e accessibili solo all'interno di tale servizio.
## Cos'è una vista più definita?
Una vista definente è una vista SQL che funziona in base alle autorizzazioni del principale che l'ha creata. Il ruolo definer dispone delle autorizzazioni necessarie per accedere alle tabelle di riferimento ed esegue l'istruzione SQL che definisce la vista. Il definitore crea la vista e la condivide con altri utenti tramite il controllo granulare degli AWS Lake Formation accessi.
Quando un utente interroga la vista del definitore, il motore di query utilizza le autorizzazioni del ruolo definer per accedere alle tabelle di riferimento sottostanti. Questo approccio consente agli utenti di interagire con la vista senza richiedere l'accesso diretto alle tabelle di origine, migliorando la sicurezza e semplificando la gestione dell'accesso ai dati.
Per configurare una vista di definizione, il ruolo IAM definer può trovarsi all'interno dello stesso AWS account delle tabelle di base o in un account diverso utilizzando ruoli di definizione tra account. Per ulteriori informazioni sulle autorizzazioni richieste per il ruolo definer, vedere. [Prerequisiti per la creazione di viste](views-prereqs.md)
## Un framework per visualizzazioni multidialettali
Il Data Catalog supporta la creazione di viste utilizzando più dialetti SQL (Structured Query Language). SQL è un linguaggio utilizzato per archiviare ed elaborare informazioni in un database relazionale e ogni motore AWS analitico utilizza la propria variante di SQL, o dialetto SQL.
È possibile creare una visualizzazione del catalogo dati in un dialetto SQL utilizzando uno dei motori di query di analisi supportati. Successivamente, puoi aggiornare la vista utilizzando l'`ALTER VIEW`istruzione in un dialetto SQL diverso all'interno di qualsiasi altro motore di analisi supportato. Tuttavia, ogni dialetto deve fare riferimento allo stesso set di tabelle, colonne e tipi di dati.
È possibile accedere ai diversi dialetti disponibili per la visualizzazione utilizzando l'`GetTable`API AWS CLI e AWS la console. Pertanto, la visualizzazione del catalogo dati è visibile e disponibile per le query su diversi motori di analisi supportati.
Definendo uno schema di visualizzazione e un oggetto di metadati comuni che è possibile interrogare da più motori, le viste del catalogo dati consentono di utilizzare viste uniformi su tutto il data lake.
Per maggiori dettagli su come viene risolto lo schema per ogni dialetto, consulta il [link al riferimento all'API](). Per maggiori dettagli sulle regole di abbinamento per i diversi tipi, consulta il [collegamento alla sezione pertinente nel documento API]().
## Integrazione con le autorizzazioni di Lake Formation
Puoi utilizzarlo AWS Lake Formation per centralizzare la gestione delle autorizzazioni sulle AWS Glue Data Catalog visualizzazioni per gli utenti. È possibile concedere autorizzazioni dettagliate per le viste del Data Catalog utilizzando il metodo delle risorse denominato o i tag LF e condividerle tra organizzazioni e unità organizzative. Account AWS AWS Puoi anche condividere e accedere alle viste del Data Catalog utilizzando i link alle risorse. Regioni AWS Ciò consente agli utenti di fornire l'accesso ai dati senza duplicare l'origine dei dati e condividere le tabelle sottostanti.
L'istruzione `CREATE VIEW` DDL di una vista Data Catalog può fare riferimento alle AWS Glue tabelle e alle tabelle standard in formati di tabelle aperte (OTF) come Hudi, Delta Lake e Iceberg con dati sottostanti archiviati in posizioni Amazon S3 registrate con Lake Formation, nonché alle tabelle federate del datashare Amazon Redshift condivise con Lake Formation. Le tabelle possono essere di qualsiasi formato di file purché il motore utilizzato per interrogare la vista supporti tale formato. È inoltre possibile fare riferimento alle funzioni integrate del motore su cui viene eseguito, ma potrebbero non essere consentite altre risorse specifiche del motore. Per ulteriori dettagli, consulta [Visualizzazioni, considerazioni e limitazioni di Data Catalog](views-notes.md).
## Casi d’uso
Di seguito sono riportati i casi d'uso importanti per le visualizzazioni del catalogo dati:
+ Crea e gestisci le autorizzazioni su uno schema a visualizzazione singola. Questo ti aiuta a evitare il rischio di autorizzazioni incoerenti su viste duplicate create in più motori.
+ Concedi le autorizzazioni agli utenti per una vista che fa riferimento a più tabelle senza concedere le autorizzazioni direttamente sulle tabelle di riferimento sottostanti.
+ Ottieni il filtraggio a livello di riga sulle tabelle utilizzando i tag LF (dove i tag LF si estendono a cascata solo fino al livello delle colonne) applicando i tag LF alle viste e concedendo autorizzazioni basate sui tag LF agli utenti.
## Servizi di analisi supportati per le visualizzazioni AWS
I seguenti servizi AWS di analisi supportano la creazione di viste del catalogo dati:
+ Amazon Redshift
+ Amazon Athena versione 3
+ Apache Spark su EMR Serverless
+ Apache Spark nella versione 5.0 AWS Glue
## Risorse aggiuntive
Puoi saperne di più sul Data Catalog in questa guida e utilizzare le seguenti risorse:
Il video seguente mostra come creare viste e interrogarle da Athena e Amazon Redshift.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/rFO2OoxVYxE?si=Z0qsyuvTp2ZJg-PL)
**Topics**
+ [
## Differenziazione delle viste del Data Catalog da altri tipi di visualizzazione
](#diff-views)
+ [
## Cos'è una vista più definita?
](#definer-view)
+ [
## Un framework per visualizzazioni multidialettali
](#multi-dialect)
+ [
## Integrazione con le autorizzazioni di Lake Formation
](#lf-view-integ)
+ [
## Casi d’uso
](#views-use-cases)
+ [
## Servizi di analisi supportati per le visualizzazioni AWS
](#views-supported-engines)
+ [
## Risorse aggiuntive
](#views-addtional-resources)
+ [
# Prerequisiti per la creazione di viste
](views-prereqs.md)
+ [
# Creazione di viste del catalogo dati utilizzando istruzioni DDL
](create-views.md)
+ [
# Creazione di viste del catalogo dati utilizzando AWS Glue APIs
](views-api-usage.md)
+ [
# Concessione delle autorizzazioni per le visualizzazioni del catalogo dati
](grant-perms-views.md)
+ [
# Viste materializzate
](materialized-views.md)
# Prerequisiti per la creazione di viste
+ Per creare viste in Data Catalog, devi registrare le posizioni dei dati Amazon S3 sottostanti delle tabelle di riferimento con Lake Formation. Per i dettagli sulla registrazione dei dati con Lake Formation, vedere[Aggiungere una posizione Amazon S3 al tuo data lake](register-data-lake.md).
+ Solo i ruoli IAM possono creare viste del Data Catalog. Le altre identità IAM non possono creare viste del catalogo dati.
+ Il ruolo IAM che definisce la vista deve disporre delle seguenti autorizzazioni:
+ `SELECT`Autorizzazione Lake Formation con `Grantable` opzione su tutte le tabelle di riferimento, incluse tutte le colonne.
+ `CREATE_TABLE`Autorizzazione Lake Formation sul database di destinazione in cui vengono create le viste.
+ Una politica di fiducia affinché la Lake Formation e AWS Glue i servizi assumano il ruolo.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DataCatalogViewDefinerAssumeRole1",
"Effect": "Allow",
"Principal": {
"Service": [
"glue.amazonaws.com",
"lakeformation.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
+ Lo scopo: PassRole autorizzazione per AWS Glue e Lake Formation.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DataCatalogViewDefinerPassRole1",
"Action": [
"iam:PassRole"
],
"Effect": "Allow",
"Resource": "*",
"Condition": {
"StringEquals": {
"iam:PassedToService": [
"glue.amazonaws.com",
"lakeformation.amazonaws.com"
]
}
}
}
]
}
```
------
+ AWS Glue e autorizzazioni Lake Formation.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"Glue:GetDatabase",
"Glue:GetDatabases",
"Glue:CreateTable",
"Glue:GetTable",
"Glue:GetTables",
"Glue:BatchGetPartition",
"Glue:GetPartitions",
"Glue:GetPartition",
"Glue:GetTableVersion",
"Glue:GetTableVersions",
"Glue:PassConnection",
"lakeFormation:GetDataAccess"
],
"Resource": "*"
}
]
}
```
------
+ Non è possibile creare viste in un database che dispone `Super` o ha `ALL` l'autorizzazione concessa al `IAMAllowedPrincipals` gruppo. Puoi revocare l'`Super`autorizzazione per il `IAMAllowedPrincipals` gruppo su un database[Passaggio 4: Passa i tuoi archivi dati al modello di autorizzazioni Lake Formation](upgrade-glue-lake-formation.md#upgrade-glue-lake-formation-step4), vedere o creare un nuovo database con la casella **Usa solo il controllo di accesso IAM per le nuove tabelle in questo database deselezionata in** **Autorizzazioni predefinite per le** tabelle appena create.
# Creazione di viste del catalogo dati utilizzando istruzioni DDL
Puoi creare AWS Glue Data Catalog viste utilizzando gli editor SQL per Athena, Amazon Redshift e utilizzando/. AWS Glue APIs AWS CLI
Per creare una vista del catalogo dati utilizzando gli editor SQL, scegli Athena o Redshift Spectrum e crea la vista utilizzando `CREATE VIEW` un'istruzione DDL (Data Definition Language). Dopo aver creato una vista nel dialetto del primo motore, puoi utilizzare un'istruzione `ALTER VIEW` DDL del secondo motore per aggiungere i dialetti aggiuntivi.
Quando si definiscono le viste, è importante considerare quanto segue:
+ **Definizione di viste multidialettali**: quando si definisce una vista con più dialetti, gli schemi dei diversi dialetti devono corrispondere. Ogni dialetto SQL avrà una specifica sintattica leggermente diversa. La sintassi della query che definisce la visualizzazione del catalogo dati dovrebbe corrispondere esattamente allo stesso elenco di colonne, inclusi sia i tipi che i nomi, in tutti i dialetti. Queste informazioni vengono memorizzate nella `StorageDescriptor` vista. I dialetti devono inoltre fare riferimento agli stessi oggetti della tabella sottostanti del Data Catalog.
Per aggiungere un altro dialetto a una vista utilizzando DDL, puoi usare l'istruzione. `ALTER VIEW` Se un'`ALTER VIEW`istruzione tenta di aggiornare la definizione della vista, ad esempio modificando il descrittore di archiviazione o le tabelle sottostanti della vista, l'istruzione restituisce un errore che dice «Input and existing storage descriptor mismatch». È possibile utilizzare le operazioni SQL cast per garantire che i tipi di colonne di visualizzazione corrispondano.
+ **Aggiornamento di una vista**: per aggiornare la vista, puoi utilizzare l'`UpdateTable`API. Se aggiorni la vista senza corrispondere ai descrittori di archiviazione o alle tabelle di riferimento, puoi fornire il `FORCE` flag (consulta la documentazione SQL del motore per la sintassi). Dopo un aggiornamento forzato, la visualizzazione assumerà le tabelle forzate `StorageDescriptor` e di riferimento. Qualsiasi ulteriore `ALTER VIEW` DDL deve corrispondere ai valori modificati. Una vista che è stata aggiornata per includere dialetti incompatibili avrà lo stato «Stale». Lo stato della vista è visibile nella console Lake Formation e utilizzando l'`GetTable`operazione.
+ **Riferimento a un tipo di colonna varchar come stringa: non è possibile inserire un** tipo di colonna varchar di Redshift Spectrum in una stringa. Se viene creata una vista in Redshift Spectrum con un tipo di colonna varchar e un dialetto successivo tenta di fare riferimento a quel campo come una stringa, il Data Catalog la tratterà come stringa senza la necessità del flag. `FORCE`
+ **Trattamento di campi di tipo complesso**: Amazon Redshift tratta tutti i tipi complessi come tipi [SUPER mentre](https://docs.aws.amazon.com/redshift/latest/dg/r_SUPER_type.html) Athena specifica il tipo complesso. Se una vista ha un campo `SUPER` di tipo e un altro motore fa riferimento a quella colonna come a un particolare tipo complesso, ad esempio struct (`>`), il Data Catalog presume che il campo sia il tipo complesso specifico e lo utilizza nel descrittore di archiviazione, senza richiedere il flag. `Force`
Per ulteriori informazioni sulla sintassi per la creazione e la gestione delle viste del catalogo dati, vedi:
+ [Utilizzo delle AWS Glue Data Catalog visualizzazioni](https://docs.aws.amazon.com/athena/latest/ug/views-glue.html) nella Guida per l'utente di Amazon Athena.
+ [Glue Data Catalog visualizza la sintassi delle query](https://docs.aws.amazon.com/athena/latest/ug/views-glue-ddl.html) nella Guida per l'utente di Amazon Athena.
+ [Creazione di viste AWS Glue Data Catalog nella](https://docs.aws.amazon.com/redshift/latest/dg/data-catalog-views-overview.html) Amazon Redshift Database Developer Guide.
Per ulteriori informazioni sui comandi SQL relativi alle viste nel Catalogo dati, consulta [CREATE EXTERNAL VIEW](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_VIEW.html), [ALTER EXTERNAL VIEW](https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_EXTERNAL_VIEW.html) e [DROP EXTERNAL VIEW](https://docs.aws.amazon.com/redshift/latest/dg/r_DROP_EXTERNAL_VIEW.html).
Dopo aver creato una vista Data Catalog, i dettagli della vista sono disponibili nella console Lake Formation.
1. Scegli **Views** in Data Catalog nella console Lake Formation.
1. Nella pagina delle visualizzazioni viene visualizzato un elenco delle viste disponibili.
1. Scegliete una vista dall'elenco e la pagina dei dettagli mostra gli attributi della vista.
![\[La sezione inferiore contiene cinque schede disposte orizzontalmente, in cui ogni scheda include le informazioni corrispondenti.\]](http://docs.aws.amazon.com/it_it/lake-formation/latest/dg/images/view-definition.png)
Schema
Scegliete una `Column` riga e selezionate **Modifica tag LF per aggiornare i valori dei tag** o assegnare nuovi tag LF.
Definizioni SQL
È possibile visualizzare un elenco di definizioni SQL disponibili. Seleziona **Aggiungi definizione SQL** e scegli un motore di query per aggiungere una definizione SQL. Scegli un motore di query (Athena o Amazon Redshift) sotto `Edit definition` la colonna per aggiornare una definizione SQL.
Tag LF
Scegliete **Modifica tag LF** per modificare i valori di un tag o assegnare nuovi tag. È possibile utilizzare i tag LF per concedere autorizzazioni sulle viste.
Accesso multi-account
Puoi vedere un elenco di Account AWS organizzazioni e unità organizzative (OUs) con cui hai condiviso la visualizzazione del catalogo dati.
Tabelle sottostanti
Le tabelle sottostanti a cui si fa riferimento nella definizione SQL utilizzata per creare la vista sono mostrate in questa scheda.
# Creazione di viste del catalogo dati utilizzando AWS Glue APIs
È possibile utilizzare AWS Glue [CreateTable](https://docs.aws.amazon.com/glue/latest/webapi/API_CreateTable.html)e [UpdateTable](https://docs.aws.amazon.com/glue/latest/webapi/API_UpdateTable.html) APIs creare e aggiornare le viste nel Data Catalog. Le `UpdateTable` operazioni `CreateTable` and hanno una nuova `TableInput` struttura`ViewDefinition`, mentre,`SearchTables`,,`GetTable`, `GetTables``GetTableVersion`, `GetTableVersions` le operazioni forniscono la `ViewDefinition` sintassi di output per le viste. Inoltre, c'è un nuovo `Status` campo nell'output dell'`GetTable`API.
Sono disponibili due nuove AWS Glue connessioni per la convalida del dialetto SQL per ogni motore di query supportato Amazon Athena e Amazon Redshift.
Le `CreateTable` e `UpdateTable` APIs sono asincrone se utilizzate con le viste. Quando questi APIs vengono chiamati con più dialetti SQL, la chiamata viene convalidata con ciascun motore per determinare se il dialetto può essere eseguito su quel motore e se lo schema risultante della vista di ciascun dialetto corrisponde. Il AWS Glue servizio utilizza queste connessioni per effettuare chiamate interne ai motori di analisi. Queste chiamate simulano ciò che fa il motore per convalidare se sul motore è stata eseguita una DDL `CREATE VIEW` o `ALTER VIEW` SQL.
Se l'SQL fornito è valido e gli schemi corrispondono tra i dialetti di visualizzazione, l' AWS Glue API esegue il commit atomico del risultato. Atomicity consente di creare o modificare viste con più dialetti senza tempi di inattività.
**Topics**
+ [
# Creazione di connessioni per AWS Glue convalidare lo stato
](views-api-usage-connection.md)
+ [
# Convalida dello stato di generazione della vista
](views-api-usage-get-table.md)
+ [
# Stati e operazioni asincroni
](views-api-usage-async-states.md)
+ [
# Visualizza gli scenari di errore di creazione durante le operazioni asincrone
](views-api-usage-errors.md)
# Creazione di connessioni per AWS Glue convalidare lo stato
Per creare o aggiornare una AWS Glue Data Catalog vista utilizzando le `UpdateTable` operazioni `CreateTable` or, devi creare un nuovo tipo di AWS Glue connessione per la convalida e fornirlo al motore di analisi supportato. Queste connessioni sono necessarie per utilizzare le viste del catalogo dati con Athena o Amazon Redshift. Puoi creare queste connessioni solo utilizzando AWS CLI AWS SDKs, o. AWS Glue APIs Non è possibile utilizzare il Console di gestione AWS per creare la AWS Glue connessione.
**Nota**
Se il ruolo view definer e il role calling `CreateTable` or `UpdateTable` sono diversi, entrambi richiedono l'`glue:PassConnection`autorizzazione nella dichiarazione sulla politica IAM.
Per ulteriori informazioni, consulta la documentazione [create-connection](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glue/create-connection.html) AWS CLI .
**AWS CLI comando per creare una connessione**
Di seguito è riportato un AWS CLI comando per creare una connessione:
```
aws glue create-connection --region us-east-1
--endpoint-url https://glue.us-east-1.amazonaws.com
--cli-input-json file:///root/path/to/create-connection.json
```
**AWS CLI input JSON**
Per Amazon Redshift:
```
{
"CatalogId": "123456789012",
"ConnectionInput": {
"ConnectionType": "VIEW_VALIDATION_REDSHIFT",
"Name": "views-preview-cluster-connection-2",
"Description": "My first Amazon Redshift validation connection",
"ConnectionProperties": {
"DATABASE": "dev",
"CLUSTER_IDENTIFIER": "glue-data-catalog-views-preview-cluster"
}
}
}
```
Per Amazon Athena:
```
{
"CatalogId": "123456789012",
"ConnectionInput": {
"ConnectionType": "VIEW_VALIDATION_ATHENA",
"Name": "views-preview-cluster-connection-3",
"Description": "My first Amazon Athena validation connection",
"ConnectionProperties": {
"WORKGROUP_NAME": "workgroup-name"
}
}
}
```
# Convalida dello stato di generazione della vista
Quando si eseguono le `UpdateTable` operazioni `CreateTable` or, il `Status` campo per l'output dell'`GetTable`API mostra i dettagli dello stato di creazione della vista. Per `create` le richieste in cui la tabella non esiste già, AWS Glue crea una tabella vuota per la durata del processo asincrono. Durante la chiamata`GetTable`, è possibile passare un flag booleano opzionale`IncludeStatusDetails`, che mostra le informazioni diagnostiche sulla richiesta. In caso di errore, questo flag mostra un messaggio di errore con gli stati individuali di ogni dialetto.
Gli errori durante le operazioni di visualizzazione, creazione, lettura, aggiornamento ed eliminazione (CRUD) possono verificarsi durante l'elaborazione nel servizio AWS Glue/Lake Formation o durante la convalida SQL della visualizzazione in Amazon Redshift o Athena. Quando si verifica un errore durante la convalida in un motore, il AWS Glue servizio fornisce il messaggio di errore restituito dal motore.
**Campi di stato**
I seguenti sono i campi di stato:
+ Status: uno stato generico, che è agnostico per diversi tipi di lavori:
+ IN CODA
+ IN\$1PROGRESS
+ RIUSCITO
+ NON RIUSCITO
+ Azione: indica quale azione è stata richiamata sulla tabella, attualmente solo `CREATE` o quali `UPDATE` operazioni sono disponibili.
La distinzione tra `UPDATE` e `CREATE` operazioni è importante quando si lavora con le viste. Il tipo di operazione determina come procedere con l'interrogazione delle tabelle.
Un'`UPDATE`operazione indica che la tabella esiste già nel Data Catalog. In questo caso, puoi continuare a interrogare la tabella creata in precedenza senza problemi. D'altra parte, un'`CREATE `operazione indica che la tabella non è mai stata creata correttamente prima. Se una tabella è contrassegnata per`CREATE`, il tentativo di interrogarla avrà esito negativo perché la tabella non esiste ancora nel sistema. Pertanto, è essenziale identificare il tipo di operazione (UPDATE o CREATE) prima di tentare di interrogare una tabella.
+ RequestedBy — L'ARN dell'utente che ha richiesto la modifica asincrona.
+ UpdatedBy — L'ARN dell'utente che per ultimo ha modificato manualmente il processo di modifica asincrono, ad esempio richiedendo una cancellazione o una modifica.
+ **Errore: questo campo viene visualizzato solo quando lo stato è FAILED.** Si tratta di un messaggio di eccezione a livello principale. Potrebbero esserci errori diversi per ogni dialetto.
+ ErrorCode — Il tipo di eccezione.
+ ErrorMessage — una breve descrizione dell'eccezione.
+ RequestTime — una stringa di data in formato ISO 8601 che indica l'ora in cui è stata avviata la modifica.
+ UpdateTime — una stringa di data in formato ISO 8601 che indica l'ora dell'ultimo aggiornamento dello stato.
# Stati e operazioni asincroni
Quando si esegue una `glue:CreateTable` richiesta, inizia la creazione asincrona della vista del catalogo dati. Nelle sezioni seguenti, questo documento descrive una `Status` AWS Glue vista disponibile in una risposta. `glue:GetTable` Per brevità, questa sezione omette la risposta completa.
```
{
"Table": {
...
"Status": {
...
"Action": "CREATE",
"State": "QUEUED",
}
}
}
```
Entrambi gli attributi precedenti rappresentano importanti informazioni diagnostiche che indicano lo stato dell'operazione asincrona e le azioni che possono essere eseguite su questa vista. Di seguito sono riportati i possibili valori che questi attributi possono assumere.
1. `Status.Action`
1. CREATE
1. UPDATE
1. `Status.State`
1. IN CODA
1. IN\$1PROGRESS
1. RIUSCITO
1. NON RIUSCITO
È inoltre importante notare che alcuni aggiornamenti su una visualizzazione del catalogo dati non richiedono un'operazione asincrona. Ad esempio, si potrebbe voler aggiornare l'`Description`attributo della tabella. Poiché ciò non richiede alcuna operazione asincrona, i metadati della tabella risultanti non ne `Status` avranno e l'attributo lo sarà. `NULL`
```
{
"Table": {
...,
"Description": "I changed this attribute!"
}
}
```
Successivamente, questo argomento esplora in che modo le informazioni sullo stato di cui sopra possono influire sulle operazioni che possono essere eseguite su una vista. AWS Glue
**colla: CreateTable**
Non ci sono modifiche per questa API rispetto al modo in cui `glue:CreateTable` funziona per qualsiasi tabella Glue. `CreateTable`può essere chiamato per qualsiasi nome di tabella che non esista già.
**colla: UpdateTable**
Questa operazione non può essere eseguita su una AWS Glue vista che contiene le seguenti informazioni di stato:
1. Azione == CREATE e State == IN CODA
1. Azione == CREATE e State == IN\$1PROGRESS
1. Azione == CREATE e state == FALLITO
1. Azione == AGGIORNAMENTO e stato == IN CODA
1. Azione == AGGIORNAMENTO e stato == IN\$1PROGRESS
Per riassumere, è possibile aggiornare una vista del catalogo dati solo quando soddisfa i seguenti requisiti.
1. È stata creata con successo per la prima volta.
1. Azione == CREATE e State == SUCCESS
1. Ha raggiunto lo stato terminale dopo un'operazione di aggiornamento asincrona.
1. Azione == AGGIORNAMENTO e stato == SUCCESSO
1. Azione == AGGIORNAMENTO e stato == FALLITO
1. Ha un attributo di `NULL` stato come risultato di un aggiornamento sincrono.
**colla: DeleteTable**
Questa operazione non presenta modifiche rispetto al `glue:DeleteTable` funzionamento di qualsiasi AWS Glue tabella. È possibile eliminare una vista del catalogo dati indipendentemente dal suo stato.
**colla: GetTable**
Questa operazione non presenta modifiche rispetto al `glue:GetTable` funzionamento di qualsiasi AWS Glue tabella. Tuttavia, non è possibile interrogare una vista del catalogo dati dai motori di analisi finché non è stata creata correttamente per la prima volta. `Action == CREATE and State == SUCCESS`. Dopo aver creato correttamente una vista del catalogo dati per la prima volta, è possibile interrogare la vista indipendentemente dal suo stato.
**Nota**
Tutte le informazioni contenute in questa sezione si applicano a tutte le tabelle lette`GetTable`, APIs ad esempio`GetTables`, e`SearchTables`.
# Visualizza gli scenari di errore di creazione durante le operazioni asincrone
Gli esempi seguenti sono rappresentativi dei tipi di errori che possono derivare `CreateTable` o `UpdateTable` visualizzare le chiamate API. Non sono esaustivi in quanto la superficie di errore degli errori delle query SQL è piuttosto ampia.
## Scenario 1: errore di interrogazione su Amazon Redshift
La query fornita per Amazon Redshift include un nome di tabella con errori di ortografia che non può essere trovato nel Data Catalog durante la convalida. L'errore risultante viene mostrato nel `Status` campo della `GetTable` risposta della vista.
`GetTable`richiesta:
```
{
"CatalogId": "123456789012",
"DatabaseName": "async-view-test-db",
"TableInput": {
"Name": "view-athena-redshift-72",
"Description": "This is an atomic operation",
"StorageDescriptor": {
"Columns": [
{ "Name": "col1", "Type": "int" },
{ "Name": "col2", "Type": "string" },
{ "Name": "col3", "Type": "double" }
]
},
"ViewDefinition": {
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [ "arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1" ],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-db\".\"table_1\"",
"ValidationConnection": "athena-connection"
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table__1\";",
"ValidationConnection": "redshift-connection"
}
]
}
}
}
```
`GetTable`risposta:
```
IncludeStatusDetails = FALSE
{
"Table": {
"Name": "view-athena-redshift-72",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:39:19-07:00",
"UpdateTime": "2024-07-11T11:39:19-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:39:19-07:00",
"UpdateTime": "2024-07-11T11:40:06-07:00",
"Action": "CREATE",
"State": "FAILED"
}
}
}
IncludeStatusDetails = TRUE
{
"Table": {
"Name": "view-athena-redshift-72",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:39:19-07:00",
"UpdateTime": "2024-07-11T11:39:19-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:39:19-07:00",
"UpdateTime": "2024-07-11T11:40:06-07:00",
"Action": "CREATE",
"State": "FAILED",
"Error": {
"ErrorCode": "QueryExecutionException",
"ErrorMessage": "Error received during view SQL validation using a connection: [Connection Name: redshift-connection | Query Execution Id: ddb711d3-2415-4aa9-b251-6a76ab4f41b1 | Timestamp: Thu Jul 11 18:39:37 UTC 2024]: Redshift returned error for the statement: ERROR: AwsClientException: EntityNotFoundException from glue - Entity Not Found"
},
"Details": {
"RequestedChange": {
"Name": "view-athena-redshift-72",
"DatabaseName": "async-view-test-db",
"Description": "This is an atomic operation",
"Retention": 0,
"StorageDescriptor": {
"Columns": [
{
"Name": "col1",
"Type": "int"
},
{
"Name": "col2",
"Type": "string"
},
{
"Name": "col3",
"Type": "double"
}
],
"Compressed": false,
"NumberOfBuckets": 0,
"SortColumns": [],
"StoredAsSubDirectories": false
},
"TableType": "VIRTUAL_VIEW",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"ViewDefinition": {
"IsProtected": true,
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [
"arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1"
],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-db\".\"table_1\"",
"IsStale": false
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table__1\";",
"IsStale": false
}
]
},
"IsMultiDialectView": true
},
"ViewValidations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewValidationText": "SELECT * FROM \"gdc-view-playground-db\".\"table_1\"",
"UpdateTime": "2024-07-11T11:40:06-07:00",
"State": "SUCCESS"
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewValidationText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table__1\";",
"UpdateTime": "2024-07-11T11:39:37-07:00",
"State": "FAILED",
"Error": {
"ErrorCode": "QueryExecutionException",
"ErrorMessage": "Error received during view SQL validation using a connection: [Connection Name: redshift-connection | Query Execution Id: ddb711d3-2415-4aa9-b251-6a76ab4f41b1 | Timestamp: Thu
Jul 11 18:39:37 UTC 2024]: Redshift returned error for the statement: ERROR: AwsClientException: EntityNotFoundException from glue - Entity Not Found"
}
}
]
}
}
}
}
```
## Scenario 2: connessione Amazon Redshift non valida
La connessione Amazon Redshift nell'esempio seguente non è valida perché fa riferimento a un database Amazon Redshift che non esiste nell'endpoint fornito. cluster/serverless Amazon Redshift non è in grado di convalidare la vista e il `Status` campo nella `GetTable` risposta mostra l'errore (da Amazon `"State": "FAILED"` Redshift).
`GetTable`richiesta:
```
{
"CatalogId": "123456789012",
"DatabaseName": "async-view-test-db",
"TableInput": {
"Name": "view-athena-redshift-73",
"Description": "This is an atomic operation",
"StorageDescriptor": {
"Columns": [
{ "Name": "col1", "Type": "int" },
{ "Name": "col2", "Type": "string" },
{ "Name": "col3", "Type": "double" }
]
},
"ViewDefinition": {
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [ "arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1" ],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-db\".\"table_1\"",
"ValidationConnection": "athena-connection"
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"ValidationConnection": "redshift-connection-malformed"
}
]
}
}
}
```
`GetTable`risposta:
```
IncludeStatusDetails = FALSE
{
"Table": {
"Name": "view-athena-redshift-73",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:43:27-07:00",
"UpdateTime": "2024-07-11T11:43:27-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:43:27-07:00",
"UpdateTime": "2024-07-11T11:43:40-07:00",
"Action": "CREATE",
"State": "FAILED"
}
}
}
IncludeStatusDetails = TRUE
{
"Table": {
"Name": "view-athena-redshift-73",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:43:27-07:00",
"UpdateTime": "2024-07-11T11:43:27-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:43:27-07:00",
"UpdateTime": "2024-07-11T11:43:40-07:00",
"Action": "CREATE",
"State": "FAILED",
"Error": {
"ErrorCode": "QueryExecutionException",
"ErrorMessage": "Error received during view SQL validation using a connection: [Connection Name: redshift-connection-malformed | Query Execution Id: 69bfafd4-3d51-4cb0-9320-7ce5404b1809 | Timestamp: Thu Jul 11 18:43:38 UTC 2024]: Redshift returned error for the statement: FATAL: database \"devooo\" does not exist"
},
"Details": {
"RequestedChange": {
"Name": "view-athena-redshift-73",
"DatabaseName": "async-view-test-db",
"Description": "This is an atomic operation",
"Retention": 0,
"StorageDescriptor": {
"Columns": [
{
"Name": "col1",
"Type": "int"
},
{
"Name": "col2",
"Type": "string"
},
{
"Name": "col3",
"Type": "double"
}
],
"Compressed": false,
"NumberOfBuckets": 0,
"SortColumns": [],
"StoredAsSubDirectories": false
},
"TableType": "VIRTUAL_VIEW",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"ViewDefinition": {
"IsProtected": true,
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [
"arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1"
],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-db\".\"table_1\"",
"IsStale": false
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"IsStale": false
}
]
},
"IsMultiDialectView": true
},
"ViewValidations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewValidationText": "SELECT * FROM \"gdc-view-playground-db\".\"table_1\"",
"UpdateTime": "2024-07-11T11:43:40-07:00",
"State": "SUCCESS"
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewValidationText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"UpdateTime": "2024-07-11T11:43:38-07:00",
"State": "FAILED",
"Error": {
"ErrorCode": "QueryExecutionException",
"ErrorMessage": "Error received during view SQL validation using a connection: [Connection Name: redshift-connection-malformed | Query Execution Id: 69bfafd4-3d51-4cb0-9320-7ce5404b1809 | Time
stamp: Thu Jul 11 18:43:38 UTC 2024]: Redshift returned error for the statement: FATAL: database \"devooo\" does not exist"
}
}
]
}
}
}
}
```
## Scenario 3: interrogazione Athena non riuscita
L'SQL per Athena qui non è valido perché la query digita erroneamente il nome del database. La convalida della query Athena rileva questo problema e l'errore risultante viene visualizzato attraverso l'`Status`oggetto in una chiamata. `GetTable`
`GetTable`richiesta:
```
{
"CatalogId": "123456789012",
"DatabaseName": "async-view-test-db",
"TableInput": {
"Name": "view-athena-redshift-70",
"Description": "This is an atomic operation",
"StorageDescriptor": {
"Columns": [
{ "Name": "col1", "Type": "int" },
{ "Name": "col2", "Type": "string" },
{ "Name": "col3", "Type": "double" }
]
},
"ViewDefinition": {
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [ "arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1" ],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT * FROM \"gdc--view-playground-db\".\"table_1\"",
"ValidationConnection": "athena-connection"
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"ValidationConnection": "redshift-connection"
}
]
}
}
}
```
`GetTable`risposta:
```
IncludeStatusDetails = FALSE
{
"Table": {
"Name": "view-athena-redshift-70",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:09:53-07:00",
"UpdateTime": "2024-07-11T11:09:53-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:09:54-07:00",
"UpdateTime": "2024-07-11T11:10:41-07:00",
"Action": "CREATE",
"State": "FAILED",
}
}
}
IncludeStatusDetails = TRUE
{
"Table": {
"Name": "view-athena-redshift-70",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:09:53-07:00",
"UpdateTime": "2024-07-11T11:09:53-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:09:54-07:00",
"UpdateTime": "2024-07-11T11:10:41-07:00",
"Action": "CREATE",
"State": "FAILED",
"Error": {
"ErrorCode": "QueryExecutionException",
"ErrorMessage": "Error received during view SQL validation using a connection: [Connection Name: athena-connection | Query Execution Id: d9bb1e6d-ce26-4b35-8276-8a199af966aa | Timestamp: Thu Jul 11 18:10:
41 UTC 2024]: Athena validation FAILED: {ErrorCategory: 2,ErrorType: 1301,Retryable: false,ErrorMessage: line 1:118: Schema 'gdc--view-playground-db' does not exist}"
},
"Details": {
"RequestedChange": {
"Name": "view-athena-redshift-70",
"DatabaseName": "async-view-test-db",
"Description": "This is an atomic operation",
"Retention": 0,
"StorageDescriptor": {
"Columns": [
{
"Name": "col1",
"Type": "int"
},
{
"Name": "col2",
"Type": "string"
},
{
"Name": "col3",
"Type": "double"
}
],
"Compressed": false,
"NumberOfBuckets": 0,
"SortColumns": [],
"StoredAsSubDirectories": false
},
"TableType": "VIRTUAL_VIEW",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"ViewDefinition": {
"IsProtected": true,
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [
"arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1"
],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT * FROM \"gdc--view-playground-db\".\"table_1\"",
"IsStale": false
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"IsStale": false
}
]
},
"IsMultiDialectView": true
},
"ViewValidations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewValidationText": "SELECT * FROM \"gdc--view-playground-db\".\"table_1\"",
"UpdateTime": "2024-07-11T11:10:41-07:00",
"State": "FAILED",
"Error": {
"ErrorCode": "QueryExecutionException",
"ErrorMessage": "Error received during view SQL validation using a connection: [Connection Name: athena-connection | Query Execution Id: d9bb1e6d-ce26-4b35-8276-8a199af966aa | Timestamp: Thu J
ul 11 18:10:41 UTC 2024]: Athena validation FAILED: {ErrorCategory: 2,ErrorType: 1301,Retryable: false,ErrorMessage: line 1:118: Schema 'gdc--view-playground-db' does not exist}"
}
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewValidationText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"UpdateTime": "2024-07-11T11:10:41-07:00",
"State": "SUCCESS"
}
]
}
}
}
}
```
## Scenario 4: descrittori di archiviazione non corrispondenti
L'SQL fornito per il dialetto Athena seleziona`col1`, `col2` mentre l'SQL per Redshift seleziona solo. `col1` Ciò porta a un errore di mancata corrispondenza del descrittore di archiviazione.
`GetTable`richiesta:
```
{
"CatalogId": "123456789012",
"DatabaseName": "async-view-test-db",
"TableInput": {
"Name": "view-athena-redshift-71",
"Description": "This is an atomic operation",
"StorageDescriptor": {
"Columns": [
{ "Name": "col1", "Type": "int" },
{ "Name": "col2", "Type": "string" },
{ "Name": "col3", "Type": "double" }
]
},
"ViewDefinition": {
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [ "arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1" ],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT col1, col2 FROM \"gdc-view-playground-db\".\"table_1\"",
"ValidationConnection": "athena-connection"
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT col1 FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"ValidationConnection": "redshift-connection"
}
]
}
}
}
```
`GetTable`risposta:
```
IncludeStatusDetails = FALSE
{
"Table": {
"Name": "view-athena-redshift-71",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:22:02-07:00",
"UpdateTime": "2024-07-11T11:22:02-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:22:02-07:00",
"UpdateTime": "2024-07-11T11:23:19-07:00",
"Action": "CREATE",
"State": "FAILED"
}
}
}
IncludeStatusDetails = TRUE
{
"Table": {
"Name": "view-athena-redshift-71",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:22:02-07:00",
"UpdateTime": "2024-07-11T11:22:02-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:22:02-07:00",
"UpdateTime": "2024-07-11T11:23:19-07:00",
"Action": "CREATE",
"State": "FAILED",
"Error": {
"ErrorCode": "InvalidInputException",
"ErrorMessage": "Engine and existing storage descriptor mismatch"
},
"Details": {
"RequestedChange": {
"Name": "view-athena-redshift-71",
"DatabaseName": "async-view-test-db",
"Description": "This is an atomic operation",
"Retention": 0,
"StorageDescriptor": {
"Columns": [
{
"Name": "col1",
"Type": "int"
},
{
"Name": "col2",
"Type": "string"
},
{
"Name": "col3",
"Type": "double"
}
],
"Compressed": false,
"NumberOfBuckets": 0,
"SortColumns": [],
"StoredAsSubDirectories": false
},
"TableType": "VIRTUAL_VIEW",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"ViewDefinition": {
"IsProtected": true,
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [
"arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1"
],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT col1, col2 FROM \"gdc-view-playground-db\".\"table_1\"",
"IsStale": false
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT col1 FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"IsStale": false
}
]
},
"IsMultiDialectView": true
},
"ViewValidations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewValidationText": "SELECT col1, col2 FROM \"gdc-view-playground-db\".\"table_1\"",
"UpdateTime": "2024-07-11T11:23:19-07:00",
"State": "FAILED",
"Error": {
"ErrorCode": "InvalidInputException",
"ErrorMessage": "Engine and existing storage descriptor mismatch"
}
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewValidationText": "SELECT col1 FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"UpdateTime": "2024-07-11T11:22:49-07:00",
"State": "FAILED",
"Error": {
"ErrorCode": "InvalidInputException",
"ErrorMessage": "Engine and existing storage descriptor mismatch"
}
}
]
}
}
}
}
```
# Concessione delle autorizzazioni per le visualizzazioni del catalogo dati
Dopo aver creato le viste in AWS Glue Data Catalog, puoi concedere le autorizzazioni per le visualizzazioni del data lake ai responsabili di tutte Account AWS le organizzazioni e le unità organizzative. È possibile concedere le autorizzazioni utilizzando i tag LF o il metodo di risorsa denominato. Per ulteriori informazioni sull'etichettatura delle risorse, vedere. [Controllo degli accessi basato su tag Lake Formation](tag-based-access-control.md) Per ulteriori informazioni sulla concessione diretta delle autorizzazioni per le viste, consulta. [Concessione delle autorizzazioni sulle viste utilizzando il metodo di risorsa denominato](granting-view-permissions.md)
# Viste materializzate
**Topics**
+ [
## Differenziazione delle viste materializzate da altri tipi di viste
](#materialized-views-differentiating)
+ [
## Casi d’uso
](#materialized-views-use-cases)
+ [
## Concetti chiave
](#materialized-views-key-concepts)
+ [
## Autorizzazioni per le viste materializzate
](#materialized-views-permissions)
+ [
## Creazione e gestione di viste materializzate
](#materialized-views-creating-managing)
+ [
## Archiviazione e accesso ai dati
](#materialized-views-storage-access)
+ [
## AWS Lake Formation Integrazione con le autorizzazioni
](#materialized-views-lake-formation)
+ [
## Monitoraggio e debug
](#materialized-views-monitoring-debugging)
+ [
## Gestione dei processi di aggiornamento
](#materialized-views-managing-refresh-jobs)
+ [
## Monitoraggio e risoluzione dei problemi
](#materialized-views-monitoring-troubleshooting)
+ [
## Considerazioni e limitazioni
](#materialized-views-considerations-limitations)
Nel AWS Glue Data Catalog, una vista materializzata è una tabella gestita che memorizza il risultato precalcolato di una query SQL in formato Apache Iceberg. A differenza delle viste standard del Data Catalog che eseguono la query ogni volta che vi si accede, le viste materializzate archiviano fisicamente i risultati della query e li aggiornano man mano che le tabelle di origine sottostanti cambiano. Puoi creare viste materializzate utilizzando Apache Spark versione 3.5.6\$1 in Amazon Athena, Amazon EMR o. AWS Glue
Le viste materializzate fanno riferimento alle tabelle Apache Iceberg registrate nel AWS Glue Data Catalog, con dati precalcolati archiviati come tabelle Apache Iceberg in bucket Amazon S3 Tables o bucket Amazon S3 per uso generico, rendendole accessibili da più motori di query tra cui Amazon Athena, Amazon Redshift e motori di terze parti compatibili con Iceberg.
## Differenziazione delle viste materializzate da altri tipi di viste
Le viste materializzate differiscono dalle viste AWS Glue Data Catalog, dalle viste Apache Spark e dalle viste Amazon Athena per alcuni aspetti fondamentali. Sebbene le viste del catalogo dati siano tabelle virtuali che eseguono la definizione della query SQL ogni volta che vi si accede, le viste materializzate archiviano fisicamente i risultati delle query precalcolate. Ciò elimina il calcolo ridondante e migliora significativamente le prestazioni delle query per le trasformazioni complesse a cui si accede di frequente.
Le viste materializzate differiscono anche dalle tradizionali pipeline di trasformazione dei dati create con AWS Glue ETL o job Spark personalizzati. Invece di scrivere codice personalizzato per gestire il rilevamento delle modifiche, gli aggiornamenti incrementali e l'orchestrazione del flusso di lavoro, definisci le viste materializzate utilizzando la sintassi SQL standard. Il AWS Glue Data Catalog monitora automaticamente le tabelle di origine, rileva le modifiche e aggiorna le viste materializzate utilizzando un'infrastruttura di elaborazione completamente gestita.
## Casi d’uso
Di seguito sono riportati importanti casi d'uso per le viste materializzate:
+ **Accelera le query analitiche complesse**: crea viste materializzate che precalcolano giunzioni, aggregazioni e funzioni di finestra costose. I motori Spark riscrivono automaticamente le query successive per utilizzare i risultati precalcolati, riducendo la latenza delle query e i costi di elaborazione.
+ **Semplifica le pipeline di trasformazione dei dati**: sostituisci i complessi job ETL che gestiscono il rilevamento delle modifiche, gli aggiornamenti incrementali e l'orchestrazione del flusso di lavoro con semplici definizioni di viste materializzate basate su SQL. Il Data Catalog gestisce automaticamente tutta la complessità operativa. AWS Glue
+ **Abilita l'analisi self-service con accesso regolamentato ai dati**: crea viste materializzate curate che trasformano i dati grezzi in set di dati pronti per l'uso. Concedi agli utenti l'accesso alle viste materializzate senza esporre le tabelle di origine sottostanti, semplificando la gestione della sicurezza e potenziando l'analisi self-service.
+ **Ottimizza la progettazione delle funzionalità per l'apprendimento automatico**: definisci viste materializzate che implementano le trasformazioni delle funzionalità per i modelli ML. La funzionalità di aggiornamento automatico assicura che gli archivi di funzionalità rimangano aggiornati man mano che i dati di origine si evolvono, mentre l'aggiornamento incrementale riduce al minimo i costi di elaborazione.
+ **Implementa una condivisione efficiente dei dati**: crea viste materializzate che filtrano e trasformano i dati per consumatori specifici. Condividi le viste materializzate tra account e aree geografiche utilizzando AWS Lake Formation, eliminando la necessità di duplicazione dei dati e mantenendo al contempo una governance centralizzata.
## Concetti chiave
### Aggiornamento automatico
L'aggiornamento automatico è una funzionalità che monitora continuamente le tabelle di origine e aggiorna le viste materializzate in base a una pianificazione definita dall'utente. Quando si crea una vista materializzata, è possibile specificare una frequenza di aggiornamento utilizzando una pianificazione basata sul tempo con intervalli frequenti fino a un'ora. Il AWS Glue Data Catalog utilizza l'infrastruttura di elaborazione Spark gestita per eseguire operazioni di aggiornamento in background, gestendo in modo trasparente tutti gli aspetti del rilevamento delle modifiche e degli aggiornamenti incrementali.
Quando i dati di origine cambiano tra gli intervalli di aggiornamento, la vista materializzata diventa temporaneamente obsoleta. Le query che accedono direttamente alla vista materializzata possono restituire risultati obsoleti fino al completamento del successivo aggiornamento pianificato. Per gli scenari che richiedono l'accesso immediato ai dati più recenti, è possibile eseguire un aggiornamento manuale utilizzando il comando SQL. `REFRESH MATERIALIZED VIEW`
### Aggiornamento incrementale
L'aggiornamento incrementale è una tecnica di ottimizzazione che elabora solo i dati modificati nelle tabelle di origine dall'ultimo aggiornamento, anziché ricalcolare l'intera vista materializzata. Il AWS Glue Data Catalog sfrutta il livello di metadati di Apache Iceberg per tracciare in modo efficiente le modifiche nelle tabelle di origine e determinare quali parti della vista materializzata richiedono aggiornamenti.
Questo approccio riduce in modo significativo i costi di elaborazione e la durata dell'aggiornamento rispetto alle operazioni di aggiornamento complete, in particolare per set di dati di grandi dimensioni in cui solo una piccola percentuale di dati cambia tra i cicli di aggiornamento. Il meccanismo di aggiornamento incrementale funziona automaticamente; non è necessario scrivere una logica personalizzata per rilevare o elaborare i dati modificati.
### Riscrittura automatica delle interrogazioni
La riscrittura automatica delle query è una funzionalità di ottimizzazione delle query disponibile nei motori Spark di Amazon Athena, Amazon EMR e. AWS Glue Quando esegui una query su tabelle di base, l'ottimizzatore Spark analizza il tuo piano di query e determina automaticamente se le viste materializzate disponibili possono soddisfare la query in modo più efficiente. Se esiste una vista materializzata adatta, l'ottimizzatore riscrive in modo trasparente la query per utilizzare i risultati precalcolati anziché elaborare le tabelle di base.
Questa ottimizzazione avviene senza richiedere alcuna modifica al codice dell'applicazione o alle istruzioni di query. L'ottimizzatore Spark assicura che la riscrittura automatica delle query si applichi solo quando la vista materializzata è attuale e può produrre risultati accurati. Se una vista materializzata è obsoleta o non soddisfa completamente i requisiti della query, l'ottimizzatore esegue il piano di query originale sulla base delle tabelle di base, dando priorità alla correttezza rispetto alle prestazioni.
### Visualizza il ruolo del definitore
Una vista materializzata funziona in base alle autorizzazioni del ruolo IAM che l'ha creata, noto come ruolo view definer. Il ruolo definer deve avere accesso in lettura a tutte le tabelle di base a cui si fa riferimento nella definizione della vista materializzata e creare i permessi per le tabelle sul database di destinazione. Quando il AWS Glue Data Catalog aggiorna una vista materializzata, assume il ruolo di definitore di accedere alle tabelle di origine e scrivere risultati aggiornati.
Questo modello di sicurezza consente di concedere agli utenti l'accesso alle viste materializzate senza concedere loro autorizzazioni dirette sulle tabelle di origine sottostanti. Se il ruolo View Definer perde l'accesso a qualsiasi tabella di base, le successive operazioni di aggiornamento avranno esito negativo fino al ripristino delle autorizzazioni.
## Autorizzazioni per le viste materializzate
Per creare e gestire le viste materializzate, è necessario configurare le autorizzazioni. AWS Lake Formation Il ruolo IAM che crea la vista materializzata (il ruolo definer) richiede autorizzazioni specifiche sulle tabelle di origine e sui database di destinazione.
### Autorizzazioni richieste per il ruolo di definitore
Il ruolo che definisce deve avere i seguenti permessi di Lake Formation:
+ Nelle tabelle di origine: autorizzazioni SELECT o ALL senza filtri di riga, colonna o cella
+ Sul database di destinazione: autorizzazione CREATE\$1TABLE
+ Sul AWS Glue Data Catalog e sulle autorizzazioni API GetTable CreateTable
Quando si crea una vista materializzata, l'ARN del ruolo definitore viene memorizzato nella definizione della vista. Il AWS Glue Data Catalog assume questo ruolo durante l'esecuzione di operazioni di aggiornamento automatico. Se il ruolo del definitore perde l'accesso alle tabelle di origine, le operazioni di aggiornamento avranno esito negativo fino al ripristino delle autorizzazioni.
### Autorizzazioni IAM per i lavori AWS Glue
Il ruolo IAM del tuo AWS Glue lavoro richiede le seguenti autorizzazioni:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:GetCatalog",
"glue:GetCatalogs",
"glue:GetTable",
"glue:GetTables",
"glue:CreateTable",
"glue:UpdateTable",
"glue:DeleteTable",
"glue:GetDatabase",
"glue:GetDatabases",
"cloudwatch:PutMetricData"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:PutObject",
"s3:DeleteObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket"
]
},
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": [
"arn:aws:logs:*:*:*:/aws-glue/*"
]
},
{
"Effect": "Allow",
"Action": [
"lakeformation:GetDataAccess"
],
"Resource": "*"
}
]
}
```
Il ruolo che usi per l'aggiornamento automatico di Materialized View deve avere l'PassRole autorizzazione iam: sul ruolo.
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::111122223333:role/materialized-view-role-name"
]
}
]
}
```
Affinché Glue aggiorni automaticamente la vista materializzata, il ruolo deve inoltre avere la seguente politica di attendibilità che consenta al servizio di assumere il ruolo.
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "glue.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
Se la vista materializzata è archiviata in S3 Tables Bucket, devi anche aggiungere la seguente autorizzazione al ruolo.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3tables:PutTableMaintenanceConfiguration"
],
"Resource": "arn:aws:s3tables:*:123456789012:*"
}
]
}
```
### Concessione dell'accesso alle viste materializzate
Per concedere ad altri utenti l'accesso all'interrogazione di una vista materializzata, utilizzare questa opzione AWS Lake Formation per concedere l'autorizzazione SELECT sulla tabella delle viste materializzate. Gli utenti possono interrogare la vista materializzata senza richiedere l'accesso diretto alle tabelle di origine sottostanti.
Per informazioni dettagliate sulla configurazione delle autorizzazioni di Lake Formation, consulta Concessione e revoca delle autorizzazioni sulle risorse di Data Catalog nella Developer Guide. AWS Lake Formation
## Creazione e gestione di viste materializzate
Puoi creare viste materializzate utilizzando l'`CREATE MATERIALIZED VIEW`istruzione SQL nei motori Spark. La definizione della vista specifica la query SQL che definisce la logica di trasformazione, il database di destinazione e il nome della tabella e la configurazione di aggiornamento opzionale. È possibile definire trasformazioni complesse tra cui aggregazioni, join tra più tabelle, filtri e funzioni di finestra.
```
CREATE MATERIALIZED VIEW sales_summary
AS
SELECT
region,
product_category,
SUM(sales_amount) as total_sales,
COUNT(DISTINCT customer_id) as unique_customers
FROM sales_transactions
WHERE transaction_date >= current_date - interval '90' day
GROUP BY region, product_category;
```
Per configurare l'aggiornamento automatico, includi la pianificazione dell'aggiornamento nella definizione della vista:
```
CREATE MATERIALIZED VIEW sales_summary
SCHEDULE REFRESH EVERY 1 HOUR
AS
SELECT region, product_category, SUM(sales_amount) as total_sales
FROM sales_transactions
GROUP BY region, product_category;
```
È possibile aggiornare manualmente una vista materializzata in qualsiasi momento utilizzando il comando: `REFRESH MATERIALIZED VIEW`
```
REFRESH MATERIALIZED VIEW sales_summary;
```
Per modificare la pianificazione di aggiornamento di una vista materializzata esistente, utilizza l'istruzione: `ALTER MATERIALIZED VIEW`
```
ALTER MATERIALIZED VIEW sales_summary
ADD SCHEDULE REFRESH EVERY 2 HOURS;
```
### Viste materializzate annidate
È possibile creare viste materializzate che fanno riferimento ad altre viste materializzate come tabelle di base, abilitando trasformazioni dei dati in più fasi. Quando si creano viste materializzate annidate, il AWS Glue Data Catalog tiene traccia delle dipendenze e propaga automaticamente gli aggiornamenti attraverso la gerarchia delle viste materializzate. Quando una vista materializzata di base viene aggiornata, tutte le viste materializzate a valle che dipendono da essa vengono aggiornate di conseguenza.
Questa funzionalità consente di scomporre trasformazioni complesse in fasi logiche, migliorando la manutenibilità e abilitando l'aggiornamento selettivo dei livelli di trasformazione in base ai requisiti di freschezza dei dati.
## Archiviazione e accesso ai dati
Le viste materializzate archiviano i risultati precalcolati come tabelle Apache Iceberg in bucket S3 Tables o bucket S3 per uso generico all'interno del tuo account. AWS Il AWS Glue Data Catalog gestisce tutti gli aspetti della manutenzione delle tabelle Iceberg, tra cui la compattazione e la conservazione delle istantanee, attraverso le funzionalità di ottimizzazione automatizzata di S3 Tables.
Poiché le viste materializzate vengono archiviate come tabelle Iceberg, puoi leggerle direttamente da qualsiasi motore compatibile con Iceberg, tra cui Amazon Athena, Amazon Redshift e piattaforme di analisi di terze parti. Questa accessibilità multi-motore garantisce che i dati precalcolati rimangano accessibili in tutto l'ecosistema di analisi senza duplicazione dei dati o conversione del formato.
## AWS Lake Formation Integrazione con le autorizzazioni
Puoi utilizzarlo AWS Lake Formation per gestire autorizzazioni granulari sulle viste materializzate. Il creatore della vista diventa automaticamente il proprietario della vista materializzata e può concedere le autorizzazioni ad altri utenti o ruoli utilizzando AWS Lake Formation il metodo named resource o i tag LF.
Quando concedi l'`SELECT`autorizzazione a un utente per una vista materializzata, quest'ultimo può interrogare i risultati precalcolati senza richiedere l'accesso alle tabelle di origine sottostanti. Questo modello di sicurezza semplifica la gestione dell'accesso ai dati e consente di implementare il principio del privilegio minimo, fornendo agli utenti l'accesso solo alle trasformazioni di dati specifiche di cui hanno bisogno.
È possibile condividere viste materializzate tra AWS account, AWS organizzazioni e unità organizzative utilizzando le funzionalità di condivisione tra account AWS Lake Formation di cui dispone. È inoltre possibile accedere alle viste materializzate in tutte AWS le regioni utilizzando collegamenti alle risorse, abilitando una governance centralizzata dei dati con accesso distribuito ai dati.
## Monitoraggio e debug
Il AWS Glue Data Catalog pubblica tutte le operazioni di aggiornamento delle viste materializzate e le metriche associate su Amazon. CloudWatch Puoi monitorare l'ora di inizio dell'aggiornamento, l'ora di fine, la durata, il volume di dati elaborati e lo stato dell'aggiornamento tramite metriche. CloudWatch Quando le operazioni di aggiornamento falliscono, i messaggi di errore e le informazioni di diagnostica vengono acquisiti nei registri. CloudWatch
È possibile impostare CloudWatch allarmi per ricevere notifiche quando i processi di aggiornamento superano la durata prevista o falliscono ripetutamente. Il AWS Glue Data Catalog pubblica anche eventi di modifica in caso di esecuzioni di aggiornamento riuscite e non riuscite, consentendoti di integrare le operazioni di visualizzazione materializzata in un'automazione più ampia del flusso di lavoro.
Per verificare lo stato corrente di una vista materializzata, utilizza il comando `DESCRIBE MATERIALIZED VIEW` SQL, che restituisce i metadati tra cui lo stato di inattività, il timestamp dell'ultimo aggiornamento e la configurazione della pianificazione dell'aggiornamento.
## Gestione dei processi di aggiornamento
### Avvio di un aggiornamento manuale
Attiva un aggiornamento immediato al di fuori dell'intervallo pianificato.
Autorizzazione richiesta: AWS le credenziali utilizzate per effettuare la chiamata API devono disporre dell'`glue:GetTable`autorizzazione per la vista materializzata.
Per S3 Tables Catalog:
```
aws glue start-materialized-view-refresh-task-run \
--catalog-id :s3tablescatalog/ \
--database-name \
--table-name
```
Per Root Catalog:
```
aws glue start-materialized-view-refresh-task-run \
--catalog-id \
--database-name \
--table-name
```
### Verifica dello stato di aggiornamento
Ottieni lo stato di un processo di aggiornamento specifico:
```
aws glue get-materialized-view-refresh-task-run \
--catalog-id \
--materialized-view-refresh-task-run-id
```
### Cronologia degli aggiornamenti degli elenchi
Visualizza tutti i lavori di aggiornamento per una vista materializzata:
```
aws glue list-materialized-view-refresh-task-runs \
--catalog-id \
--database-name \
--table-name
```
**Nota**
Utilizzare `:s3tablescatalog/` per le tabelle S3 o `` per il catalogo principale.
### Interruzione di un aggiornamento in esecuzione
Annullare un processo di aggiornamento in corso:
```
aws glue stop-materialized-view-refresh-task-run \
--catalog-id \
--database-name \
--table-name
```
## Monitoraggio e risoluzione dei problemi
Esistono tre modi per monitorare i processi di aggiornamento delle viste materializzate:
### CloudWatch Metriche
Visualizza le metriche aggregate per tutti i tuoi lavori di aggiornamento delle viste materializzate in: CloudWatch
Metriche disponibili:
+ AWS/Namespace Glue con dimensioni:
+ CatalogId: il tuo identificatore del catalogo
+ DatabaseName: database contenente la vista materializzata
+ TableName: nome della vista materializzata
+ TaskType: Imposta su "» MaterializedViewRefresh
Visualizzazione in console:
1. Vai a CloudWatch Console → Metriche
1. Seleziona lo spazio dei AWS nomi /Glue
1. Filtra per dimensioni: CatalogId,,, DatabaseName TableName TaskType
1. Visualizza le metriche relative al successo, al fallimento e alla durata del lavoro
Esempio di interrogazione CloudWatch sulle metriche:
```
{AWS/Glue,CatalogId,DatabaseName,TableName,TaskType} MaterializedViewRefresh
```
Usando AWS CLI:
```
aws cloudwatch get-metric-statistics \
--namespace AWS/Glue \
--metric-name \
--dimensions Name=CatalogId,Value= \
Name=DatabaseName,Value= \
Name=TableName,Value= \
Name=TaskType,Value=MaterializedViewRefresh \
--start-time \
--end-time \
--period 3600 \
--statistics Sum \
--region
```
### CloudWatch Registri
Visualizza i registri di esecuzione dettagliati per le singole operazioni di aggiornamento:
Gruppo di log: `/aws-glue/materialized-views/`
``Dov'è un UUID (ad esempio, abc12345-def6-7890-ghij-klmnopqrstuv).
Visualizzazione dei registri:
```
# List log streams for a task run
aws logs describe-log-streams \
--log-group-name /aws-glue/materialized-views/ \
--region
# Get log events
aws logs get-log-events \
--log-group-name /aws-glue/materialized-views/ \
--log-stream-name \
--region
```
Nella CloudWatch console:
1. Vai a CloudWatch → Gruppi di log
1. Cerca /aws-glue/materialized-views/
1. Seleziona il gruppo di log con il tuo ID di esecuzione dell'attività
1. Visualizza i log di esecuzione dettagliati, gli errori e l'output del job Spark
### Notifications
Iscriviti agli eventi per ricevere notifiche in tempo reale sulle modifiche allo stato del processo di aggiornamento:
Tipi di eventi disponibili:
+ Attività di aggiornamento di Glue Materialized View iniziata
+ Attività di aggiornamento di Glue Materialized View riuscita
+ Task di aggiornamento di Glue Materialized View non riuscita
+ Errore di invocazione dell'aggiornamento automatico di Glue Materialized View
Creazione di una regola:
```
aws events put-rule \
--name materialized-view-refresh-notifications \
--event-pattern '{
"source": ["aws.glue"],
"detail-type": [
"Glue Materialized View Refresh Task Started",
"Glue Materialized View Refresh Task Succeeded",
"Glue Materialized View Refresh Task Failed",
"Glue Materialized View Auto-Refresh Invocation Failure"
]
}' \
--region
```
Aggiungere una destinazione (ad esempio, argomento SNS):
```
aws events put-targets \
--rule materialized-view-refresh-notifications \
--targets "Id"="1","Arn"="arn:aws:sns:::" \
--region
```
### Visualizzazione dello stato di aggiornamento
Controlla lo stato dei tuoi lavori di aggiornamento delle viste materializzate utilizzando l'API: AWS Glue
```
aws glue get-materialized-view-refresh-task-run \
--catalog-id \
--materialized-view-refresh-task-run-id \
--region
```
Oppure elenca tutte le esecuzioni di aggiornamento recenti:
```
aws glue list-materialized-view-refresh-task-runs \
--catalog-id \
--database-name \
--table-name \
--region
```
Questo mostra:
+ Ora dell'ultimo aggiornamento
+ Stato di aggiornamento (RIUSCITO, FALLITO, IN ESECUZIONE, INTERROTTO)
+ ID di esecuzione dell'attività
+ Messaggi di errore (se falliti)
Stati di aggiornamento comuni:
+ IN ESECUZIONE: il processo di aggiornamento è attualmente in esecuzione
+ RIUSCITO: aggiornamento completato con successo
+ FALLITO: l'aggiornamento ha rilevato un errore
+ INTERROTTO: l'aggiornamento è stato annullato manualmente
Risoluzione dei problemi relativi agli aggiornamenti non riusciti:
Se un aggiornamento fallisce, controlla:
1. Autorizzazioni IAM: assicurati che il ruolo che definisce abbia accesso a tutte le tabelle di base e alla posizione della vista materializzata
1. Disponibilità della tabella di base: verifica che tutte le tabelle di riferimento esistano e siano accessibili
1. Validità della query: conferma che la query SQL è valida per il dialetto SQL di Spark
1. Limiti delle risorse: verifica se hai raggiunto i limiti di aggiornamento simultanei per il tuo account
Utilizza l' GetMaterializedViewRefreshTaskRun API per recuperare messaggi di errore dettagliati.
## Considerazioni e limitazioni
+ Le viste materializzate possono fare riferimento solo alle tabelle Apache Iceberg registrate nel AWS Glue Data Catalog come tabelle di base.
+ La creazione di viste e la riscrittura automatica delle query sono disponibili solo dai motori Spark in Apache Spark versione 3.5.6 e successive su Amazon Athena, Amazon EMR e (versione 5.1). AWS Glue
+ Le viste materializzate alla fine sono coerenti con le tabelle di base. Durante la finestra di aggiornamento, le query che accedono direttamente alla vista materializzata possono restituire dati obsoleti. Per un accesso immediato ai dati correnti, esegui un aggiornamento manuale.
+ L'intervallo minimo di aggiornamento automatico è di un'ora. Per i casi d'uso che richiedono aggiornamenti più frequenti, esegui gli aggiornamenti manuali a livello di codice utilizzando il comando. `REFRESH MATERIALIZED VIEW`
+ La riscrittura delle query dà priorità alla correttezza rispetto alle prestazioni. Se una vista materializzata è obsoleta o non è in grado di soddisfare con precisione i requisiti di query, i motori Spark eseguono la query originale sulle tabelle di base.