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à.
# Esecuzione di query SQL con Amazon Athena
Puoi eseguire query SQL mediante Amazon Athena su origini dati registrate con AWS Glue Data Catalog e le origini dati, come i metastore Hive e le istanze Amazon DocumentDB cui ti connetti usando la funzionalità Athena Federated Query. Per ulteriori informazioni sull'utilizzo delle origini dati, consulta [Connessione alle origini dati](work-with-data-stores.md). Quando esegui una query DDL (Data Definition Language) che modifica lo schema, Athena scrive i metadati nel metastore associato all'origine dati. Inoltre, alcune query, come `CREATE TABLE AS` e `INSERT INTO`, possono scrivere record nel set di dati, ad esempio aggiungendo un record CSV a una posizione Amazon S3.
In questa sezione vengono fornite indicazioni per l'esecuzione di query Athena su origini dati comuni e tipi di dati utilizzando diverse istruzioni SQL. Vengono fornite indicazioni generali per lavorare con strutture e operatori comuni, ad esempio per lavorare con array, concatenare, filtrare, appiattire e ordinare. Altri esempi includono query per dati in tabelle con strutture e mappe annidate, tabelle basate su set di dati con codifica JSON e set di dati associati a log e log di Amazon EMR. Servizi AWS AWS CloudTrail La copertura completa dell'utilizzo di SQL standard non viene riportata in questa documentazione. Per ulteriori informazioni su SQL, consulta i riferimenti ai linguaggi [Trino](https://trino.io/docs/current/language.html) e [Presto](https://prestodb.io/docs/current/sql.html).
**Topics**
+ [Visualizzare i piani di query](query-plans.md)
+ [Lavora con i risultati delle query e le query recenti](querying.md)
+ [Riutilizza i risultati delle query in Athena](reusing-query-results.md)
+ [Visualizzazione dello stato delle query](query-stats.md)
+ [Utilizzo delle viste](views.md)
+ [Utilizzo di query salvate](saved-queries.md)
+ [Utilizzare query parametrizzate](querying-with-prepared-statements.md)
+ [Utilizzo dell’ottimizzatore basato sui costi](cost-based-optimizer.md)
+ [Eseguire query in S3 Express One Zone](querying-express-one-zone.md)
+ [Eseguire query in Amazon Glacier](querying-glacier.md)
+ [Gestire gli aggiornamenti degli schemi](handling-schema-updates-chapter.md)
+ [Eseguire query su matrici](querying-arrays.md)
+ [Eseguire query su dati geospaziali.](querying-geospatial-data.md)
+ [Dati JSON](querying-JSON.md)
+ [Utilizzare ML con Athena](querying-mlmodel.md)
+ [Interrogazione con UDFs](querying-udf.md)
+ [Eseguire query tra regioni](querying-across-regions.md)
+ [Interroga il AWS Glue Data Catalog](querying-glue-catalog.md)
+ [Servizio AWS Registri delle interrogazioni](querying-aws-service-logs.md)
+ [Eseguire query sui log del server web](querying-web-server-logs.md)
Per considerazioni e limitazioni, vedere [Considerazioni e restrizioni per le query SQL in Amazon Athena](other-notable-limitations.md).
# Visualizzare i piani di esecuzione per query SQL
È possibile utilizzare l'editor di query Athena per visualizzare rappresentazioni grafiche di come verrà eseguita la query. Quando si immette una query nell'editor e si seleziona l’opzione **Explain**, Athena usa un’istruzione [EXPLAIN](athena-explain-statement.md) di SQL sulla query per creare due grafici corrispondenti: un piano di esecuzione distribuito e un piano di esecuzione logico. Puoi utilizzare questi grafici per analizzare, risolvere i problemi e migliorare l'efficienza delle tue query.
**Visualizzare i piani di esecuzione di una query**
1. Inserisci la query nell'editor, quindi seleziona **Run** (esegui).
![\[Seleziona Explain nell'editor di query Athena.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/query-plans-1.png)
La scheda **Distributed plan (piano distribuito)** mostra il piano di esecuzione della query in un ambiente distribuito. Un piano distribuito contiene frammenti di elaborazione o *fasi*. Ogni fase ha un numero di indice a base zero ed è elaborata da uno o più nodi. I dati possono essere scambiati tra i nodi.
![\[Esempio di grafico del piano distribuito delle query.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/query-plans-2.png)
1. Per navigare nel grafico, utilizza le seguenti opzioni:
+ Per ingrandire o ridurre l'immagine, fai scorrere il mouse o utilizza le icone di ingrandimento.
+ Per regolare il grafico in base alle dimensioni della schermata, seleziona l’icona **Zoom to fit (usa lo zoom per adattare l’immagine)**.
+ Per spostare il grafico, trascina il puntatore del mouse.
1. Per visualizzare maggiori dettagli di una fase, selezionala.
![\[Seleziona una fase per visualizzarne i dettagli.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/query-plans-3.png)
1. Per visualizzare i dettagli della fase a tutto schermo, seleziona l'icona di espansione in alto a destra nel pannello dei dettagli.
1. Per visualizzare più dettagli, espandi uno o più elementi nell'albero operatore. Per informazioni sui frammenti di piani distribuiti, consulta [Tipi di output dell'istruzione EXPLAIN](athena-explain-statement-understanding.md#athena-explain-statement-understanding-explain-plan-types).
![\[Albero dell’operatore ampliato per una fase in un piano di query distribuito.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/query-plans-4.png)
**Importante**
Attualmente, alcuni filtri di partizione potrebbero non essere visibili nel grafico ad albero degli operatori annidato anche se Athena li applica alla tua query. Per verificare l'effetto di tali filtri, esegui [EXPLAIN](athena-explain-statement.md#athena-explain-statement-syntax-athena-engine-version-2) o [EXPLAIN ANALYZE](athena-explain-statement.md#athena-explain-analyze-statement) sulla query e visualizza i risultati.
1. Seleziona la scheda **Logical plan (piano logico)**. Il grafico mostra il piano logico per l'esecuzione della query. Per ulteriori informazioni sull'operazione, consulta [Capire i risultati dell’istruzione EXPLAIN di Athena](athena-explain-statement-understanding.md).
![\[Grafico di un piano logico di query in Athena.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/query-plans-5.png)
1. Per esportare un piano come immagine SVG o PNG o come testo JSON, scegli **Export (esporta)**.
## Risorse aggiuntive
Per ulteriori informazioni, consulta le risorse seguenti.
[Utilizzo di EXPLAIN e EXPLAIN ANALYZE in Athena](athena-explain-statement.md)
[Capire i risultati dell’istruzione EXPLAIN di Athena](athena-explain-statement-understanding.md)
[Visualizzazione di statistiche e dettagli di esecuzione per le query completate](query-stats.md)
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/7JUyTqglmNU)
# Lavora con i risultati delle query e le query recenti
Amazon Athena archivia automaticamente i risultati delle query e le informazioni sui metadati per ogni query eseguita in una *posizione dei risultati delle query* che puoi specificare in Amazon S3. Se necessario, puoi accedere ai file in questa posizione per utilizzarli. Puoi anche scaricare i file dei risultati delle query direttamente dalla console Athena.
Athena offre ora due opzioni per la gestione dei risultati delle query: è possibile utilizzare un bucket S3 di proprietà del cliente o optare per la funzionalità di gestione dei risultati delle query. Con il proprio bucket, si mantiene il controllo completo sullo storage, sulle autorizzazioni, sulle politiche del ciclo di vita e sulla conservazione, offrendo la massima flessibilità ma richiedendo una maggiore gestione. In alternativa, quando si sceglie l’opzione dei risultati delle query gestite, il servizio gestisce automaticamente lo storage e la gestione del ciclo di vita, eliminando la necessità di configurare un bucket di risultati separato e di ripulire automaticamente i risultati dopo un periodo di conservazione predeterminato. Per ulteriori informazioni, consulta [Risultati delle query gestite](managed-results.md).
Per impostare una posizione per i risultati delle query di Amazon S3 per la prima volta, consulta [Specificare una posizione dei risultati delle query utilizzando la console Athena](query-results-specify-location-console.md).
I file di output vengono salvati automaticamente per ogni query eseguita. Per accedere e visualizzare i file di output delle query utilizzando la console Athena, i responsabili IAM (utenti e ruoli) necessitano dell'autorizzazione all'[GetObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html)azione Amazon S3 per la posizione dei risultati della query, nonché dell'autorizzazione per l'azione Athena. [GetQueryResults](https://docs.aws.amazon.com/athena/latest/APIReference/API_GetQueryResults.html) La posizione dei risultati delle query può essere crittografata. Se la posizione è crittografata, gli utenti devono disporre delle autorizzazioni chiave appropriate per crittografare e decrittografare la posizione dei risultati delle query.
**Importante**
I principali IAM con l'autorizzazione per l'operazione Amazon S3 `GetObject` per la posizione dei risultati delle query sono in grado di recuperare i risultati delle query da Amazon S3 anche se l'autorizzazione per l'operazione Athena `GetQueryResults` viene negata.
**Nota**
Per le query annullate o non riuscite, Athena potrebbe avere già scritto risultati parziali in Amazon S3. In questi casi, Athena non elimina risultati parziali dal prefisso Amazon S3 in cui vengono archiviati i risultati. Devi rimuovere il prefisso Amazon S3 con risultati parziali. Athena utilizza caricamenti in più parti di Amazon S3 per scrivere dati Amazon S3. È consigliabile impostare la policy del ciclo di vita del bucket in modo da terminare i caricamenti in più parti in caso di query non riuscite. Per ulteriori informazioni, consulta [Interruzione dei caricamenti in più parti incompleti utilizzando una policy per il ciclo di vita del bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpuoverview.html#mpu-abort-incomplete-mpu-lifecycle-config) nella *Guida per l'utente di Amazon Simple Storage Service*.
In determinate condizioni, Athena può ritentare automaticamente l’esecuzione delle query. Nella maggior parte dei casi, queste interrogazioni possono essere completate correttamente e l’ID della query è contrassegnato come `Completed`. Queste query potrebbero aver prodotto risultati parziali durante i tentativi iniziali e generare caricamenti incompleti in più parti.
**Topics**
+ [Risultati delle query gestite](managed-results.md)
+ [Specificare una posizione dei risultati delle query](query-results-specify-location.md)
+ [Download dei file dei risultati delle query mediante la console Athena](saving-query-results.md)
+ [Come visualizzare le query recenti nella console Athena](queries-viewing-history.md)
+ [Scaricamento di più query recenti in un file CSV](queries-downloading-multiple-recent-queries-to-csv.md)
+ [Configurazione delle opzioni di visualizzazione delle query recenti](queries-recent-queries-configuring-options.md)
+ [Conservazione della cronologia delle query per più di 45 giorni](querying-keeping-query-history.md)
+ [Ricerca dei file di output delle query in Amazon S3](querying-finding-output-files.md)
# Risultati delle query gestite
Con i risultati delle query gestite, è possibile eseguire query SQL senza fornire un bucket Amazon S3 per lo storage dei risultati delle query. Questo evita di dover fornire, gestire, controllare l’accesso e pulire i bucket S3. Per iniziare, creare un nuovo gruppo di lavoro o modificare un gruppo di lavoro esistente. In **Query result configuration**, seleziona **Athena managed**.
**Funzionalità principali**
+ Semplificare il flusso di lavoro eliminando la necessità di scegliere una posizione per il bucket S3 prima di eseguire le query.
+ Non vi sono costi aggiuntivi per l’utilizzo dei risultati delle query gestite e l’eliminazione automatica dei risultati delle query riduce il sovraccarico amministrativo e la necessità di processi separati di pulizia dei bucket S3.
+ Iniziare è semplice: i gruppi di lavoro nuovi e preesistenti possono essere configurati facilmente per utilizzare i risultati delle query gestite. Nel tuo account puoi avere una combinazione di risultati di query gestiti da Athena e gestiti dai clienti. AWS
+ Autorizzazioni IAM semplificate con accesso alla lettura dei risultati tramite `GetQueryResults` e `GetQueryResultsStream` sono legate a singoli gruppi di lavoro.
+ I risultati delle query vengono crittografati automaticamente con chiavi di proprietà o di AWS proprietà del cliente a tua scelta.
## Considerazioni e limitazioni
****
+ L’accesso ai risultati delle query è gestito a livello di gruppo di lavoro in Athena. A tal fine, sono necessarie autorizzazioni esplicite ad azioni IAM `GetQueryResults` e `GetQueryResultsStream` sullo specifico gruppo di lavoro. L’azione `GetQueryResults` determina chi può recuperare i risultati di una query completata in un formato impaginato, mentre l’azione `GetQueryResultsStream` determina chi può trasmettere in streaming i risultati di una query completata (comunemente utilizzata dai driver Athena).
+ Non è possibile scaricare dalla console i file dei risultati delle query di dimensioni superiori a 200 MB. Utilizzare l’istruzione `UNLOAD` per scrivere risultati di dimensioni superiori a 200 MB in una posizione che è possibile scaricare separatamente.
+ La funzionalità dei risultati delle query gestite non supporta il [Riutilizzo dei risultati delle query](reusing-query-results.md).
+ I risultati delle query sono disponibili per 24 giorni. I risultati delle query vengono archiviati gratuitamente durante questo periodo. Dopo questo periodo, i risultati delle query vengono poi automaticamente eliminati.
## Creare o modificare un gruppo di lavoro con risultati di query gestite
Per creare un gruppo di lavoro o aggiornare un gruppo di lavoro esistente con i risultati di query gestiti dalla console:
1. Apri la console Athena all'indirizzo [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/).
1. Nel riquadro di navigazione a sinistra, scegliere **Workgroups**.
1. Scegliere **Create Workgroup** per creare un nuovo gruppo di lavoro o modificare un gruppo di lavoro esistente dall’elenco.
1. In **Query result configuration**, scegliere **Athena managed**.
![\[Menu di configurazione dei risultati delle query.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/athena-managed.png)
1. Per **Encrypt query results**, scegliere l’opzione di crittografia desiderata. Per ulteriori informazioni, consulta [Scegliere la crittografia dei risultati della query](#managed-query-results-encryption-at-rest).
1. Inserisci tutti gli altri dettagli richiesti e scegliere **Salva modifiche**.
## Scegliere la crittografia dei risultati della query
Sono disponibili due opzioni per la configurazione della crittografia:
+ **Crittografa utilizzando una chiave AWS proprietaria**: questa è l'opzione predefinita quando si utilizzano i risultati delle query gestite. Scegliete questa opzione se desiderate che i risultati delle query vengano crittografati con una chiave AWS proprietaria.
+ **Encrypt using customer managed key**: scegli questa opzione se desideri crittografare e decrittografare i risultati delle query con una chiave gestita dal cliente. Per utilizzare una chiave gestita dal cliente, aggiungere il servizio Athena nell’elemento principale della sezione relativa alla policy della chiave. Per ulteriori informazioni, consulta [Imposta una politica AWS KMS chiave per i risultati delle query gestite](#managed-query-results-set-up). Per eseguire correttamente le query, l'utente che esegue le query deve essere autorizzato ad accedere alla AWS KMS chiave.
## Imposta una politica AWS KMS chiave per i risultati delle query gestite
La sezione sulla policy della chiave `Principal` specifica chi può utilizzare questa chiave. La funzionalità dei risultati delle query gestite introduce il principale `encryption.athena.amazonaws.com` che è necessario specificare nella sezione `Principal` . Questo servizio principale è destinato specificamente alle chiavi di accesso non di proprietà di Athena. È inoltre necessario aggiungere le azioni `kms:Decrypt`, `kms:GenerateDataKey`, `kms:DescribeKey` alla policy della chiave utilizzata per accedere ai risultati gestiti. Queste tre azioni sono le azioni minime consentite.
I risultati delle query gestite utilizzano l’ARN del gruppo di lavoro per il [contesto di crittografia](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context). Poiché la `Principal` sezione è un AWS servizio, è inoltre necessario aggiungere `aws:sourceArn` e `aws:sourceAccount` completare le condizioni chiave della politica. L'esempio seguente mostra una politica AWS KMS chiave con autorizzazioni minime per un singolo gruppo di lavoro.
```
{
"Sid": "Allow athena service principal to use the key",
"Effect": "Allow",
"Principal": {
"Service": "encryption.athena.amazonaws.com"
},
"Action": [
"kms:Decrypt",
"kms:GenerateDataKey",
"kms:DescribeKey"
],
"Resource": "arn:aws:kms:us-east-1:{account-id}:key/{key-id}",
"Condition": {
"ArnLike": {
"kms:EncryptionContext:aws:athena:arn": "arn:aws:athena:us-east-1:{account-id}:workgroup/{workgroup-name}",
"aws:SourceArn": "arn:aws:athena:us-east-1:{account-id}:workgroup/{workgroup-name}"
},
"StringEquals": {
"aws:SourceAccount": "{account-id}"
}
}
```
L'esempio seguente di politica AWS KMS chiave consente a tutti i gruppi di lavoro all'interno dello stesso account di *account-id* utilizzare la stessa chiave. AWS KMS
```
{
"Sid": "Allow athena service principal to use the key",
"Effect": "Allow",
"Principal": {
"Service": "encryption.athena.amazonaws.com"
},
"Action": [
"kms:Decrypt",
"kms:GenerateDataKey",
"kms:DescribeKey"
],
"Resource": "arn:aws:kms:us-east-1:account-id:key/{key-id}",
"Condition": {
"ArnLike": {
"kms:EncryptionContext:aws:athena:arn": "arn:aws:athena:us-east-1:account-id:workgroup/*",
"aws:SourceArn": "arn:aws:athena:us-east-1:account-id:workgroup/*"
},
"StringEquals": {
"aws:SourceAccount": "account-id"
}
}
}
```
Oltre alle autorizzazioni Athena e Amazon S3, bisogna anche ottenere autorizzazioni per eseguire `kms:GenerateDataKey` e azioni `kms:Decrypt`. Per ulteriori informazioni, consulta [Autorizzazioni di accesso a dati crittografati in Amazon S3](encryption.md#permissions-for-encrypting-and-decrypting-data).
Per ulteriori informazioni sulla crittografia dei risultati delle query gestite, consultare [Crittografare i risultati delle query gestite](encrypting-managed-results.md).
# Crittografare i risultati delle query gestite
Athena offre le seguenti opzioni per crittografare [Risultati delle query gestite](managed-results.md).
## Crittografa utilizzando una chiave proprietaria AWS
Questa è l’opzione di default quando si utilizzano i risultati di query gestite. Questa opzione indica che si desidera crittografare i risultati delle query utilizzando una chiave AWS proprietaria. AWS le chiavi di proprietà non sono archiviate nel tuo AWS account e fanno parte di una raccolta di chiavi KMS di cui AWS è proprietaria. Non ti viene addebitata alcuna commissione quando utilizzi chiavi AWS di proprietà e queste non vengono conteggiate nelle AWS KMS quote relative al tuo account.
## Crittografa utilizzando una chiave gestita AWS KMS dal cliente
Le chiavi gestite dal cliente sono le chiavi KMS del tuo AWS account che crei, possiedi e gestisci. Si ha il controllo completo di queste chiavi KMS, tra cui la definizione e il mantenimento delle policy delle chiavi, delle policy IAM e delle concessioni, l’abilitazione e la disabilitazione di tali chiavi, la rotazione del materiale crittografico, l’aggiunta di tag, la creazione di alias che fanno riferimento a esse e la pianificazione per l’eliminazione. Per ulteriori informazioni, consultare [Chiavi master del cliente](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#customer-cmk).
## In che modo Athena utilizza la chiave gestita dal cliente per crittografare i risultati
Quando si specifica una chiave gestita dal cliente, Athena la utilizza per crittografare i risultati della query quando vengono archiviati nei risultati delle query gestite. La stessa chiave viene utilizzata per decrittografare i risultati quando si effettua chiamata `GetQueryResults`. Quando si imposta lo stato della chiave gestita dal cliente su disabilitato o se ne pianifica l’eliminazione, si impedisce ad Athena e a tutti gli utenti di crittografare o decrittografare i risultati con quella chiave.
DynamoDB utilizza la crittografia a busta e la gerarchia delle chiavi per criptare i dati. La chiave di crittografia AWS KMS viene utilizzata per generare e decrittografare la chiave root di questa gerarchia.
Ogni risultato viene crittografato utilizzando la chiave gestita dal cliente configurata nel gruppo di lavoro al momento della crittografia. Il passaggio della chiave a una chiave gestita dal cliente diversa o a una chiave AWS di proprietà non cripta nuovamente i risultati esistenti con la nuova chiave. L’eliminazione e la disabilitazione di una particolare chiave gestita dal cliente influiscono solo sulla decrittografia dei risultati crittografati dalla chiave.
Athena ha bisogno dell’accesso alla chiave di crittografia per eseguire operazioni `kms:Decrypt`, `kms:GenerateDataKey` e `kms:DescribeKey` per crittografare e decrittografare i risultati. Per ulteriori informazioni, consulta [Autorizzazioni di accesso a dati crittografati in Amazon S3](encryption.md#permissions-for-encrypting-and-decrypting-data).
Il principale che invia la query utilizzando l’API `StartQueryExecution` e legge i risultati utilizzando `GetQueryResults` deve inoltre disporre dell’autorizzazione alla chiave gestita dal cliente e alle operazioni `kms:Decrypt`, `kms:GenerateDataKey` e `kms:DescribeKey` oltre alle autorizzazioni Athena e Amazon S3. Per ulteriori informazioni, vedere [Politiche chiave](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html#key-policy-default-allow-users) in. AWS KMS
# Specificare una posizione dei risultati delle query
La posizione dei risultati delle query utilizzata da Athena è determinata da una combinazione di impostazioni del gruppo di lavoro e *impostazioni lato client*. Le impostazioni lato client sono basate sulla modalità di esecuzione della query.
+ Se esegui la query utilizzando la console Athena, la **posizione dei risultati delle query** immessa in **Impostazioni** nella barra di navigazione determina l'impostazione lato client.
+ Se esegui la query utilizzando l'API Athena, il `OutputLocation` parametro dell'[StartQueryExecution](https://docs.aws.amazon.com/athena/latest/APIReference/API_StartQueryExecution.html)azione determina l'impostazione lato client.
+ Se utilizzi i driver ODBC o JDBC per eseguire le query, la proprietà `S3OutputLocation` specificata nell'URL di connessione determina l'impostazione lato client.
**Importante**
Quando esegui una query utilizzando l'API o il driver ODBC o JDBC, l'impostazione della console non viene applicata.
Ogni configurazione del gruppo di lavoro ha un'opzione [Override client-side settings (Ignora impostazioni lato client)](https://docs.aws.amazon.com/athena/latest/ug/workgroups-settings-override.html) che può essere abilitata. Quando questa opzione è abilitata, le impostazioni del gruppo di lavoro hanno la precedenza sulle impostazioni lato client applicabili quando un principale IAM associato a tale gruppo di lavoro esegue la query.
## Posizioni di default create in precedenza
In precedenza in Athena, se si eseguiva una query senza specificare un valore per **Query result location** (Posizione dei risultati delle query) e l'impostazione della posizione dei risultati della query non è stata sovrascritta da un gruppo di lavoro, Athena creava una posizione predefinita per l'utente. La posizione predefinita era`aws-athena-query-results-MyAcctID-MyRegion`, *MyAcctID* dov'era l'ID dell'account Amazon Web Services del principale IAM che eseguiva la query e la regione in cui *MyRegion* veniva eseguita la query (ad esempio,`us-west-1`.)
Ora, prima di poter eseguire una query Athena in una Regione in cui l'account non ha utilizzato in Athena precedenza, è necessario specificare una posizione dei risultati delle query o utilizzare un gruppo di lavoro che sostituisce l'impostazione della posizione dei risultati delle query Sebbene Athena non crei più una posizione predefinita dei risultati delle query, le posizioni predefinite `aws-athena-query-results-MyAcctID-MyRegion` create in precedenza rimangono valide ed è possibile continuare a utilizzarle.
**Topics**
+ [Posizioni di default create in precedenza](#query-results-specify-location-previous-defaults)
+ [Specificare una posizione dei risultati delle query utilizzando la console Athena](query-results-specify-location-console.md)
+ [Specificare una posizione dei risultati delle query utilizzando un gruppo di lavoro](query-results-specify-location-workgroup.md)
# Specificare una posizione dei risultati delle query utilizzando la console Athena
Prima di poter eseguire una query, è necessario specificare una posizione del bucket dei risultati delle query in Amazon S3, o utilizzare un gruppo di lavoro che ha specificato un bucket e la cui configurazione sostituisce le impostazioni del client.
**Per specificare un percorso dei risultati della query di impostazione lato client utilizzando la console Athena**
1. [Passa ](switching-workgroups.md) al gruppo di lavoro per il quale desideri specificare una posizione per i risultati delle query. Il nome del gruppo di lavoro predefinito è **primario**.
1. Dalla barra di navigazione scegliere **Impostazioni**.
1. Scegli **Manage** (Gestisci) sulla barra di navigazione.
1. Per **Manage settings** (Gestisci impostazioni), effettua una delle seguenti operazioni:
+ Nella casella **Location of query result** (Posizione dei risultati delle query) inserisci il percorso del bucket creato in Amazon S3 per i risultati delle query. Aggiungi al percorso il prefisso `s3://`.
+ Scegli **Browse S3** (Sfoglia S3), scegli il bucket Amazon S3 creato per la tua regione corrente, quindi seleziona **Choose** (Scegli).
**Nota**
Se utilizzi un gruppo di lavoro che specifica una posizione dei risultati delle query per tutti gli utenti del gruppo di lavoro, l'opzione per modificare la posizione dei risultati delle query non è disponibile.
1. (Facoltativo) Scegli **View lifecycle configuration** (Visualizza configurazione del ciclo di vita) per visualizzare e configurare le [regole del ciclo di vita di Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) nel bucket dei risultati delle query. Le regole del ciclo di vita di Amazon S3 che crei possono essere regole di scadenza o regole di transizione. Le regole di scadenza eliminano automaticamente i risultati delle query dopo un certo periodo di tempo. Le regole di transizione li spostano su un altro livello di archiviazione di Amazon S3. Per ulteriori informazioni, consulta [Configurazione del ciclo di vita per un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/how-to-set-lifecycle-configuration-intro.html) nella Guida per l'utente di Amazon Simple Storage Service.
1. (Facoltativo) Per **Expected bucket owner**, inserisci l'ID di Account AWS quello che prevedi sia il proprietario del bucket di posizione di output. Si tratta di una misura di sicurezza aggiuntiva. Se l'ID account del proprietario del bucket non corrisponde all'ID specificato, i tentativi di output nel bucket avranno esito negativo. Per informazioni dettagliate, consulta [Verifica della proprietà del bucket con condizione del proprietario del bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucket-owner-condition.html) nella *Guida per l'utente di Amazon S3*.
**Nota**
L'impostazione prevista per il proprietario del bucket si applica solo al percorso di output di Amazon S3 specificato per i risultati delle query di Athena. Non si applica ad altri percorsi Amazon S3 come i percorsi dell'origine dati nei bucket Amazon S3 esterni, i percorsi relativi alle tabelle di destinazione con istruzioni `CTAS` e `INSERT INTO`, i percorsi di output delle istruzioni `UNLOAD`, le operazioni del bucket spill per le query federate o le query `SELECT` eseguite su una tabella in un altro account.
1. (Facoltativo) Scegli **Encrypt query results** (Esegui crittografia dei risultati delle query) se desideri crittografare i risultati delle query archiviati in Amazon S3. Per ulteriori informazioni sulla crittografia in Athena, consulta [Crittografia dei dati a riposo](encryption.md).
1. (Facoltativo) Scegli **Assegna al proprietario del bucket il controllo completo sui risultati della query** per concedere il pieno controllo sui risultati della query al proprietario del bucket quando [ACLs sono abilitati](https://docs.aws.amazon.com/AmazonS3/latest/userguide/about-object-ownership.html) per il bucket dei risultati della query. Ad esempio, se la posizione dei risultati della query è di proprietà di un altro account, puoi concedere la proprietà e il controllo completo dei risultati della query all'altro account. Per ulteriori informazioni, consulta la sezione [Controllo della proprietà degli oggetti e disattivazione ACLs del bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/about-object-ownership.html) nella *Amazon S3* User Guide.
1. Scegli **Save** (Salva).
# Specificare una posizione dei risultati delle query utilizzando un gruppo di lavoro
Puoi specificare la posizione dei risultati delle query in una configurazione del gruppo di lavoro utilizzando AWS CLI, Console di gestione AWS, o l'API Athena.
Quando usi il AWS CLI, specifica la posizione dei risultati della query utilizzando il `OutputLocation` parametro dell'`--configuration`opzione quando esegui il [https://docs.aws.amazon.com/cli/latest/reference/athena/create-work-group.html](https://docs.aws.amazon.com/cli/latest/reference/athena/create-work-group.html)comando or. [https://docs.aws.amazon.com/cli/latest/reference/athena/update-work-group.html](https://docs.aws.amazon.com/cli/latest/reference/athena/update-work-group.html)
**Per specificare la posizione dei risultati delle query per un gruppo di lavoro utilizzando la console Athena**
1. Se il pannello di navigazione della console non è visibile, scegli il menu di espansione a sinistra.
![\[Scegli il menu di espansione.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/nav-pane-expansion.png)
1. Nel pannello di navigazione, seleziona **Workgroups** (Gruppi di lavoro).
1. Nell'elenco dei gruppi di lavoro, scegli il collegamento del gruppo di lavoro che desideri configurare.
1. Scegli **Modifica**.
1. Per **la posizione e la crittografia dei risultati delle query)** esegui una delle seguenti operazioni:
+ Nella casella **Location of query result** (Posizione dei risultati delle query) inserisci il percorso del bucket in Amazon S3 per i risultati delle query. Aggiungi al percorso il prefisso `s3://`.
+ Scegli **Browse S3** (Sfoglia S3), scegli il bucket Amazon S3 per la tua regione corrente che desideri utilizzare, quindi seleziona **Choose** (Scegli).
1. (Facoltativo) In **Expected bucket owner**, inserite l'ID del bucket di posizione di output Account AWS che ritenete sia il proprietario del bucket di posizione di output. Si tratta di una misura di sicurezza aggiuntiva. Se l'ID account del proprietario del bucket non corrisponde all'ID specificato, i tentativi di output nel bucket avranno esito negativo. Per informazioni dettagliate, consulta [Verifica della proprietà del bucket con condizione del proprietario del bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucket-owner-condition.html) nella *Guida per l'utente di Amazon S3*.
**Nota**
L'impostazione prevista per il proprietario del bucket si applica solo al percorso di output di Amazon S3 specificato per i risultati delle query di Athena. Non si applica ad altri percorsi Amazon S3 come i percorsi dell'origine dati nei bucket Amazon S3 esterni, i percorsi relativi alle tabelle di destinazione con istruzioni `CTAS` e `INSERT INTO`, i percorsi di output delle istruzioni `UNLOAD`, le operazioni del bucket spill per le query federate o le query `SELECT` eseguite su una tabella in un altro account.
1. (Facoltativo) Scegli **Encrypt query results** (Esegui crittografia dei risultati delle query) se desideri crittografare i risultati delle query archiviati in Amazon S3. Per ulteriori informazioni sulla crittografia in Athena, consulta [Crittografia dei dati a riposo](encryption.md).
1. (Facoltativo) Scegli **Assegna al proprietario del bucket il controllo completo sui risultati della query** per concedere il pieno controllo sui risultati della query al proprietario del bucket quando [ACLs sono abilitati](https://docs.aws.amazon.com/AmazonS3/latest/userguide/about-object-ownership.html) per il bucket dei risultati della query. Ad esempio, se la posizione dei risultati della query è di proprietà di un altro account, puoi concedere la proprietà e il controllo completo dei risultati della query all'altro account.
Se l'impostazione di S3 Object Ownership del bucket è **Bucket owner preferred** (Preferita dal proprietario del bucket), il proprietario del bucket possiede anche tutti gli oggetti dei risultati della query scritti da questo gruppo di lavoro. Ad esempio, se il gruppo di lavoro di un account esterno abilita questa opzione e imposta la posizione dei risultati della query sul bucket Amazon S3 del tuo account con S3 Object Ownership impostato su **Bucket owner preferred** (Preferita dal proprietario del bucket), possiedi e hai il pieno controllo di accesso ai risultati delle query del gruppo di lavoro esterno.
Selezionando questa opzione, quando l'impostazione di S3 Object Ownership del bucket dei risultati della query è **Bucket owner enforced** (Applicata dal proprietario del bucket), non si avrà alcun effetto. Per ulteriori informazioni, consulta la sezione [Controllo della proprietà degli oggetti e disattivazione ACLs del bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/about-object-ownership.html) nella *Amazon S3* User Guide.
1. Se desideri richiedere a tutti gli utenti del gruppo di lavoro di utilizzare la posizione dei risultati della query specificata, scorri verso il basso fino alla sezione **Settings** (Impostazioni) e seleziona **Override client-side settings** (Ignora impostazioni lato client).
1. Scegli **Save changes** (Salva modifiche).
# Download dei file dei risultati delle query mediante la console Athena
Puoi scaricare il file CSV dei risultati delle query dal riquadro della query subito dopo averla eseguita. È possibile anche scaricare i risultati delle query dalle query recenti nella scheda **Recent queries** (Query recenti).
**Nota**
I file dei risultati delle query Athena sono file di dati che contengono informazioni che possono essere configurate dai singoli utenti. Alcuni programmi che leggono e analizzano questi dati possono interpretare potenzialmente alcuni dei dati come comandi (CSV Injection). Per questo motivo, quando importi i risultati delle query dei dati CSV in un programma di calcolo, il programma potrebbe mostrare avvisi su problemi di sicurezza. Per mantenere il sistema sicuro, è consigliabile scegliere sempre di disabilitare i link o le macro dai risultati delle query scaricati.
**Come eseguire una query e scaricare i risultati delle query**
1. Inserisci la query nell'editor di query, quindi scegli **Run** (Esegui).
Al termine dell'esecuzione della query, il riquadro **Results (Risultati)** mostra i risultati della query.
1. Per scaricare un file CSV dei risultati delle query, scegli **Download results** (Scarica risultati) sopra il riquadro dei risultati della query. A seconda del browser e della sua configurazione, potrebbe essere necessario confermare il download.
![\[Salvataggio dei risultati delle query in un file .csv nella console Athena.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/getting-started-query-results-download-csv.png)
**Per scaricare il file dei risultati di una query precedente**
1. Scegli **Recent queries** (Query recenti).
![\[Scegli Recent queries (Query recenti) per visualizzare le query precedenti.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/getting-started-recent-queries.png)
1. Utilizza la casella di ricerca per trovare la query, selezionala e scegli quindi **Download results** (Scarica risultati).
**Nota**
Non è possibile utilizzare l'opzione **Download results** (Scarica risultati) per recuperare i risultati delle query che sono stati eliminati manualmente o recuperare i risultati delle query che sono stati eliminati o spostati in un'altra posizione in base alle [regole del ciclo](https://docs.aws.amazon.com/AmazonS3/latest/userguide/how-to-set-lifecycle-configuration-intro.html) di vita di Amazon S3.
![\[Scegli Recent queries (Query recenti) per trovare e scaricare i risultati delle query precedenti.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/querying-recent-queries-tab-download.png)
# Come visualizzare le query recenti nella console Athena
È possibile utilizzare la console Athena per vedere quali query sono riuscite o non riuscite e visualizzare i dettagli di errore per quelle non riuscite. Athena mantiene la cronologia delle query per 45 giorni.
**Come visualizzare le query recenti nella console Athena**
1. Apri la console Athena all'indirizzo [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Scegli **Recent queries** (Query recenti). La scheda **Recent queries** (Query recenti) mostra informazioni su ogni query eseguita.
1. Per aprire un'istruzione di query nell'editor di query, scegli l'ID di esecuzione della query.
![\[Scegli l'ID di esecuzione di una query per visualizzarlo nell'editor di query.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/querying-view-query-statement.png)
1. Per visualizzare i dettagli di una query non riuscita, scegli il collegamento **Failed** (Non riuscito) per la query.
![\[Seleziona il collegamento Failed (Non riuscito) per una query per visualizzare le informazioni sull'errore.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/querying-view-query-failure-details.png)
# Scaricamento di più query recenti in un file CSV
Puoi utilizzare la scheda **Recent queries** (Query recenti) della console Athena per esportare una o più query recenti in un file CSV per visualizzarle in formato tabellare. Il file scaricato non contiene i risultati della query, ma la stringa della query SQL stessa e altre informazioni sulla query. I campi esportati includono l'ID di esecuzione, il contenuto della stringa di query, l'ora di inizio della query, lo stato, il tempo di esecuzione, la quantità di dati scansionati, la versione del motore di query utilizzato e il metodo di crittografia. Puoi esportare un massimo di 500 query recenti o un massimo di 500 query filtrate utilizzando i criteri immessi nella casella di ricerca.
**Esportazione di una o più query recenti in un file CSV**
1. Apri la console Athena all'indirizzo [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Scegli **Recent queries** (Query recenti).
1. (Facoltativo) Utilizza la casella di ricerca per filtrare le query recenti che desideri scaricare.
1. Scegli **Download CSV** (Scarica CSV).
![\[Scegli Download CSV (Scarica CSV).\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/querying-recent-queries-csv.png)
1. Alla richiesta di salvataggio del file, scegli **Save** (Salva). Il nome del file predefinito è `Recent Queries` seguito da un timestamp (ad esempio, `Recent Queries 2022-12-05T16 04 27.352-08 00.csv`)
# Configurazione delle opzioni di visualizzazione delle query recenti
Puoi configurare le opzioni per la scheda **Recent queries** (Query recenti) come colonne da visualizzare con testo a capo.
**Configurazione delle opzioni per la scheda **Recent queries** (Query recenti)**
1. Apri la console Athena all'indirizzo [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Scegli **Recent queries** (Query recenti).
1. Scegli il pulsante delle opzioni (icona a forma di ingranaggio).
![\[Scegli il pulsante di opzione per configurare la visualizzazione delle query recenti.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/querying-recent-queries-options.png)
1. Nella finestra di dialogo **Preferences** (Preferenze), scegli il numero di righe per pagina, il comportamento del ritorno a capo e le colonne da visualizzare.
![\[Configurazione della visualizzazione delle query recenti.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/querying-recent-queries-preferences.png)
1. Scegli **Conferma**.
# Conservazione della cronologia delle query per più di 45 giorni
Se si desidera mantenere la cronologia delle query più di 45 giorni, è possibile recuperare la cronologia delle query e salvarla in un archivio dati, ad esempio Amazon S3. Per automatizzare questo processo, è possibile utilizzare le operazioni dell'API Amazon S3 e Athena e i comandi CLI. Nella procedura seguente vengono riepilogati questi passaggi.
**Per recuperare e salvare la cronologia delle query a livello di codice**
1. Utilizza l'azione [ListQueryExecutions](https://docs.aws.amazon.com/athena/latest/APIReference/API_ListQueryExecutions.html)API Athena o il comando [list-query-executions](https://docs.aws.amazon.com/cli/latest/reference/athena/list-query-executions.html)CLI per recuperare la query. IDs
1. Utilizza l'azione [GetQueryExecution](https://docs.aws.amazon.com/athena/latest/APIReference/API_GetQueryExecution.html)API Athena o il comando [get-query-execution](https://docs.aws.amazon.com/cli/latest/reference/athena/get-query-execution.html)CLI per recuperare informazioni su ogni query in base al relativo ID.
1. Utilizza l'azione dell'[PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)API Amazon S3 o il comando CLI [put-object](https://docs.aws.amazon.com/cli/latest/reference/s3api/put-object.html) per salvare le informazioni in Amazon S3.
# Ricerca dei file di output delle query in Amazon S3
I file di output delle query vengono archiviati in sottocartelle in Amazon S3 nel seguente schema di percorso, a meno che la query non si verifichi in un gruppo di lavoro la cui configurazione sostituisce le impostazioni lato client. Quando la configurazione del gruppo di lavoro sostituisce le impostazioni lato client, la query utilizza il percorso dei risultati specificato dal gruppo di lavoro.
```
QueryResultsLocationInS3/[QueryName|Unsaved/yyyy/mm/dd/]
```
+ *QueryResultsLocationInS3*è la posizione dei risultati della query specificata dalle impostazioni del gruppo di lavoro o dalle impostazioni lato client. Per ulteriori informazioni, consultare [Specificare una posizione dei risultati delle query](query-results-specify-location.md) riportata di seguito in questo documento.
+ Le seguenti sottocartelle vengono create solo per le query eseguite dalla console il cui percorso dei risultati non è stato sostituito dalla configurazione del gruppo di lavoro. Le query eseguite da AWS CLI o utilizzando l'API Athena vengono salvate direttamente in. *QueryResultsLocationInS3*
+ *QueryName* è il nome della query di cui si desidera salvare i risultati. Se la query è stata eseguita ma non è stata salvata, viene utilizzato `Unsaved`.
+ *yyyy/mm/dd*è la data di esecuzione della query.
I file associati a una query `CREATE TABLE AS SELECT` vengono archiviati in una sottocartella `tables` del modello precedente.
## Identificazione dei file di output delle query
I file vengono salvati nella posizione dei risultati delle query in Amazon S3 in base al nome, all'ID e alla data di esecuzione della query. I file per ogni query sono denominati utilizzando*QueryID*, che è un identificatore univoco che Athena assegna a ogni query durante l'esecuzione.
Vengono salvati i seguenti tipi di file:
| Tipo di file | ModellI di denominazione dei file | Description |
| --- | --- | --- |
| **File dei risultati delle query** | `QueryID.csv` `QueryID.txt` | I file dei risultati delle query DML vengono salvati in formato CSV (valori separati da virgola). I risultati delle query DDL vengono salvati come file di testo normale. Puoi scaricare i file dei risultati dalla console dal riquadro **Risultati** quando utilizzi la console o dalla **Cronologia** della query. Per ulteriori informazioni, consulta [Download dei file dei risultati delle query mediante la console Athena](saving-query-results.md). |
| **File di metadati delle query** | `QueryID.csv.metadata` `QueryID.txt.metadata` | I file di metadati delle query DML e DDL vengono salvati in formato binario e non sono leggibili dall'uomo. L'estensione del file corrisponde al file dei risultati della query. Athena utilizza i metadati durante la lettura dei risultati delle query utilizzando l'operazione `GetQueryResults`. Anche se questi file possono essere eliminati, è sconsigliato perché informazioni importanti sulla query andrebbero perse. |
| **File manifest di dati** | `QueryID-manifest.csv` | I file manifest di dati vengono generati per tenere traccia dei file Athena creati da nelle posizioni dell'origine dati Amazon S3 quando viene eseguita una query [INSERT INTO](insert-into.md). Se una query ha esito negativo, il manifest tiene traccia anche dei file che la query intendeva scrivere. Il manifest è utile per identificare i file orfani risultanti da una query non riuscita. |
## Utilizzate il AWS CLI per identificare la posizione e i file di output delle interrogazioni
Per utilizzare il AWS CLI per identificare la posizione di output della query e i file dei risultati, eseguite il `aws athena get-query-execution` comando, come illustrato nell'esempio seguente. Sostituisci *abc1234d-5efg-67hi-jklm-89n0op12qr34* con l'ID della query.
```
aws athena get-query-execution --query-execution-id abc1234d-5efg-67hi-jklm-89n0op12qr34
```
Il comando restituisce un risultato simile al seguente. Per le descrizioni di ogni parametro di output, vedere [get-query-execution](https://docs.aws.amazon.com/cli/latest/reference/athena/get-query-execution.html)nella *AWS CLI Guida ai comandi*.
```
{
"QueryExecution": {
"Status": {
"SubmissionDateTime": 1565649050.175,
"State": "SUCCEEDED",
"CompletionDateTime": 1565649056.6229999
},
"Statistics": {
"DataScannedInBytes": 5944497,
"DataManifestLocation": "s3://amzn-s3-demo-bucket/athena-query-results-123456789012-us-west-1/MyInsertQuery/2019/08/12/abc1234d-5efg-67hi-jklm-89n0op12qr34-manifest.csv",
"EngineExecutionTimeInMillis": 5209
},
"ResultConfiguration": {
"EncryptionConfiguration": {
"EncryptionOption": "SSE_S3"
},
"OutputLocation": "s3://amzn-s3-demo-bucket/athena-query-results-123456789012-us-west-1/MyInsertQuery/2019/08/12/abc1234d-5efg-67hi-jklm-89n0op12qr34"
},
"QueryExecutionId": "abc1234d-5efg-67hi-jklm-89n0op12qr34",
"QueryExecutionContext": {},
"Query": "INSERT INTO mydb.elb_log_backup SELECT * FROM mydb.elb_logs LIMIT 100",
"StatementType": "DML",
"WorkGroup": "primary"
}
}
```
# Riutilizza i risultati delle query in Athena
Quando esegui nuovamente una query in Athena, puoi scegliere facoltativamente di riutilizzare l'ultimo risultato della query memorizzato. Questa opzione può aumentare le prestazioni e ridurre i costi in termini di numero di byte scansionati. Il riutilizzo dei risultati delle query è utile se, ad esempio, si sa che i risultati non cambieranno entro un determinato periodo di tempo. Puoi specificare un'età massima per il riutilizzo dei risultati delle query. Athena utilizza il risultato memorizzato purché non sia più vecchio dell'età specificata. Per ulteriori informazioni, consulta [Ridurre i costi e migliorare le prestazioni delle query con Amazon Athena](https://aws.amazon.com/blogs/big-data/reduce-cost-and-improve-query-performance-with-amazon-athena-query-result-reuse/) nel blog sui *AWS Big Data*.
## Funzionalità principali
Quando abiliti il riutilizzo dei risultati per una query, Athena cerca un'esecuzione precedente della query all'interno dello stesso gruppo di lavoro. Se Athena trova una corrispondenza, ignora l'esecuzione e restituisce il risultato della query dell'esecuzione precedente, corrispondente. Puoi abilitare il riutilizzo dei risultati delle query per ogni singola query.
Athena riutilizza il risultato dell'ultima query quando tutte le seguenti condizioni sono vere:
+ Le stringhe di query corrispondono a quanto determinato da Athena.
+ I nomi del database e del catalogo corrispondono.
+ Il risultato precedente non è scaduto.
+ La configurazione dei risultati della query corrisponde alla configurazione dei risultati della query dell'esecuzione precedente.
+ È possibile accedere a tutte le tabelle a cui si fa riferimento nella query.
+ Hai accesso alla posizione del file S3 in cui è archiviato il risultato precedente.
Se una di queste condizioni non è soddisfatta, Athena esegue la query senza utilizzare i risultati memorizzati nella cache.
## Considerazioni e limitazioni
Quando utilizzi la funzionalità di riutilizzo dei risultati della query, tieni presenti i punti seguenti:
+ Athena riutilizza i risultati delle query solo all'interno dello stesso gruppo di lavoro.
+ La funzionalità di riutilizzo dei risultati delle query rispetta le configurazioni dei gruppi di lavoro. Se sovrascrivi la configurazione dei risultati per una query, la funzionalità viene disabilitata.
+ Sono supportate solo le query che producono set di risultati su Amazon S3. Dichiarazioni diverse da `SELECT` e non `EXECUTE` sono supportate.
+ Le tabelle Apache Hive, Apache Hudi, Apache Iceberg e Linux Foundation Delta Lake registrate con sono supportate. AWS Glue I metastore Hive esterni non sono supportati.
+ Le query che fanno riferimento a cataloghi federati o a un metastore Hive esterno non sono supportate.
+ Il riutilizzo dei risultati delle query non è supportato per le tabelle regolate da Lake Formation.
+ Il riutilizzo dei risultati delle query non è supportato quando la posizione Amazon S3 dell'origine della tabella è registrata come posizione dati in Lake Formation.
+ Le tabelle con autorizzazioni per righe e colonne non sono supportate.
+ Le tabelle con un controllo degli accessi granulare (ad esempio, il filtraggio di colonne o righe) non sono supportate.
+ Qualsiasi query che fa riferimento a una tabella non supportata non è idonea per il riutilizzo dei risultati della query.
+ Athena richiede che tu disponga delle autorizzazioni di lettura di Amazon S3 per riutilizzare il file di output generato in precedenza.
+ La funzionalità di riutilizzo dei risultati delle query presuppone che il contenuto del risultato precedente non sia stato modificato. Athena non verifica l'integrità di un risultato precedente prima di utilizzarlo.
+ Se i risultati della query eseguita precedente sono stati eliminati o spostati in una posizione diversa in Amazon S3, l'esecuzione successiva della stessa query non riutilizzerà i risultati della query.
+ È possibile che vengano restituiti risultati potenzialmente obsoleti. Athena non verifica le modifiche nei dati di origine fino al raggiungimento dell'età massima di riutilizzo specificata.
+ Se sono disponibili più risultati riutilizzabili, Athena utilizza il risultato più recente.
+ Query che utilizzano operatori o funzioni non deterministici, come `rand()` o `shuffle()`, non utilizzano risultati memorizzati nella cache. Ad esempio, `LIMIT` senza `ORDER BY` è non deterministico e non viene memorizzato nella cache, ma `LIMIT` con `ORDER BY` è deterministico e viene memorizzato nella cache.
+ Per utilizzare la funzione di riutilizzo dei risultati delle query con JDBC, la versione minima richiesta del driver è 2.0.34.1000. Per ODBC, la versione minima del driver richiesta è 1.1.19.1002. Per informazioni sul download dei driver, consulta [Connettersi ad Amazon Athena con i driver ODBC e JDBC](athena-bi-tools-jdbc-odbc.md).
+ Il riutilizzo dei risultati delle query non è supportato per query che utilizzano più di un catalogo dati.
+ Il riutilizzo dei risultati delle query non è supportato per query che includono più di 20 tabelle.
+ Per le stringhe di query di dimensioni inferiori a 100 KB, le differenze nei commenti e negli spazi vuoti vengono ignorate `INNER JOIN` e trattate come equivalenti ai fini del `JOIN` riutilizzo dei risultati. Le stringhe di query di dimensioni superiori a 100 KB devono corrispondere esattamente per riutilizzare i risultati.
+ Il risultato di una query è considerato scaduto se è più vecchio dell'età massima specificata o più vecchio dell'impostazione predefinita di 60 minuti se non è stata specificata un'età massima. L'età massima per riutilizzare i risultati della query può essere specificata in minuti, ore o giorni. L'età massima specificabile è l'equivalente di 7 giorni, indipendentemente dall'unità di tempo utilizzata.
+ [I risultati delle query gestite](https://docs.aws.amazon.com/athena/latest/ug/managed-results.html) non sono supportati.
## Come riutilizzare i risultati delle query nella console Athena
Per utilizzare la funzionalità, abilita l'opzione **Reuse query results** (Riutilizza i risultati della query) nell'editor di query di Athena.
![\[Abilita Reuse query results (Riutilizza i risultati della query) nell'editor di query di Athena.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/reusing-query-results-1.png)
**Configurazione della funzionalità di riutilizzo dei risultati delle query**
1. Nell'editor di query di Athena, sotto l'opzione **Reuse query results** (Riutilizza i risultati della query), scegli l'icona di modifica accanto a **Up to 60 minutes ago** (Massimo 60 minuti fa).
1. Nella finestra di dialogo **Edit reuse time** (Modifica tempo di riutilizzo), nella casella a destra scegli un'unità di tempo (minuti, ore o giorni).
1. Nella casella a sinistra, inserisci o scegli il numero di unità di tempo che desideri specificare. Il tempo massimo che puoi inserire è l'equivalente di sette giorni, indipendentemente dall'unità di tempo scelta.
![\[Configurazione dell'età massima per il riutilizzo dei risultati delle query\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/reusing-query-results-2.png)
1. Scegli **Conferma**.
Un banner conferma la modifica alla configurazione e l'opzione **Reuse query results** (Riutilizza i risultati della query) mostra la nuova impostazione.
# Visualizzazione di statistiche e dettagli di esecuzione per le query completate
Dopo aver eseguito una query, è possibile ottenere statistiche sui dati di input e output elaborati, visualizzare una rappresentazione grafica del tempo impiegato per ogni fase della query ed esplorare in modo interattivo i dettagli di esecuzione.
**Visualizzare le statistiche di una query completata**
1. Dopo aver eseguito una query nell'editor di Athena, seleziona la scheda **Query stats (statistiche delle query)**.
![\[Seleziona Query stats (statistiche delle query).\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/query-stats-1.png)
La scheda **Query stats** (statistiche delle query) fornisce le seguenti informazioni:
+ **Data processed (dati elaborati)**: mostra il numero di righe di input e byte elaborati e il numero di righe e byte di output.
+ **The Total runtime (runtime totale)**: mostra il tempo totale impiegato dalla query per l'esecuzione e una rappresentazione grafica di quanto tempo è stato impiegato per la creazione della coda, la pianificazione, l'esecuzione e l'elaborazione del servizio.
**Nota**
Il conteggio delle righe di input e output a livello di fase e le informazioni sulla dimensione dei dati non vengono visualizzati quando una query ha filtri a livello di riga definiti in Lake Formation.
1. Per esplorare in modo interattivo le informazioni sulla modalità di esecuzione della query, seleziona **Execution details (dettagli dell'esecuzione)**.
![\[Seleziona Execution details (dettagli dell’esecuzione).\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/query-stats-2.png)
La pagina **Execution details (dettagli dell’esecuzione)** mostra l'ID di esecuzione e un grafico delle fasi a base zero nella query. Le fasi sono ordinate dall'inizio alla fine, dal basso verso l'alto. L'etichetta di ogni fase mostra il tempo impiegato per l'esecuzione della fase.
**Nota**
Il runtime totale e la durata della fase di esecuzione di una query spesso differiscono in modo significativo. Ad esempio, una query con un runtime totale in minuti può mostrare il tempo di esecuzione per una fase in ore. Poiché una fase è un'unità logica di calcolo eseguita in parallelo su molte attività, il tempo di esecuzione di una fase è il tempo di esecuzione aggregato di tutte le relative attività. Nonostante questa discrepanza, il tempo di esecuzione dello stage può essere utile come indicatore relativo di quale fase ha richiesto la maggiore intensità di calcolo in una query.
![\[La pagina dei dettagli dell'esecuzione.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/query-stats-3.png)
Per navigare nel grafico, utilizza le seguenti opzioni:
+ Per ingrandire o ridurre l'immagine, fai scorrere il mouse o utilizza le icone di ingrandimento.
+ Per regolare il grafico in base alle dimensioni della schermata, seleziona l’icona **Zoom to fit (usa lo zoom per adattare l’immagine)**.
+ Per spostare il grafico, trascina il puntatore del mouse.
1. Per visualizzare maggiori dettagli di una fase, selezionala. Il riquadro dei dettagli della fase sulla destra mostra il numero di righe e byte di input e output e un albero dell’operatore.
![\[Pannello con i dettagli della fase\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/query-stats-4.png)
1. Per visualizzare i dettagli della fase a schermo intero, seleziona l'icona di espansione in alto a destra nel pannello dei dettagli.
1. Per ottenere informazioni sulle parti della fase, espandi uno o più elementi nell'albero dell’operatore.
![\[Albero dell’operatore ampliato.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/query-stats-5.png)
Per ulteriori informazioni sui dettagli dell’esecuzione, consulta [Capire i risultati dell’istruzione EXPLAIN di Athena](athena-explain-statement-understanding.md).
## Risorse aggiuntive
Per ulteriori informazioni, consulta le risorse seguenti.
[Visualizzare i piani di esecuzione per query SQL](query-plans.md)
[Utilizzo di EXPLAIN e EXPLAIN ANALYZE in Athena](athena-explain-statement.md)
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/7JUyTqglmNU)
# Utilizzo delle viste
Una visualizzazione in Amazon Athena è una tabella logica, non fisica. La query che definisce una visualizzazione viene eseguita ogni volta che si fa riferimento alla visualizzazione in una query. È possibile creare una visualizzazione da una query `SELECT` e quindi fare riferimento a questa visualizzazione nelle query future.
È possibile utilizzare due diversi tipi di viste in Athena: le viste di Athena e le viste. AWS Glue Data Catalog
## Quando usare le visualizzazioni?
È possibile creare visualizzazioni per:
+ **Eseguire query in un sottoinsieme di dati**: ad esempio, è possibile creare una visualizzazione con un sottoinsieme di colonne della tabella originale per semplificare l’esecuzione delle query sui dati.
+ **Combina tabelle**: puoi utilizzare le viste per combinare più tabelle in un'unica query. Quando si dispone di più tabelle e si desidera combinarle con `UNION ALL`, è possibile creare una visualizzazione con quell'espressione per semplificare le query sulle tabelle combinate.
+ **Nascondere la complessità delle query di base esistenti e semplificare l’esecuzione delle query da parte degli utenti**. Le query di base spesso includono join tra tabelle, espressioni nell'elenco delle colonne e altre sintassi SQL che rendono difficile la comprensione e l'esecuzione del debug. È possibile creare una visualizzazione che nasconda la complessità e semplifichi le query.
+ **Ottimizzazione delle interrogazioni**: è possibile utilizzare le viste per sperimentare tecniche di ottimizzazione per creare query ottimizzate. Ad esempio, se si trova una combinazione di condizioni `WHERE`, ordine `JOIN` o altre espressioni che dimostrano le prestazioni migliori, è possibile creare una visualizzazione con queste clausole ed espressioni. Le applicazioni possono quindi rendere relativamente semplici le query su questa visualizzazione. Se successivamente si trova un modo migliore per ottimizzare la query originale, quando si ricrea la visualizzazione, tutte le applicazioni sfruttano immediatamente la query di base ottimizzata.
+ **Nascondere i nomi delle tabelle e delle colonne sottostanti e ridurre al minimo i problemi di manutenzione** in caso di modifica di tali nomi. Se i nomi cambiano, puoi semplicemente ricreare la vista utilizzando i nuovi nomi. Tutte le query che utilizzano la visualizzazione anziché le tabelle sottostanti continuano a essere eseguite senza modifiche.
Per ulteriori informazioni, consulta [Utilizza le viste di Athena](views-console.md).
## Quando usare le AWS Glue Data Catalog visualizzazioni?
Usa le AWS Glue Data Catalog viste quando desideri un'unica vista comune su Servizi AWS Amazon Athena e Amazon Redshift. Nelle viste di Catalogo dati, le autorizzazioni di accesso sono definite dall'utente che ha creato la vista anziché dall'utente che la interroga. Questo metodo di concessione delle autorizzazioni è chiamato semantica del *definitore*.
Di seguito sono riportati casi d'uso che mostrano come è possibile utilizzare le viste di Catalogo dati.
+ **Maggiore controllo degli accessi**: crea una vista che limita l'accesso ai dati in base al livello di autorizzazioni richiesto dall'utente. Ad esempio, è possibile utilizzare le viste di Catalogo dati per impedire ai dipendenti che non lavorano nel reparto delle risorse umane di visualizzare informazioni di identificazione personale.
+ **Completezza dei record garantita**: applicando determinati filtri alla vista di Catalogo dati, puoi assicurarti che i record di dati in una vista di Catalogo dati siano sempre completi.
+ **Sicurezza avanzata**: nelle viste di Catalogo dati, la definizione della query che crea la vista deve essere intatta per assicurare la corretta creazione della vista. Ciò rende le visualizzazioni di Catalogo dati meno suscettibili ai comandi SQL da parte di soggetti malintenzionati.
+ **Accesso alle tabelle sottostanti interdetto**: la semantica del definitore consente agli utenti di accedere a una vista senza rendere loro disponibile la tabella sottostante. Solo l'utente che definisce la vista richiede l'accesso alle tabelle.
Le definizioni delle viste di Catalogo dati sono archiviate in AWS Glue Data Catalog. Ciò significa che è possibile utilizzare AWS Lake Formation per concedere l'accesso tramite concessioni di risorse, concessioni di colonne o controlli di accesso basati su tag. Per ulteriori informazioni sulla concessione e la revoca dell'accesso a Lake Formation, consulta la pagina [Granting and revoking permissions on Data Catalog resources](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-catalog-permissions.html) nella *Guida per gli sviluppatori di AWS Lake Formation *.
Per ulteriori informazioni, consulta [Utilizza le viste di Catalogo Dati in Athena](views-glue.md).
# Utilizza le viste di Athena
Le viste Athena possono essere facilmente create, aggiornate e gestite nella console Athena.
## Creazione delle viste
È possibile creare una visualizzazione nella console di Athena utilizzando un modello o eseguendo una query esistente.
**Per utilizzare un modello per creare una visualizzazione**
1. Nella console Athena, accanto a **Tables and views** (Tabelle e visualizzazioni), scegli **Create** (Crea) e quindi scegli **Create view** (Crea visualizzazione).
![\[Creazione di una visualizzazione.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/create-view.png)
Questa operazione inserisce un modello di visualizzazione modificabile nell'editor di query.
1. Modifica il modello di visualizzazione in base alle tue esigenze. Quando inserisci un nome per la visualizzazione nell'istruzione, ricorda che i nomi delle visualizzazioni non possono contenere caratteri speciali diversi dal carattere di sottolineatura `(_)`. Per informazioni, consulta [Nomi di tabelle, database e colonne](tables-databases-columns-names.md). Evitare di utilizzare [Impostare il carattere escape di parole chiave riservate nelle query](reserved-words.md) per nominare le visualizzazioni.
Per ulteriori informazioni sulla creazione di visualizzazioni, consulta [CREATE VIEW e CREATE PROTECTED MULTI DIALECT VIEW](create-view.md) e [Esempi di visualizzazioni](views-examples.md).
1. Scegli **Run** (Esegui) per creare la visualizzazione. La visualizzazione viene mostrata nell'elenco delle visualizzazioni nella console Athena.
**Per creare una visualizzazione da una query esistente**
1. Utilizza l'editor di query Athena per eseguire una query esistente.
1. Nella finestra dell'editor di query, scegli **Create** (Crea) e quindi scegli **View from query** (Visualizzazione da query).
![\[Scegli Create (Crea), View from query (Visualizzazione da query).\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/create-view-from-query.png)
1. Nella finestra di dialogo **Create view** (Crea visualizzazione), inserisci un nome per la visualizzazione, quindi scegli **Create** (Crea). I nomi delle visualizzazioni non possono contenere caratteri speciali, diversi dal carattere di sottolineatura `(_)`. Per informazioni, consulta [Nomi di tabelle, database e colonne](tables-databases-columns-names.md). Evitare di utilizzare [Impostare il carattere escape di parole chiave riservate nelle query](reserved-words.md) per nominare le visualizzazioni.
Athena aggiunge la visualizzazione all'elenco delle visualizzazioni nella console e mostra l'istruzione `CREATE VIEW` per la visualizzazione nell'editor di query.
**Note**
+ Se si elimina una tabella su cui è basata una tabella e quindi si cerca di eseguire la visualizzazione, Athena mostra un messaggio di errore.
+ È possibile creare una visualizzazione nidificata, ovvero una visualizzazione sopra una visualizzazione esistente. Athena ti impedisce di eseguire una visualizzazione ricorsiva che fa riferimento a se stessa.
# Esempi di visualizzazioni
Per visualizzare la sintassi della query di visualizzazione, utilizza [SHOW CREATE VIEW](show-create-view.md).
**Example Esempio 1**
Considera le due tabelle seguenti: una tabella `employees` con due colonne, `id` e `name`, e una tabella `salaries` con due colonne, `id` e `salary`.
In questo esempio, creiamo una vista `name_salary` denominata `SELECT` interrogazione che ottiene un elenco degli stipendi IDs mappati alle tabelle e: `employees` `salaries`
```
CREATE VIEW name_salary AS
SELECT
employees.name,
salaries.salary
FROM employees, salaries
WHERE employees.id = salaries.id
```
**Example Esempio 2**
Nell'esempio seguente, creiamo una visualizzazione denominata `view1` che consente di nascondere la sintassi delle query più complesse.
Questa visualizzazione viene eseguita su due tabelle, `table1` e `table2`, ognuna delle quali è una query `SELECT` diversa. La visualizzazione seleziona le colonne di `table1` e unisce i risultati con `table2`. Il join si basa sulla colonna `a` presente in entrambe le tabelle.
```
CREATE VIEW view1 AS
WITH
table1 AS (
SELECT a,
MAX(b) AS the_max
FROM x
GROUP BY a
),
table2 AS (
SELECT a,
AVG(d) AS the_avg
FROM y
GROUP BY a)
SELECT table1.a, table1.the_max, table2.the_avg
FROM table1
JOIN table2
ON table1.a = table2.a;
```
Per informazioni relative all'esecuzione di query su visualizzazioni federate, consulta [Eseguire query su visualizzazioni federate](running-federated-queries.md#running-federated-queries-federated-views).
# Gestisci le viste di Athena
Nella console Athena, puoi:
+ Individuare tutte le visualizzazioni nel riquadro a sinistra, in cui sono elencate le tabelle.
+ Filtrare le visualizzazioni.
+ Eseguire l'anteprima di una visualizzazione, visualizzarne le proprietà, modificarla o eliminarla.
**Per mostrare le operazioni per una visualizzazione**
Una visualizzazione viene mostrata nella console solo se è già stata creata.
1. Nella console Athena, seleziona **Views** (Visualizzazioni) e quindi scegli una visualizzazione per espanderla e mostrare le colonne al suo interno.
1. Scegli i tre punti verticali accanto alla visualizzazione per visualizzare un elenco di operazioni.
![\[Il menu delle operazioni per una visualizzazione.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/view-options.png)
1. Scegli le operazioni per visualizzare in anteprima la visualizzazione, inserire il nome della visualizzazione nell'editor di query, eliminare la visualizzazione, visualizzare le proprietà della visualizzazione o visualizzare e modificare la visualizzazione nell'editor di query.
## Operazioni supportate per le visualizzazioni in Athena
Athena supporta le seguenti operazioni per le visualizzazioni.
| Dichiarazione | Description |
| --- | --- |
| [CREATE VIEW e CREATE PROTECTED MULTI DIALECT VIEW](create-view.md) | Crea una nuova visualizzazione da una query `SELECT` specificata. Per ulteriori informazioni, consulta [Creazione delle viste](views-console.md#creating-views). La clausola opzionale `OR REPLACE` consente di aggiornare la visualizzazione esistente sostituendola. |
| [DESCRIBE VIEW](describe-view.md) | Visualizza l'elenco delle colonne per la visualizzazione specificata. In questo modo è possibile esaminare gli attributi di una visualizzazione complessa. |
| [DROP VIEW](drop-view.md) | Elimina una visualizzazione esistente. La clausola facoltativa `IF EXISTS` sopprime l'errore se la visualizzazione non esiste. |
| [SHOW CREATE VIEW](show-create-view.md) | Mostra l'istruzione SQL che crea la vista specificata. |
| [SHOW VIEWS](show-views.md) | Elenca le viste nel database specificato o, se si omette il nome del database, quelle nel database corrente. Utilizza la clausola `LIKE` facoltativa con un'espressione regolare per limitare l'elenco dei nomi di vista. È possibile visualizzare l'elenco delle visualizzazioni anche nel riquadro a sinistra della console. |
| [SHOW COLUMNS](show-columns.md) | Elenca le colonne nello schema per una visualizzazione. |
# Considerazioni e limitazioni per le viste di Athena
Le visualizzazioni di Athena hanno le seguenti considerazioni e limitazioni.
## Considerazioni
Le seguenti considerazioni valgono per la creazione e l'utilizzo di visualizzazioni in Athena:
+ In Athena, puoi visualizzare in anteprima e lavorare con le viste create nella console Athena, in AWS Glue Data Catalog o con Presto in esecuzione sul cluster Amazon EMR connesso allo stesso catalogo.
+ Se hai creato visualizzazioni Athena nel Catalogo dati, le visualizzazioni vengono trattate come tabelle. È possibile utilizzare il controllo degli accessi granulare a livello di tabella nel catalogo dati per [limitare l'accesso](fine-grained-access-to-glue-resources.md) a queste visualizzazioni.
+ Athena impedisce di eseguire visualizzazioni ricorsive e, in questi casi, viene visualizzato un messaggio di errore. Una visualizzazione ricorsiva è una query di visualizzazione che fa riferimento a se stessa.
+ Athena visualizza un messaggio di errore quando rileva viste non aggiornate. Una vista obsoleta viene segnalata quando si verifica una delle seguenti operazioni:
+ La vista fa riferimento a tabelle o database che non esistono.
+ Una modifica dello schema o dei metadati viene effettuata in una tabella di riferimento.
+ Una tabella di riferimento viene eliminata e ricreata con uno schema o una configurazione diversa.
+ È possibile creare ed eseguire visualizzazioni nidificate a condizione che la query alla base della visualizzazione nidificata sia valida e le tabelle e i database esistano.
## Limitazioni
+ I nomi delle visualizzazioni Athena non possono contenere caratteri speciali, diversi dal trattino basso `(_)`. Per ulteriori informazioni, consulta [Nomi di tabelle, database e colonne](tables-databases-columns-names.md).
+ Occorre evitare di utilizzare parole chiave per nominare le visualizzazioni. Se si utilizzano parole chiave riservate, occorre utilizzare le virgolette doppie per racchiudere le parole chiave riservate nella query sulle visualizzazioni. Per informazioni, consulta [Impostare il carattere escape di parole chiave riservate nelle query](reserved-words.md).
+ Non è possibile utilizzare le viste create in Athena con metastore Hive esterni o. UDFs Per informazioni sull'utilizzo di visualizzazioni create esternamente in Hive, consulta [Lavorare con le visualizzazioni Hive](hive-views.md).
+ Non è possibile utilizzare visualizzazioni con funzioni geospaziali.
+ Non è possibile utilizzare le visualizzazioni per gestire il controllo degli accessi sui dati in Amazon S3. Per eseguire query su una visualizzazione, è necessario disporre delle autorizzazioni per accedere ai dati archiviati in Amazon S3. Per ulteriori informazioni, consulta [Controllo dell’accesso ad Amazon S3 da Athena](s3-permissions.md).
+ Sebbene l’esecuzione di query sulle visualizzazioni tra gli account sia supportata nella versione 3 del motore Athena, non puoi creare una visualizzazione che includa più account AWS Glue Data Catalog. Per ulteriori informazioni sull'accesso tra account ai cataloghi dati, consulta [Configurare l'accesso tra account ai cataloghi di AWS Glue dati](security-iam-cross-account-glue-catalog-access.md).
+ Le colonne di metadati nascosti Hive o Iceberg `$bucket`, `$file_modified_time`, `$file_size` e `$partition` non sono supportate per le visualizzazioni in Athena. Per informazioni sull'utilizzo della colonna dei metadati `$path` in Athena, consulta [Ottenere le posizioni dei file per i dati di origine in Amazon S3](select.md#select-path).
# Utilizza le viste di Catalogo Dati in Athena
La creazione di viste del catalogo dati in Amazon Athena richiede una dichiarazione speciale `CREATE VIEW`. La loro interrogazione utilizza la sintassi SQL `SELECT` convenzionale. Le viste del Data Catalog vengono anche chiamate viste *multidialettali*, o. MDVs
## Crea una vista data-catalog.
Per creare una vista Catalogo Dati in Athena, utilizza la sintassi seguente.
```
CREATE [ OR REPLACE ] PROTECTED MULTI DIALECT VIEW view_name
SECURITY DEFINER
[ SHOW VIEW JSON ]
AS athena-sql-statement
```
**Nota**
L’opzione `SHOW VIEW JSON` si applica solo alle viste del catalogo dati e non alle viste Athena. L’utilizzo dell’`SHOW VIEW JSON`opzione esegue una «esecuzione a secco» che convalida l’input e, se la convalida ha esito positivo, restituisce il codice JSON dell’oggetto AWS Glue tabella che rappresenterà la vista. La vista effettiva non viene creata. Se l’opzione `SHOW VIEW JSON` non è specificata, vengono eseguite le convalide e la vista viene creata come di consueto nel Data Catalog.
La sintassi di esempio seguente mostra come un utente del ruolo `Definer` crea la vista di Catalogo Dati di `orders_by_date`. L'esempio presuppone che il ruolo `Definer` disponga delle autorizzazioni `SELECT` complete sulla tabella `orders` del database `default`.
```
CREATE PROTECTED MULTI DIALECT VIEW orders_by_date
SECURITY DEFINER
AS
SELECT orderdate, sum(totalprice) AS price
FROM orders
WHERE order_city = 'SEATTLE'
GROUP BY orderdate
```
Per informazioni sulla sintassi, consultare la pagina [CREATE PROTECTED MULTI DIALECT VIEW](create-view.md#create-protected-multi-dialect-view).
## Interrogazione di una vista di Catalogo Dati
Dopo la creazione della vista, l’amministratore `Lake Formation` di `SELECT` può concedere le autorizzazioni per la vista di Catalogo Dati ai principali `Invoker`. I principali `Invoker` possono quindi interrogare la vista senza avere accesso alle tabelle di base sottostanti a cui la vista fa riferimento. Di seguito è riportato un esempio di query `Invoker`.
```
SELECT * from orders_by_date where price > 5000
```
## Considerazioni e limitazioni
La maggior parte delle seguenti limitazioni alla visualizzazione del catalogo dati sono specifiche di Athena. Per ulteriori limitazioni sulle visualizzazioni del Data Catalog che si applicano anche ad altri servizi, consulta la documentazione di Lake Formation.
+ Le viste di Catalogo Dati non possono fare riferimento ad altre viste, collegamenti a risorse di database o collegamenti a risorse di tabelle.
+ È possibile fare riferimento a un massimo di 10 tabelle nella definizione della vista.
+ Le tabelle non devono avere l’autorizzazione per il data lake `IAMAllowedPrincipals` in Lake Formation. Se presente, si verifica l'errore Multi Dialect views può fare riferimento solo a tabelle senza IAMAllowed le autorizzazioni Principal.
+ La posizione Amazon S3 della tabella deve essere registrata come posizione del data lake. Se la tabella non è così registrata, si verifica l’errore Multi Dialect views may only reference tables managed tables Lake Formation. Per informazioni su come registrare le posizioni Amazon S3 in [, consultare ](https://docs.aws.amazon.com/lake-formation/latest/dg/register-location.html)Registrazione di una posizione Amazon S3*AWS Lake Formation nella Guida per gli sviluppatori di *.
+ Le chiamate AWS Glue [GetTables](https://docs.aws.amazon.com/glue/latest/webapi/API_GetTables.html)e [SearchTables](https://docs.aws.amazon.com/glue/latest/webapi/API_SearchTables.html)API non aggiornano il parametro. `IsRegisteredWithLakeFormation` Per visualizzare il valore corretto del parametro, utilizza l' AWS Glue [GetTable](https://docs.aws.amazon.com/glue/latest/webapi/API_GetTable.html)API. Per ulteriori informazioni, [ SearchTables APIs consultate GetTables e non aggiornate il valore del IsRegisteredWithLakeFormation parametro nella Guida per](https://docs.aws.amazon.com/lake-formation/latest/dg/limitations.html#issue-GetTables-value) *gli AWS Lake Formation sviluppatori*.
+ Il principale `DEFINER` può essere solo un ruolo IAM.
+ Il ruolo `DEFINER` deve disporre di autorizzazioni `SELECT` (concedibili) complete per tutte le tabelle sottostanti.
+ Le viste di Catalogo Dati di `UNPROTECTED` non sono supportate.
+ Le funzioni definite dall'utente (UDFs) non sono supportate nella definizione della vista.
+ Le origini dati federate Athena non possono essere utilizzate nelle viste di Catalogo Dati.
+ Le viste di Catalogo Dati non sono supportate per i metastore Hive esterni.
+ Athena visualizza un messaggio di errore quando rileva viste non aggiornate. Una vista obsoleta viene segnalata quando si verifica una delle seguenti operazioni:
+ La vista fa riferimento a tabelle o database che non esistono.
+ Una modifica dello schema o dei metadati viene effettuata in una tabella di riferimento.
+ Una tabella di riferimento viene eliminata e ricreata con uno schema o una configurazione diversa.
## Permissions
Le viste di Catalogo Dati richiedono tre ruoli: `Lake Formation Admin`, `Definer` e `Invoker`.
+ **`Lake Formation Admin`**: ha accesso alla configurazione di tutte le autorizzazioni di Lake Formation.
+ **`Definer`**: crea la vista di Catalogo Dati. Il ruolo `Definer` deve disporre di autorizzazioni `SELECT` complete per tutte le tabelle sottostanti a cui la definizione della vista fa riferimento.
+ **`Invoker`**: può interrogare la vista di Catalogo Dati o controllarne i metadati. Per mostrare l’invocatore di una query, è possibile utilizzare la funzione DML. `invoker_principal()` Per ulteriori informazioni, consulta [invoker\$1principal ()](functions-env3.md#functions-env3-invoker-principal).
Le relazioni di fiducia del `Definer` ruolo devono consentire l'`sts:AssumeRole`azione dei responsabili del servizio AWS Glue e di Lake Formation. Per ulteriori informazioni, consulta [Prerequisiti per la firma delle immagini di container](https://docs.aws.amazon.com/lake-formation/latest/dg/working-with-views.html#views-prereqs) nella *Guida per gli sviluppatori di AWS Lake Formation *.
Sono inoltre necessarie le autorizzazioni IAM per l'accesso ad Athena. Per ulteriori informazioni, consulta [AWS politiche gestite per Amazon Athena](security-iam-awsmanpol.md).
# Viste di Catalogo dati di Glue
Puoi usare i comandi DDL per aggiornare e gestire le viste del catalogo dati.
## Aggiornamento di una vista di Catalogo Dati
L’amministratore `Lake Formation` oppure il definer possono utilizzare la sintassi `ALTER VIEW UPDATE DIALECT` per aggiornare la definizione della vista. L'esempio seguente modifica la definizione della vista per selezionare le colonne dalla tabella `returns` anziché dalla tabella `orders`.
```
ALTER VIEW orders_by_date UPDATE DIALECT
AS
SELECT return_date, sum(totalprice) AS price
FROM returns
WHERE order_city = 'SEATTLE'
GROUP BY orderdate
```
## Azioni DDL supportate per le visualizzazioni AWS Glue Data Catalog
Athena supporta le seguenti azioni per AWS Glue Data Catalog le viste.
| Dichiarazione | Description |
| --- | --- |
| [ALTER VIEW DIALECT](alter-view-dialect.md) | È possibile aggiornare le viste di Catalogo Dati aggiungendo un dialetto del motore o aggiornando o eliminando un dialetto del motore esistente. |
| [CREATE PROTECTED MULTI DIALECT VIEW](create-view.md#create-protected-multi-dialect-view) | Crea un nuovo Catalogo Dati da una query `SELECT` specificata. Per ulteriori informazioni, consulta [CREATE PROTECTED MULTI DIALECT VIEW](create-view.md#create-protected-multi-dialect-view). La clausola opzionale `OR REPLACE` consente di aggiornare la visualizzazione esistente sostituendola. |
| [DESCRIBE VIEW](describe-view.md) | Visualizza l'elenco delle colonne per la visualizzazione specificata. In questo modo è possibile esaminare gli attributi di una visualizzazione complessa. |
| [DROP VIEW](drop-view.md) | Elimina una visualizzazione esistente. La clausola facoltativa `IF EXISTS` sopprime l'errore se la visualizzazione non esiste. |
| [SHOW CREATE VIEW](show-create-view.md) | Mostra l'istruzione SQL che crea la vista specificata. |
| [SHOW VIEWS](show-views.md) | Elenca le viste nel database specificato o, se si omette il nome del database, quelle nel database corrente. Utilizza la clausola `LIKE` facoltativa con un'espressione regolare per limitare l'elenco dei nomi di vista. È possibile visualizzare l'elenco delle visualizzazioni anche nel riquadro a sinistra della console. |
| [SHOW COLUMNS](show-columns.md) | Elenca le colonne nello schema per una visualizzazione. |
# Utilizzo di query salvate
Puoi utilizzare la console Athena per salvare, modificare, eseguire, rinominare ed eliminare le query create nell'editor di query.
## Considerazioni e limitazioni
+ Puoi aggiornare il nome, la descrizione e il testo delle query salvate.
+ Puoi aggiornare le query solo nel tuo account.
+ Non puoi modificare il gruppo di lavoro o il database a cui appartiene la query.
+ Athena non conserva una cronologia delle modifiche alle query. Se desideri mantenere una versione particolare di una query, salvala con un nome diverso.
**Nota**
È ora possibile accedere alle risorse di Amazon Athena all'interno di Amazon SageMaker Unified Studio (Preview), che ti aiuta ad accedere ai dati della tua organizzazione e ad agire di conseguenza con gli strumenti migliori. Puoi migrare le query salvate da un gruppo di lavoro Athena a un progetto SageMaker Unified Studio, configurare progetti con gruppi di lavoro Athena esistenti e mantenere le autorizzazioni necessarie tramite gli aggiornamenti dei ruoli IAM. Per ulteriori informazioni, consulta [Migrazione delle risorse di Amazon Athena ad SageMaker Amazon Unified Studio](https://github.com/aws/Unified-Studio-for-Amazon-Sagemaker/tree/main/migration/athena) (Preview).
**Topics**
+ [Considerazioni e limitazioni](#saved-queries-considerations-and-limitations)
+ [Salva una query con un nome](saved-queries-name.md)
+ [Per eseguire una query salvata](saved-queries-run.md)
+ [Modificare una query salvata](saved-queries-edit.md)
+ [Rinominare o eliminare una query salvata](saved-queries-rename-or-delete.md)
+ [Rinominare un'interrogazione salvata non visualizzata](saved-queries-rename-not-displayed.md)
+ [Eliminare un'interrogazione salvata non visualizzata](saved-queries-delete-not-displayed.md)
+ [Utilizzo dell’API Athena per aggiornare le query salvate](saved-queries-update-with-api.md)
# Salva una query con un nome
**Salvare e denominare una query**
1. Nell'editor di query della console Athena, inserisci o esegui una query.
1. Sopra la finestra dell'editor di query, nella scheda della query, seleziona i tre punti verticali, quindi scegli **Save as** (Salva con nome).
1. Nella finestra di dialogo **Save query** (Salva query), inserisci un nome per la query e una descrizione facoltativa. Puoi utilizzare la finestra espandibile **Preview SQL query** (Anteprima query SQL) per verificare il contenuto della query prima di salvarla.
1. Scegli **Save query** (Salva query).
Nell'editor di query, la scheda della query mostra il nome specificato.
# Per eseguire una query salvata
**Per eseguire una query salvata**
1. Nella console Athena, scegli la scheda **Query salvate**.
1. Nell'elenco **Saved queries** (Query salvate), scegli il nome della query da eseguire.
L'editor di query visualizza la query scelta.
1. Scegli **Run** (Esegui).
# Modificare una query salvata
**Modificare una query salvata**
1. Nella console Athena, scegli la scheda **Query salvate**.
1. Nell'elenco **Saved queries** (Query salvate), scegli il nome della query da modificare.
1. Modifica la query nell'editor di query.
1. Eseguire una delle seguenti fasi:
+ Per eseguire la query, scegli **Run** (Esegui).
+ Per salvare la query, seleziona i tre punti verticali nella scheda della query, quindi scegli **Save** (Salva).
+ Per salvare la query con un nome diverso, seleziona i tre punti verticali nella scheda della query, quindi scegli **Save as** (Salva con nome).
# Rinominare o eliminare una query salvata
**Ridenominazione o eliminazione di una query salvata già visualizzata nell'editor di query**
1. Seleziona i tre punti verticali nella scheda per della query, quindi scegli **Rename** (Rinomina) o **Delete** (Elimina).
1. Segui le istruzioni per rinominare o eliminare la query.
# Rinominare un'interrogazione salvata non visualizzata
**Ridenominazione di una query salvata non visualizzata nell'editor di query**
1. Nella console Athena, scegli la scheda **Query salvate**.
1. Seleziona la casella di controllo per la query che desideri rinominare.
1. Scegliere **Rinomina**.
1. Nella finestra di dialogo **Rename query** (Rinomina query), modifica il nome e la descrizione della query. Puoi utilizzare la finestra espandibile **Preview SQL query** (Anteprima query SQL) per verificare il contenuto della query prima di rinominarla.
1. Scegli **Rename query** (Rinomina query).
La query rinominata viene visualizzata nell'elenco **Query salvate**.
# Eliminare un'interrogazione salvata non visualizzata
**Eliminazione di una query salvata non visualizzata nell'editor di query**
1. Nella console Athena, scegli la scheda **Query salvate**.
1. Seleziona una o più caselle di controllo per le query da eliminare.
1. Scegli **Elimina**.
1. Alla richiesta di conferma, scegli **Delete** (Elimina).
Le query vengono rimosse dall'elenco **Saved queries** (Query salvate).
# Utilizzo dell’API Athena per aggiornare le query salvate
Per informazioni sull'utilizzo dell'API Athena per aggiornare una query salvata, consulta l'[UpdateNamedQuery](https://docs.aws.amazon.com/athena/latest/APIReference/API_UpdateNamedQuery.html)azione nell'Athena API Reference.
# Utilizzare query parametrizzate
È possibile utilizzare le query con parametri Athena per rieseguire la stessa query con valori di parametri diversi in fase di esecuzione e contribuire a prevenire gli attacchi di iniezione SQL. In Athena, le query con parametri possono assumere la forma di parametri di esecuzione in qualsiasi query DML o istruzioni preparate in SQL.
+ Le query con parametri di esecuzione possono essere eseguite in un unico passaggio e non sono specifiche del gruppo di lavoro. È possibile inserire punti interrogativi in qualsiasi query DML per i valori che si desidera parametrizzare. Quando si esegue la query, si dichiarano i valori dei parametri di esecuzione in sequenza. La dichiarazione dei parametri e l'assegnazione dei valori per i parametri possono essere eseguite nella stessa query, ma in modo disaccoppiato. A differenza delle istruzioni preparate, è possibile selezionare il gruppo di lavoro quando si invia una query con parametri di esecuzione.
+ Le istruzioni preparate richiedono due istruzioni SQL separate: `PREPARE` e `EXECUTE`. In primo luogo, è necessario definire i parametri nel campo dell’istruzione `PREPARE`. Quindi, viene eseguita un’istruzione `EXECUTE` che fornisce i valori dei parametri definiti. Le istruzioni preparate sono specifiche del gruppo di lavoro; non è possibile eseguirle al di fuori del contesto del gruppo di lavoro a cui appartengono.
## Considerazioni e limitazioni
+ Le query parametrizzate sono supportate nella versione 2 del motore Athena e versioni successive. Per ulteriori informazioni sulle versioni del motore Athena, consulta [Controllo delle versioni del motore di Athena](engine-versions.md).
+ Attualmente, le query con parametri sono supportate solo per le istruzioni `SELECT`, `INSERT INTO`, `CTAS` e `UNLOAD`.
+ Nelle query con parametri, i parametri sono posizionali e sono indicati da `?`. Ai parametri vengono assegnati valori in base al loro ordine nella query. I parametri nominati non sono supportati.
+ Attualmente, i parametri `?` possono essere inseriti solo nella clausola `WHERE`. Sintassi come `SELECT ? FROM table` non è supportata.
+ I parametri del punto interrogativo non possono essere inseriti tra virgolette doppie o singole (ovvero,`'?'` e `"?"` non sono una sintassi valida).
+ I parametri di esecuzione SQL, affinché vengano trattati come stringhe, devono essere racchiusi tra virgolette singole anziché tra virgolette doppie.
+ Se necessario, puoi utilizzare la funzione `CAST` quando immetti un valore per un termine parametrizzato. Ad esempio, se hai una colonna del tipo `date` che è stata parametrizzata in una query e vuoi eseguire una query per la data `2014-07-05`, l'immissione `CAST('2014-07-05' AS DATE)` del valore del parametro restituirà il risultato.
+ Le istruzioni preparate sono specifiche del gruppo di lavoro e i nomi delle istruzioni preparate devono essere univoci all'interno del gruppo di lavoro.
+ Sono necessarie autorizzazioni IAM per le istruzioni preparate. Per ulteriori informazioni, consulta [Consenti l’accesso alle istruzioni preparate](security-iam-athena-prepared-statements.md).
+ Le query con parametri di esecuzione nella console Athena sono limitate a un massimo di 25 punti interrogativi.
**Topics**
+ [Considerazioni e limitazioni](#querying-with-prepared-statements-considerations-and-limitations)
+ [Utilizzare parametri di esecuzione](querying-with-prepared-statements-querying-using-execution-parameters.md)
+ [Utilizzare istruzioni preparate](querying-with-prepared-statements-querying.md)
+ [Risorse aggiuntive](querying-with-prepared-statements-additional-resources.md)
# Utilizzare parametri di esecuzione
È possibile utilizzare i placeholder del punto interrogativo in qualsiasi query DML per creare una query con parametri senza creare prima un'istruzione preparata. Per eseguire queste query, puoi utilizzare la console Athena oppure utilizzare AWS CLI l'SDK AWS e dichiarare le variabili nell'argomento. `execution-parameters`
**Topics**
+ [Utilizzare la console Athena.](querying-with-prepared-statements-running-queries-with-execution-parameters-in-the-athena-console.md)
+ [Usa il AWS CLI](querying-with-prepared-statements-running-queries-with-execution-parameters-using-the-aws-cli.md)
# Eseguire query con parametri di esecuzione nella console Athena
Quando si esegue una query con parametri che include parametri di esecuzione (punti interrogativi) nella console Athena, vengono richiesti i valori nell'ordine in cui si trovano i punti interrogativi nella query.
**Per eseguire una query con parametri di esecuzione**
1. Inserisci una query con placeholder con punti interrogativi nell'editor di Athena, come nell'esempio seguente.
```
SELECT * FROM "my_database"."my_table"
WHERE year = ? and month= ? and day= ?
```
1. Scegli **Esegui**.
1. Nella finestra di dialogo **Enter parameters (inserisci parametri)**, inserisci un valore in ordine per ciascuno dei punti interrogativi nella query.
![\[Inserisci i valori per i parametri della query in ordine\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/querying-with-prepared-statements-1.png)
1. Una volta inseriti i parametri, seleziona **Run (esegui)**. L'editor mostra i risultati della query per i valori dei parametri inseriti.
In questo caso, puoi:
+ Inserire valori di parametro diversi per la stessa query, quindi selezionare **Run again (esegui nuovamente)**.
+ Per cancellare tutti i valori inseriti contemporaneamente, seleziona **Clear (annulla)**.
+ Per modificare direttamente la query (ad esempio, per aggiungere o rimuovere punti interrogativi), chiudi innanzitutto la finestra di dialogo **Enter parameters (inserisci parametri)**.
+ Per salvare la query con parametri per un uso successivo, seleziona **Save (salva)** o **Save as (salva con nome)** e assegna un nome alla query. Per ulteriori informazioni sull'utilizzo di query salvate, consulta [Utilizzo di query salvate](saved-queries.md).
Per comodità, la finestra di dialogo **Enter parameters (inserisci parametri)** memorizza i valori inseriti in precedenza per la query purché venga utilizzata la stessa scheda nell'editor di query.
# Esegui query con parametri di esecuzione utilizzando il AWS CLI
Per utilizzare il AWS CLI per eseguire query con parametri di esecuzione, utilizzate il `start-query-execution` comando e fornite una query con parametri nell'argomento. `query-string` Poi, nell’argomento `execution-parameters` fornisci i valori per i parametri di esecuzione. Nell'esempio seguente viene descritta tale tecnica.
```
aws athena start-query-execution
--query-string "SELECT * FROM table WHERE x = ? AND y = ?"
--query-execution-context "Database"="default"
--result-configuration "OutputLocation"="s3://amzn-s3-demo-bucket;/..."
--execution-parameters "1" "2"
```
# Utilizzare istruzioni preparate
È possibile utilizzare le istruzioni preparate per eseguire ripetutamente una stessa query con parametri diversi. Un’istruzione preparata contiene segnaposto di parametro i cui valori vengono forniti al momento dell’esecuzione.
**Nota**
Il numero massimo di istruzioni preparate in un gruppo di lavoro è 1.000.
**Topics**
+ [Sintassi SQL](querying-with-prepared-statements-sql-statements.md)
+ [Utilizzare la console Athena](querying-with-prepared-statements-executing-prepared-statements-without-the-using-clause-athena-console.md)
+ [Usa il AWS CLI](querying-with-prepared-statements-cli-section.md)
# Sintassi SQL per istruzioni preparate
Puoi utilizzare le istruzioni SQL `PREPARE`, `EXECUTE` e `DEALLOCATE PREPARE` per eseguire query parametrizzate nell'editor di query della console Athena.
+ Per specificare i parametri in cui normalmente si utilizzano valori letterali, utilizzare i punti interrogativi nell'istruzione `PREPARE`.
+ Per sostituire i parametri con i valori quando si esegue la query, utilizzare la clausola `USING` nell'istruzione `EXECUTE`.
+ Per rimuovere un'istruzione preparata dall'elenco delle istruzioni preparate in un gruppo di lavoro, utilizzare l'istruzione `DEALLOCATE PREPARE`.
Nelle sezioni seguenti vengono forniti ulteriori dettagli su ciascuna di queste istruzioni.
**Topics**
+ [PREPARE](querying-with-prepared-statements-prepare.md)
+ [EXECUTE](querying-with-prepared-statements-execute.md)
+ [DEALLOCATE PREPARE](querying-with-prepared-statements-deallocate-prepare.md)
# PREPARE
Prepara un'istruzione da eseguire in un secondo momento. Le istruzioni preparate vengono salvate nel gruppo di lavoro corrente con il nome specificato. L'istruzione può includere parametri al posto dei valori letterali da sostituire quando viene eseguita la query. I parametri da sostituire con valori sono denotati da punti interrogativi.
## Sintassi
```
PREPARE statement_name FROM statement
```
Nella tabella seguente vengono descritti questi parametri.
****
| Parametro | Description |
| --- | --- |
| statement\$1name | Il nome dell'istruzione da preparare. Il nome deve essere univoco all'interno del gruppo di lavoro. |
| statement | Una query SELECT, CTAS o INSERT INTO. |
## Esempi PREPARE
I seguenti esempi mostrano l'uso dell'istruzione `PREPARE`. I punti interrogativi indicano i valori che devono essere forniti dall'istruzione `EXECUTE` quando viene eseguita la query.
```
PREPARE my_select1 FROM
SELECT * FROM nation
```
```
PREPARE my_select2 FROM
SELECT * FROM "my_database"."my_table" WHERE year = ?
```
```
PREPARE my_select3 FROM
SELECT order FROM orders WHERE productid = ? and quantity < ?
```
```
PREPARE my_insert FROM
INSERT INTO cities_usa (city, state)
SELECT city, state
FROM cities_world
WHERE country = ?
```
```
PREPARE my_unload FROM
UNLOAD (SELECT * FROM table1 WHERE productid < ?)
TO 's3://amzn-s3-demo-bucket/'
WITH (format='PARQUET')
```
# EXECUTE
Esegue un'istruzione preparata. I valori per i parametri sono specificati nella clausola `USING`.
## Sintassi
```
EXECUTE statement_name [USING value1 [ ,value2, ... ] ]
```
*statement\$1name*è il nome della dichiarazione preparata. *value1*e *value2* sono i valori da specificare per i parametri dell'istruzione.
## Esempi EXECUTE
L'esempio seguente esegue l'esecuzione dell'istruzione preparata `my_select1`, che non contiene parametri.
```
EXECUTE my_select1
```
L'esempio seguente esegue l'esecuzione dell'istruzione preparata `my_select2`, che contiene un parametro singolo.
```
EXECUTE my_select2 USING 2012
```
L'esempio seguente esegue l'esecuzione dell'istruzione preparata `my_select3`, che contiene due parametri.
```
EXECUTE my_select3 USING 346078, 12
```
Nell'esempio seguente viene fornito un valore stringa per un parametro nell'istruzione preparata `my_insert`.
```
EXECUTE my_insert USING 'usa'
```
Nell'esempio seguente viene fornito un valore stringa per un parametro `productid` nell'istruzione preparata `my_unload`.
```
EXECUTE my_unload USING 12
```
# DEALLOCATE PREPARE
Rimuove l'istruzione preparata con il nome specificato dall'elenco delle istruzioni preparate nel gruppo di lavoro corrente.
## Sintassi
```
DEALLOCATE PREPARE statement_name
```
*statement\$1name*è il nome dell'istruzione preparata da rimuovere.
## Esempio
L'esempio seguente rimuove l'istruzione preparata `my_select1` dal gruppo di lavoro corrente.
```
DEALLOCATE PREPARE my_select1
```
# Eseguire istruzioni preparate interattive nella console Athena
Se si esegue un'istruzione preparata esistente con la sintassi `EXECUTE` *prepared\$1statement* dell'editor di query, Athena apre **la finestra di dialogo Inserisci** parametri in modo da poter inserire i valori che normalmente verrebbero inseriti nella clausola `USING` dell'istruzione. `EXECUTE ... USING`
**Eseguire un’istruzione preparata utilizzando la finestra di dialogo **Enter parameters (inserisci parametri)****
1. Nell'editor di query, anziché utilizzare la sintassi `EXECUTE prepared_statement USING` *value1* `,` *value2*` ...`, utilizzate la sintassi. `EXECUTE` *prepared\$1statement*
1. Scegli **Esegui**. Apparirà la finestra di dialogo **Enter parameters (inserisci parametri)**.
![\[Immissione di valori di parametri per un’istruzione preparata nella console Athena.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/querying-with-prepared-statements-2.png)
1. Inserisci i valori in ordine nella finestra di dialogo **Execution parameters (parametri di esecuzione)**. Poiché il testo originale della query non è visibile, è necessario ricordare il significato di ciascun parametro posizionale o avere l’istruzione preparata disponibile come riferimento.
1. Scegli **Esegui**.
# Utilizzate il AWS CLI per creare, eseguire ed elencare le istruzioni preparate
È possibile utilizzare il AWS CLI per creare, eseguire ed elencare le istruzioni preparate.
**Topics**
+ [Crea](querying-with-prepared-statements-creating-prepared-statements-using-the-aws-cli.md)
+ [Execute](querying-with-prepared-statements-cli-executing-prepared-statements.md)
+ [List](querying-with-prepared-statements-listing.md)
# Creare dichiarazioni preparate utilizzando il AWS CLI
Per utilizzare la AWS CLI per creare un'istruzione preparata, è possibile utilizzare uno dei seguenti `athena` comandi:
+ Utilizza il comando `create-prepared-statement` e fornisci un'istruzione di query con parametri di esecuzione.
+ Utilizza il comando `start-query-execution` e fornisci una stringa di query che utilizzi la sintassi `PREPARE`.
## Usa create-prepared-statement
In un comando `create-prepared-statement`, definisci il testo della query nell’argomento `query-statement`, come nell'esempio seguente.
```
aws athena create-prepared-statement
--statement-name PreparedStatement1
--query-statement "SELECT * FROM table WHERE x = ?"
--work-group athena-engine-v2
```
## Uso start-query-execution e sintassi PREPARE
Utilizza il comando `start-query-execution`. Inserisci l’istruzione `PREPARE` nell’argomento `query-string`, come nell’esempio seguente:
```
aws athena start-query-execution
--query-string "PREPARE PreparedStatement1 FROM SELECT * FROM table WHERE x = ?"
--query-execution-context '{"Database": "default"}'
--result-configuration '{"OutputLocation": "s3://amzn-s3-demo-bucket/..."}'
```
# Eseguite le istruzioni preparate utilizzando il AWS CLI
Per eseguire un'istruzione preparata con AWS CLI, è possibile fornire valori per i parametri utilizzando uno dei seguenti metodi:
+ Utilizzo dell’argomento `execution-parameters`.
+ Utilizzo della sintassi SQL `EXECUTE ... USING` nell’argomento `query-string`.
## Utilizzare l’argomento execution-parameters
In questo caso, è necessario fornire il comando `start-query-execution` e fornire il nome di un’istruzione preparata esistente nell’argomento `query-string`. Poi, nell’argomento `execution-parameters` fornisci i valori per i parametri di esecuzione. Di seguito viene illustrato un esempio di policy che mostra questo approccio:
```
aws athena start-query-execution
--query-string "Execute PreparedStatement1"
--query-execution-context "Database"="default"
--result-configuration "OutputLocation"="s3://amzn-s3-demo-bucket/..."
--execution-parameters "1" "2"
```
## Utilizzare EXECUTE… Utilizzo della sintassi SQL
Per eseguire un'istruzione preparata esistente utilizzando la sintassi `EXECUTE ... USING`, utilizza il comando `start-query-execution` e inserisci il nome dell'istruzione preparata e i valori dei parametri nell’argomento `query-string`, come nell’esempio:
```
aws athena start-query-execution
--query-string "EXECUTE PreparedStatement1 USING 1"
--query-execution-context '{"Database": "default"}'
--result-configuration '{"OutputLocation": "s3://amzn-s3-demo-bucket/..."}'
```
# Elenca le istruzioni preparate utilizzando il AWS CLI
Per elencare le istruzioni preparate per un gruppo di lavoro specifico, puoi utilizzare il comando [list-prepared-statements](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/athena/list-prepared-statements.html) AWS CLI Athena o l'azione API [ListPreparedStatements](https://docs.aws.amazon.com/athena/latest/APIReference/API_ListPreparedStatements.html)Athena. Il parametro `--work-group` è obbligatorio.
```
aws athena list-prepared-statements --work-group primary
```
# Risorse aggiuntive
Vedi i seguenti post correlati nel AWS Big Data Blog.
+ [Migliora la riusabilità e la sicurezza utilizzando le query parametrizzate di Amazon Athena](https://aws.amazon.com/blogs/big-data/improve-reusability-and-security-using-amazon-athena-parameterized-queries/)
+ [Utilizzare le query parametrizzate di Amazon Athena per fornire dati come servizio](https://aws.amazon.com/blogs/big-data/use-amazon-athena-parameterized-queries-to-provide-data-as-a-service/)
# Utilizzo dell’ottimizzatore basato sui costi
Per ottimizzare le tue query, puoi utilizzare la funzionalità di ottimizzazione basata sui costi (CBO) di Athena SQL. Facoltativamente, puoi richiedere che Athena raccolga statistiche a livello di tabella o colonna per una delle tue tabelle in AWS Glue. Se tutte le tabelle della query contengono statistiche, Athena utilizza le statistiche per creare un piano di esecuzione che ritiene essere il più performante. L'ottimizzatore di query calcola i piani alternativi sulla base di un modello statistico e quindi seleziona quello che sarà probabilmente il più veloce per eseguire la query.
Le statistiche sulle AWS Glue tabelle vengono raccolte e archiviate in AWS Glue Data Catalog e rese disponibili ad Athena per migliorare la pianificazione e l'esecuzione delle query. Queste statistiche sono statistiche a livello di colonna, ad esempio il numero di valori distinti, il numero di valori nulli, massimi e minimi su tipi di file come Parquet, ORC, JSON, ION, CSV e XML. Amazon Athena utilizza queste statistiche per ottimizzare le query applicando i filtri più restrittivi il prima possibile nell'elaborazione delle query. Questo filtro limita l'utilizzo della memoria e il numero di record da leggere per fornire i risultati delle query.
Oltre a CBO, Athena utilizza una funzionalità chiamata ottimizzatore basato su regole (RBO). L'RBO applica meccanicamente delle regole che dovrebbero migliorare le prestazioni delle query. L'RBO di solito è utile perché le sue trasformazioni mirano a semplificare il piano di interrogazione. Tuttavia, poiché l'RBO non esegue calcoli dei costi o confronti tra piani, le query più complicate rendono difficile la creazione di un piano ottimale.
Per questo motivo, per ottimizzare le query Athena utilizza sia RBO che CBO. Dopo aver identificato le opportunità per migliorare l'esecuzione delle query, Athena crea un piano ottimale. Per ulteriori informazioni sui dettagli del piano di esecuzione, consulta [Visualizzare i piani di esecuzione per query SQL](query-plans.md). Per una discussione dettagliata su come funziona il CBO, consulta [Velocizzare le query con l’ottimizzatore dei costi di Amazon Athena nel blog](https://aws.amazon.com/blogs/big-data/speed-up-queries-with-cost-based-optimizer-in-amazon-athena/) sui big data. AWS
Per generare statistiche per le tabelle AWS Glue del catalogo, puoi utilizzare la console Athena, la AWS Glue Console o. AWS Glue APIs Poiché Athena è integrato con AWS Glue Catalog, ottieni automaticamente i corrispondenti miglioramenti delle prestazioni delle query quando esegui query da Amazon Athena.
## Considerazioni e limitazioni
+ **Tipi di tabelle**: attualmente, la funzionalità CBO di Athena supporta solo le tabelle Hive e Iceberg presenti in. AWS Glue Data Catalog
+ **Athena per Spark**: la funzionalità CBO non è disponibile in Athena per Spark.
+ **Prezzi**: per informazioni sui prezzi, consulta la [pagina dei prezzi di AWS Glue](https://aws.amazon.com/glue/pricing).
## Generazione di statistiche sulle tabelle utilizzando la console Athena
In questa sezione viene descritto come usare la console Athena per generare statistiche a livello di tabella o colonna per una tabella in AWS Glue. Per informazioni sull'utilizzo per AWS Glue generare statistiche sulle tabelle, consulta [Lavorare con le statistiche delle colonne](https://docs.aws.amazon.com/glue/latest/dg/column-statistics.html) nella *Guida per gli AWS Glue sviluppatori*.
**Generazione di statistiche per una tabella tramite la console Athena**
1. Apri la console Athena all'indirizzo [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Nell'elenco **Tabelle** dell'editor di query Athena, scegli i tre punti verticali per la tabella desiderata, quindi scegli **Genera statistiche**.
![\[Menu contestuale per una tabella nell'editor di query Athena.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/cost-based-optimizer-1.png)
1. Nella finestra di dialogo **Genera statistiche**, scegli **Tutte le colonne** per generare le statistiche per tutte le colonne della tabella oppure **Colonne selezionate** per selezionare colonne specifiche. L'impostazione predefinita è **Tutte le colonne**.
![\[La finestra di dialogo Genera statistiche.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/cost-based-optimizer-2.png)
1. Per il **ruolo di AWS Glue servizio**, crea o seleziona un ruolo di servizio esistente per AWS Glue autorizzare la generazione di statistiche. Il ruolo di servizio AWS Glue richiede anche le autorizzazioni [https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html) per il bucket Amazon S3 che contiene i dati della tabella.
![\[Scelta di un ruolo AWS Glue di servizio.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/cost-based-optimizer-3.png)
1. Scegli **Genera statistiche**. Un banner di **generazione di statistiche per** le *table\$1name* notifiche mostra lo stato dell'attività.
![\[Il banner di notifica Generazione di statistiche.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/cost-based-optimizer-4.png)
1. Per visualizzare i dettagli nella AWS Glue console, scegli **Visualizza in Glue**.
Per informazioni sulla visualizzazione delle statistiche nella AWS Glue console, consulta [Visualizzazione delle statistiche delle colonne](https://docs.aws.amazon.com/glue/latest/dg/view-column-stats.html) nella *Guida per gli AWS Glue sviluppatori*.
1. Dopo la generazione delle statistiche, le tabelle e le colonne che contengono le statistiche mostrano la parola **Statistiche** tra parentesi, come nell'immagine seguente.
![\[Una tabella che mostra le icone statistiche nell'editor di query Athena.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/cost-based-optimizer-5.png)
Ora, quando esegui le tue query, Athena eseguirà l'ottimizzazione in base ai costi delle tabelle e delle colonne per le quali sono state generate le statistiche.
## Abilita e disabilita le statistiche della tabella
Quando si generano statistiche di tabella per una tabella Iceberg seguendo i passaggi della sezione precedente, una proprietà della tabella Glue chiamata `use_iceberg_statistics` viene aggiunta automaticamente alla tabella Iceberg AWS Glue Data Catalog e impostata su **true** per impostazione predefinita. Se rimuovi questa proprietà o la imposti su **false**, CBO non utilizzerà le statistiche della tabella Iceberg quando tenta di ottimizzare il piano di query durante l’esecuzione delle query, anche se le statistiche sono state generate da Glue. Per ulteriori informazioni su come generare statistiche sulle tabelle, vedere. [Generazione di statistiche sulle tabelle utilizzando la console Athena](#cost-based-optimizer-generating-table-statistics-using-the-athena-console)
Al contrario, le tabelle Hive nel Glue Data Catalog non hanno una proprietà di tabella simile per abilitare o disabilitare l’uso delle statistiche delle tabelle per CBO. Di conseguenza, CBO utilizza sempre le statistiche delle tabelle generate da Glue quando cerca di ottimizzare il piano di query per le tabelle Hive.
## Risorse aggiuntive
Per ulteriori informazioni, consultate la seguente risorsa.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/zUHEXJdHUxs?si=rMAhJj3I5IlhN-1R)
# Eseguire query su dati di S3 Express One Zone
La classe di archiviazione Amazon S3 Express One Zone è una classe di archiviazione di Amazon S3 ad alte prestazioni che fornisce tempi di risposta nell'ordine dei millisecondi. Pertanto, è utile per le applicazioni che accedono frequentemente ai dati con centinaia di migliaia di richieste al secondo.
S3 Express One Zone replica e archivia i dati all'interno della stessa zona di disponibilità per ottimizzare velocità e costi. Ciò si differenzia dalle classi di storage regionali di Amazon S3, che replicano automaticamente i dati su almeno AWS tre zone di disponibilità all'interno di una. Regione AWS
Per ulteriori informazioni, consulta la pagina [What is S3 Express One Zone?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-one-zone.html) nella *Guida per l'utente di Amazon S3*.
## Prerequisiti
Prima di iniziare, verifica che siano soddisfatte le seguenti condizioni:
+ **Versione 3 del motore Athena**: per utilizzare S3 Express One Zone con Athena SQL, il gruppo di lavoro deve essere configurato per l'utilizzo della versione 3 del motore Athena.
+ **Autorizzazioni S3 Express One Zone**: quando S3 Express One Zone richiama un'operazione come `GET`, `LIST` o `PUT` su un oggetto Amazon S3, la classe di archiviazione chiama `CreateSession` per tuo conto. Per questo motivo, la tua policy IAM deve consentire l'operazione `s3express:CreateSession`, che consente ad Athena di invocare l'operazione dell'API corrispondente.
## Considerazioni e limitazioni
Durante l'interrogazione di S3 Express One Zone con Athena, considera i seguenti punti.
+ I bucket S3 Express One Zone supportano la crittografia `SSE_S3` e `SSE-KMS`. I risultati delle query Athena vengono scritti utilizzando la crittografia `SSE_S3` indipendentemente dall'opzione di crittografia dei risultati delle query selezionata nelle impostazioni del gruppo di lavoro. Questa limitazione include tutti gli scenari in cui Athena scrive dati su bucket S3 Express One Zone, incluse le istruzioni `CREATE TABLE AS` (CTAS) e `INSERT INTO`.
+ Il AWS Glue crawler non è supportato per la creazione di tabelle sui dati di S3 Express One Zone.
+ L'istruzione `MSCK REPAIR TABLE` non è supportata. Come soluzione alternativa, utilizza [ALTER TABLE ADD PARTITION](alter-table-add-partition.md).
+ In S3 Express One Zone, non è supportata alcuna istruzione DDL che modifichi tabelle per Apache Iceberg (ovvero nessuna istruzione `ALTER TABLE`).
+ Lake Formation non è supportato dai bucket di S3 Express One Zone.
+ I seguenti formati di file e tabelle non sono supportati o hanno un supporto limitato. Se i formati, pur non essendo elencati, sono supportati per Athena (come Parquet, ORC e JSON), sono supportati anche per l'uso con l'archiviazione S3 Express One Zone.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/querying-express-one-zone.html)
## Nozioni di base
L'interrogazione dei dati di S3 Express One Zone con Athena è semplice. Per iniziare, attieniti alla procedura seguente.
**Utilizzo di Athena SQL per interrogare i dati di S3 Express One Zone**
1. Trasferisci i tuoi dati all'archiviazione S3 Express One Zone. Per ulteriori informazioni, consulta la pagina [Impostare la classe di archiviazione di un oggetto](https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage-class-intro.html#sc-howtoset) nella *Guida per l'utente di Amazon S3*.
1. Utilizza un'istruzione [CREATE TABLE](create-table.md) in Athena per catalogare i tuoi dati in AWS Glue Data Catalog. Per ulteriori informazioni sulla creazione delle tabelle in Athena, consulta la pagina [Crea tabelle in Athena](creating-tables.md) e l'istruzione [CREATE TABLE](create-table.md).
1. (Facoltativo) Configura la posizione dei risultati della query del tuo gruppo di lavoro Athena per utilizzare un *bucket di directory* Amazon S3. I bucket di directory Amazon S3 sono più performanti dei bucket generici e sono progettati per carichi di lavoro o applicazioni critiche per le prestazioni che richiedono una latenza costante nell'ordine dei millisecondi. Per ulteriori informazioni, consulta la pagina [Directory buckets overview](https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-buckets-overview.html) nella *Guida per l'utente di Amazon S3*.
# Eseguire query su oggetti Amazon Glacier ripristinati
È possibile usare Athena per eseguire query su oggetti ripristinati dalle [classi di archiviazione Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage-class-intro.html#sc-glacier), Amazon Glacier Flexible Retrieval (precedentemente Glacier) e Amazon Glacier Deep Archive. È necessario abilitare questa funzionalità per ogni tabella. Se non abiliti la funzionalità su una tabella prima di eseguire una query, Athena salta tutti gli oggetti Amazon Glacier Flexible Retrieval e Amazon Glacier Deep Archive della tabella.
## Considerazioni e limitazioni
+ L’esecuzione di query di oggetti Amazon Glacier ripristinati è supportata solo sulla versione 3 del motore Athena.
+ La funzionalità è supportata solo per le tabelle Apache Hive.
+ È necessario ripristinare gli oggetti prima di eseguire query sui dati; Athena non ripristina gli oggetti per conto dell'utente.
## Configurare una tabella per utilizzare oggetti ripristinati
Per configurare la tabella Athena in modo che includa gli oggetti ripristinati nelle query, è necessario impostare la relativa proprietà di tabella `read_restored_glacier_objects` su `true`. A tale scopo, è possibile utilizzare l'editor di query Athena o la AWS Glue console. Inoltre, puoi utilizzare la [CLI di AWS Glue](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glue/update-table.html), le [API di AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-tables.html#aws-glue-api-catalog-tables-UpdateTable) o l'[SDK di AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/sdk-general-information-section.html).
### Utilizzare l’editor di query Athena
In Athena puoi utilizzare il comando [ALTER TABLE SET TBLPROPERTIES](alter-table-set-tblproperties.md) per impostare la proprietà di tabella, come nell'esempio seguente.
```
ALTER TABLE table_name SET TBLPROPERTIES ('read_restored_glacier_objects' = 'true')
```
### Usa la console AWS Glue
Nella AWS Glue console, effettuate le seguenti operazioni per aggiungere la proprietà della `read_restored_glacier_objects` tabella.
**Per configurare le proprietà della tabella nella AWS Glue console**
1. Accedere a Console di gestione AWS e aprire la AWS Glue console all'indirizzo [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Esegui una delle seguenti operazioni:
+ Seleziona **Vai al catalogo dati**.
+ Nel pannello di navigazione, seleziona **Tabelle catalogo dati**.
1. Nella pagine delle **Tabelle**, nell'elenco delle tabelle, seleziona il link della tabella che intendi modificare.
1. Scegli **Actions** (Operazioni), **Edit** (Modifica).
1. Nella pagina **Modifica tabella**, nella sezione **Proprietà tabella**, aggiungi la seguente coppia chiave-valore:
+ Per **Chiave**, aggiungere `read_restored_glacier_objects`.
+ In **Valore**, specifica `true`.
1. Scegli **Save** (Salva).
### Usa il AWS CLI
In AWS CLI, è possibile utilizzare il comando AWS Glue [update-table](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glue/update-table.html) e il relativo `--table-input` argomento per ridefinire la tabella e così facendo aggiungere la proprietà. `read_restored_glacier_objects` Nell'argomento `--table-input` utilizza la struttura `Parameters` per specificare la proprietà `read_restored_glacier_objects` e il valore di `true`. Tieni presente che l'argomento per `--table-input` non deve avere spazi e deve utilizzare barre rovesciate per evitare le doppie virgolette. Nell'esempio seguente, sostituisci *my\$1database* e *my\$1table* con il nome del database e della tabella.
```
aws glue update-table \
--database-name my_database \
--table-input={\"Name\":\"my_table\",\"Parameters\":{\"read_restored_glacier_objects\":\"true\"}}
```
**Importante**
Il AWS Glue `update-table` comando funziona in modalità sovrascrittura, il che significa che sostituisce la definizione di tabella esistente con la nuova definizione specificata dal `table-input` parametro. Per questo motivo, assicurarsi di specificare nel parametro `table-input` anche tutti i campi che si desidera inserire nella tabella quando si aggiunge la proprietà `read_restored_glacier_objects`.
# Gestire gli aggiornamenti degli schemi
Questa sezione fornisce delle linee guida su come gestire gli aggiornamenti degli schemi per vari formati di dati. Athena è un motore di schema-on-read interrogazione. Ciò significa che quando si crea una tabella in Athena, applica schemi durante la lettura dei dati. Non modifica né riscrive i dati sottostanti.
Se si prevedono delle modifiche agli schemi tabella, è consigliabile crearli in un formato di dati idoneo alle proprie esigenze. Il tuo obiettivo è riutilizzare query Athena esistenti anziché modificare gli schemi, evitando così errori di mancata corrispondenza tra gli schemi durante l'esecuzione di query su tabelle con partizioni.
Per raggiungere questi obiettivi, scegli un formato di dati della tabella in base alla tabella nell'argomento seguente.
**Topics**
+ [Operazioni di aggiornamento degli schemi supportate in base al formato dei dati](#summary-of-updates)
+ [Comprendere l’accesso agli indici per Apache ORC e Apache Parquet](#index-access)
+ [Effettuare aggiornamenti degli schemi](make-schema-updates.md)
+ [Aggiornare tabelle con partizioni](updates-and-partitions.md)
## Operazioni di aggiornamento degli schemi supportate in base al formato dei dati
La tabella seguente riepiloga i formati di storage dei dati e le relative manipolazioni supportate per gli schemi. Utilizza questa tabella per scegliere più facilmente il formato che ti consenta di continuare a utilizzare le query Athena anche man mano che i tuoi schemi cambiano nel corso del tempo.
In questa tabella, osserva che Parquet e ORC sono formati di colonna con diversi metodi di accesso predefiniti alle colonne. Per impostazione predefinita, Parquet accederà alle colonne in base al nome, mentre ORC in base all'indice (valore ordinale). Pertanto, Athena fornisce una SerDe proprietà definita durante la creazione di una tabella per attivare il metodo di accesso alle colonne predefinito che consente una maggiore flessibilità con l'evoluzione dello schema.
Per Parquet, la proprietà `parquet.column.index.access` può essere configurata su `true`, impostando così il metodo di accesso alle colonne in base al numero ordinale della colonna. Impostando questa proprietà su `false`, il metodo di accesso alle colonne cambierà, impiegando il nome della colonna. Analogamente, per ORC utilizza la proprietà `orc.column.index.access` per controllare il metodo di accesso alle colonne. Per ulteriori informazioni, consulta [Comprendere l’accesso agli indici per Apache ORC e Apache Parquet](#index-access).
CSV e TSV consentono di eseguire qualsiasi manipolazione degli schemi, eccetto il riordinamento di colonne o l'aggiunta di colonne all'inizio della tabella. Ad esempio, se l'evoluzione del tuo schema richiede solo la ridenominazione delle colonne ma non la loro rimozione, è puoi decidere di creare le tabelle in CSV o TSV. Se è invece necessaria la rimozione di colonne, non utilizzare CSV o TSV, ma impiega invece uno qualsiasi degli altri formati supportati, preferibilmente un formato di colonna, ad esempio ORC o Parquet.
**Aggiornamenti di schemi e formati di dati in Athena**
| Aggiornamento tipo di schema atteso | Riepilogo | CSV (con e senza intestazioni) e TSV | JSON | AVRO | PARQUET: lettura in base al nome (predefinito) | PARQUET: lettura in base a indice | ORC: lettura in base a indice (predefinito) | ORC: lettura in base al nome |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| [Rinomina colonne](updates-renaming-columns.md) | Archivia i tuoi dati in CSV e TSV oppure in ORC e Parquet se vengono letti in base all'indice. | Y | N | N | N | Y | Y | N |
| [Aggiungi colonne all'inizio o al centro della tabella](updates-add-columns-beginning-middle-of-table.md) | Archivia i tuoi dati in JSON e AVRO oppure in ORC e Parquet se vengono letti in base al nome. Non utilizzare CSV e TSV. | N | Y | Y | Y | N | N | Y |
| [Aggiungi colonne alla fine di una tabella](updates-add-columns-end-of-table.md) | Archivia i tuoi dati in CSV o TSV, JSON, AVRO, ORC o Parquet. | Y | Y | Y | Y | Y | Y | Y |
| [Rimuovi colonne](updates-removing-columns.md) | Archivia i tuoi dati in JSON e AVRO oppure in Parquet e ORC se vengono letti in base al nome. Non utilizzare CSV e TSV. | N | Y | Y | Y | N | N | Y |
| [Riordina colonne](updates-reordering-columns.md) | Archivia i tuoi dati in AVRO, JSON oppure in ORC e Parquet se vengono letti in base al nome. | N | Y | Y | Y | N | N | Y |
| [Modifica il tipo di dati di una colonna](updates-changing-column-type.md) | Archivia i dati in qualunque formato, ma testa la query in Athena per verificare che i tipi di dati siano compatibili. Per Parquet e ORC, la modifica di un tipo di dati funziona solo per tabelle partizionate. | Y | Y | Y | Y | Y | Y | Y |
## Comprendere l’accesso agli indici per Apache ORC e Apache Parquet
PARQUET e ORC sono formati colonnari di storage dei dati che possono essere letti per indice o per nome. Archiviando i dati in uno di questi formati è possibile eseguire tutte le operazioni sugli schemi ed eseguire le query Athena senza errori di mancata corrispondenza di schemi.
+ Athena legge *ORC per indice per impostazione predefinita*, come definito in `SERDEPROPERTIES ( 'orc.column.index.access'='true')`. Per ulteriori informazioni, consulta [ORC: lettura in base all'indice](#orc-read-by-index).
+ Athena legge *Parquet per nome per impostazione predefinita*, come definito in `SERDEPROPERTIES ( 'parquet.column.index.access'='false')`. Per ulteriori informazioni, consulta [Parquet: lettura in base al nome](#parquet-read-by-name).
Poiché si tratta di impostazioni predefinite, la specificazione di queste SerDe proprietà nelle `CREATE TABLE` query è facoltativa, in quanto vengono utilizzate implicitamente. Quando sono utilizzate, consentono di eseguire alcune operazioni di aggiornamento dello schema, impedendone altre. Per abilitare tali operazioni, esegui un'altra `CREATE TABLE` query e modifica le impostazioni. SerDe
**Nota**
Le SerDe proprietà *non* vengono propagate automaticamente a ciascuna partizione. `ALTER TABLE ADD PARTITION`Utilizzate le istruzioni per impostare le SerDe proprietà per ogni partizione. Per automatizzare il processo, scrivi uno script che esegue le istruzioni `ALTER TABLE ADD PARTITION`.
Le seguenti sezioni descrivono in dettaglio questi casi.
### ORC: lettura in base all'indice
Una tabella in *ORC viene letta in base all'indice* per impostazione predefinita. Questo è definito dalla seguente sintassi:
```
WITH SERDEPROPERTIES (
'orc.column.index.access'='true')
```
La *lettura per indice* consente l'assegnazione di un nuovo nome alle colonne. Tuttavia, in tal caso non sarà più possibile rimuovere colonne o aggiungerle al centro della tabella.
Per fare in modo che ORC venga letto per nome, il che ti consentirà di aggiungere colonne al centro della tabella o rimuovere colonne in ORC, imposta la SerDe proprietà su `false` nell'`orc.column.index.access`istruzione. `CREATE TABLE` In questa configurazione, perderai la possibilità di rinominare le colonne.
**Nota**
Nel motore di Athena versione 2, quando le tabelle ORC sono impostate per la lettura per nome, Athena richiede che tutti i nomi delle colonne nei file ORC siano minuscoli. Poiché Apache Spark non utilizza nomi di campo minuscoli quando genera file ORC, Athena potrebbe non essere in grado di leggere i dati così generati. La soluzione alternativa consiste nel rinominare le colonne in modo che siano in minuscolo, oppure nell'utilizzare la versione 3 del motore Athena.
L'esempio seguente spiega come modificare la lettura ORC in modo che avvenga in base al nome:
```
CREATE EXTERNAL TABLE orders_orc_read_by_name (
`o_comment` string,
`o_orderkey` int,
`o_custkey` int,
`o_orderpriority` string,
`o_orderstatus` string,
`o_clerk` string,
`o_shippriority` int,
`o_orderdate` string
)
ROW FORMAT SERDE
'org.apache.hadoop.hive.ql.io.orc.OrcSerde'
WITH SERDEPROPERTIES (
'orc.column.index.access'='false')
STORED AS INPUTFORMAT
'org.apache.hadoop.hive.ql.io.orc.OrcInputFormat'
OUTPUTFORMAT
'org.apache.hadoop.hive.ql.io.orc.OrcOutputFormat'
LOCATION 's3://amzn-s3-demo-bucket/orders_orc/';
```
### Parquet: lettura in base al nome
Una tabella in *Parquet viene letta in base al nome* per impostazione predefinita. Questo è definito dalla seguente sintassi:
```
WITH SERDEPROPERTIES (
'parquet.column.index.access'='false')
```
La *lettura per nome* consente di aggiungere colonne al centro della tabella e di rimuovere colonne. Tuttavia, in tal caso si non sarà più possibile rinominare le colonne.
Per fare in modo che Parquet venga letto per indice, che consentirà di rinominare le colonne, è necessario creare una tabella con la `parquet.column.index.access` SerDe proprietà impostata su. `true`
# Effettuare aggiornamenti degli schemi
Questo argomento descrive alcune delle modifiche che è possibile apportare allo schema nelle istruzioni `CREATE TABLE` senza alterare effettivamente i dati. Per aggiornare uno schema, in alcuni casi puoi utilizzare un comando `ALTER TABLE`, ma in altri casi non è possibile modificare effettivamente una tabella esistente. Crea invece una tabella con un nuovo nome che modifica lo schema utilizzato nell'istruzione originale `CREATE TABLE`.
A seconda dell'evoluzione prevista degli schemi, per continuare a utilizzare le query Athena, è necessario scegliere un formato di dati compatibile.
Considera un'applicazione che legge le informazioni sugli ordini da una tabella `orders` esistente in due formati: CSV e Parquet.
L'esempio seguente crea una tabella in formato Parquet:
```
CREATE EXTERNAL TABLE orders_parquet (
`orderkey` int,
`orderstatus` string,
`totalprice` double,
`orderdate` string,
`orderpriority` string,
`clerk` string,
`shippriority` int
) STORED AS PARQUET
LOCATION 's3://amzn-s3-demo-bucket/orders_ parquet/';
```
L'esempio seguente crea la stessa tabella in formato CSV:
```
CREATE EXTERNAL TABLE orders_csv (
`orderkey` int,
`orderstatus` string,
`totalprice` double,
`orderdate` string,
`orderpriority` string,
`clerk` string,
`shippriority` int
)
ROW FORMAT DELIMITED FIELDS TERMINATED BY ','
LOCATION 's3://amzn-s3-demo-bucket/orders_csv/';
```
I seguenti argomenti, mostrano come gli aggiornamenti di queste tabelle influenzano le query Athena.
**Topics**
+ [Aggiungi colonne all'inizio o al centro della tabella](updates-add-columns-beginning-middle-of-table.md)
+ [Aggiungi colonne alla fine di una tabella](updates-add-columns-end-of-table.md)
+ [Rimuovi colonne](updates-removing-columns.md)
+ [Rinominare le colonne](updates-renaming-columns.md)
+ [Riordina colonne](updates-reordering-columns.md)
+ [Modifica il tipo di dati di una colonna](updates-changing-column-type.md)
# Aggiungi colonne all'inizio o al centro della tabella
L'aggiunta di colonne è una delle modifiche più frequenti di uno schema. Ad esempio, è possibile aggiungere una nuova colonna per arricchire la tabella con nuovi dati. In alternativa, è possibile aggiungere una nuova colonna se è cambiata la fonte di una colonna esistente e mantenere la versione precedente di questa colonna per regolare le applicazioni che dipendono da essa.
Per aggiungere colonne all'inizio o al centro della tabella e continuare a eseguire query su tabelle esistenti, utilizzate AVRO, JSON e Parquet e ORC se la loro SerDe proprietà è impostata su «Leggi per nome». Per informazioni, consulta [Comprendere l’accesso agli indici per Apache ORC e Apache Parquet](handling-schema-updates-chapter.md#index-access).
Non aggiungere colonne all'inizio o al centro della tabella in CSV e TSV, poiché questi formati dipendono dall'ordinamento. L'aggiunta di una colonna in questi casi porterebbe a errori di mancata corrispondenza tra schemi quando lo schema di partizioni viene modificato.
L'esempio seguente crea una nuova tabella che aggiunge una colonna `o_comment` al centro di una tabella basata su dati JSON.
```
CREATE EXTERNAL TABLE orders_json_column_addition (
`o_orderkey` int,
`o_custkey` int,
`o_orderstatus` string,
`o_comment` string,
`o_totalprice` double,
`o_orderdate` string,
`o_orderpriority` string,
`o_clerk` string,
`o_shippriority` int,
)
ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe'
LOCATION 's3://amzn-s3-demo-bucket/orders_json/';
```
# Aggiungi colonne alla fine di una tabella
Se si creano tabelle in uno dei formati supportati da Athena, ad esempio Parquet, ORC, Avro, JSON, CSV e TSV, è possibile utilizzare l'istruzione `ALTER TABLE ADD COLUMNS` per aggiungere colonne dopo le colonne esistenti ma prima delle colonne di partizione.
Nell'esempio seguente viene aggiunta una colonna `comment` alla fine della tabella `orders_parquet` prima di qualsiasi colonna di partizione:
```
ALTER TABLE orders_parquet ADD COLUMNS (comment string)
```
**Nota**
Per visualizzare una nuova colonna di tabella nell'editor di query Athena dopo l'esecuzione di `ALTER TABLE ADD COLUMNS`, aggiornare manualmente l'elenco di tabelle nell'editor e quindi espandere nuovamente la tabella.
# Rimuovi colonne
Potrebbe essere necessario rimuovere colonne dalle tabelle se queste non contengono più dati o per limitare l'accesso ai dati in esse contenuti.
+ È possibile rimuovere colonne da tabelle in formato JSON, Avro e Parquet e ORC se la lettura è per nome. Per informazioni, consulta [Comprendere l’accesso agli indici per Apache ORC e Apache Parquet](handling-schema-updates-chapter.md#index-access).
+ Sconsigliamo di rimuovere colonne delle tabelle in CSV e TSV se si desidera conservare le tabelle già create in Athena. La rimozione di una colonna altera lo schema e richiede di ricreare la tabella senza la colonna rimossa.
In questo esempio, si rimuove una colonna ``totalprice`` da una tabella in Parquet e si esegue una query. In Athena, il formato Parquet è letto per nome per impostazione predefinita e questo è il motivo per cui omettiamo la configurazione SERDEPROPERTIES che specifica la lettura per nome. Tieni presente che la seguente query va a buon fine anche se si modifica lo schema:
```
CREATE EXTERNAL TABLE orders_parquet_column_removed (
`o_orderkey` int,
`o_custkey` int,
`o_orderstatus` string,
`o_orderdate` string,
`o_orderpriority` string,
`o_clerk` string,
`o_shippriority` int,
`o_comment` string
)
STORED AS PARQUET
LOCATION 's3://amzn-s3-demo-bucket/orders_parquet/';
```
# Rinominare le colonne
È possibile rinominare le colonne nelle tabelle per correggere l'ortografia, rendere i nomi delle colonne più descrittivi o riutilizzare una colonna esistente per evitare il riordinamento delle colonne.
È possibile rinominare le colonne se si archiviano i dati in CSV e TSV o in Parquet e ORC con configurazione per la lettura per indice. Per informazioni, consulta [Comprendere l’accesso agli indici per Apache ORC e Apache Parquet](handling-schema-updates-chapter.md#index-access).
Athena legge i dati in CSV e TSV nell'ordine delle colonne nello schema e li restituisce nello stesso ordine. Non utilizza i nomi delle colonne per la mappatura dei dati a una colonna e questo è il motivo per cui è possibile rinominare le colonne in CSV o TSV senza interrompere le query Athena.
Una strategia per rinominare le colonne consiste nel creare una nuova tabella basata sugli stessi dati sottostanti, ma utilizzando nuovi nomi di colonna. Il seguente esempio crea una nuova tabella `orders_parquet` chiamata `orders_parquet_column_renamed`. L'esempio modifica il nome ``o_totalprice`` della colonna in ``o_total_price`` e quindi esegue una query in Athena:
```
CREATE EXTERNAL TABLE orders_parquet_column_renamed (
`o_orderkey` int,
`o_custkey` int,
`o_orderstatus` string,
`o_total_price` double,
`o_orderdate` string,
`o_orderpriority` string,
`o_clerk` string,
`o_shippriority` int,
`o_comment` string
)
STORED AS PARQUET
LOCATION 's3://amzn-s3-demo-bucket/orders_parquet/';
```
Nel caso della tabella Parquet, la query seguente viene eseguita, ma la colonna rinominata non mostra i dati poiché l'accesso alla stessa è avvenuto per nome (impostazione predefinita in Parquet) anziché per indice:
```
SELECT *
FROM orders_parquet_column_renamed;
```
Di seguito un esempio di query con una tabella in CSV:
```
CREATE EXTERNAL TABLE orders_csv_column_renamed (
`o_orderkey` int,
`o_custkey` int,
`o_orderstatus` string,
`o_total_price` double,
`o_orderdate` string,
`o_orderpriority` string,
`o_clerk` string,
`o_shippriority` int,
`o_comment` string
)
ROW FORMAT DELIMITED FIELDS TERMINATED BY ','
LOCATION 's3://amzn-s3-demo-bucket/orders_csv/';
```
Nel caso della tabella CSV, la query seguente viene eseguita e i dati vengono visualizzati in tutte le colonne, compresa quella che è stata rinominata:
```
SELECT *
FROM orders_csv_column_renamed;
```
# Riordina colonne
È possibile riordinare le colonne solo per tabelle con dati in formati che leggono per nome, ad esempio JSON o Parquet, i quali leggono per nome per impostazione predefinita. Se necessario, è possibile fare in modo che anche ORC legga per nome. Per informazioni, consulta [Comprendere l’accesso agli indici per Apache ORC e Apache Parquet](handling-schema-updates-chapter.md#index-access).
L'esempio seguente crea una nuova tabella con le colonne in un ordine diverso:
```
CREATE EXTERNAL TABLE orders_parquet_columns_reordered (
`o_comment` string,
`o_orderkey` int,
`o_custkey` int,
`o_orderpriority` string,
`o_orderstatus` string,
`o_clerk` string,
`o_shippriority` int,
`o_orderdate` string
)
STORED AS PARQUET
LOCATION 's3://amzn-s3-demo-bucket/orders_parquet/';
```
# Modifica il tipo di dati di una colonna
Potresti voler utilizzare un tipo di colonna diverso quando il tipo esistente non può più contenere la quantità di informazioni richieste. Ad esempio, i valori di una colonna ID potrebbero superare la dimensione del tipo di dati `INT` e richiedere l'uso del tipo di dati `BIGINT`.
## Considerazioni
Quando si prevede di utilizzare un tipo di dati diverso per una colonna, considerare i seguenti punti:
+ Nella maggior parte dei casi, non è possibile modificare direttamente il tipo di dati di una colonna. Al contrario, si ricrea la tabella Athena e si definisce la colonna con il nuovo tipo di dati.
+ Solo alcuni tipi di dati possono essere letti come altri tipi di dati. Consulta la tabella in questa sezione per i tipi di dati che possono essere trattati in tal modo.
+ Per i dati in Parquet e ORC, non puoi utilizzare un tipo di dati diverso per una colonna se la tabella non è partizionata.
+ Per le tabelle partizionate in Parquet e ORC, il tipo di colonna di una partizione può essere diverso dal tipo di colonna di un'altra partizione e, se possibile, Athena eseguirà `CAST` per il tipo desiderato. Per informazioni, consulta [Evitare errori di mancata corrispondenza tra schemi per tabelle con partizioni](updates-and-partitions.md#partitions-dealing-with-schema-mismatch-errors).
+ Per le tabelle create utilizzando l'[LazySimpleSerDe](lazy-simple-serde.md)unico, è possibile utilizzare l'`ALTER TABLE REPLACE COLUMNS`istruzione per sostituire le colonne esistenti con un tipo di dati diverso, ma tutte le colonne esistenti che si desidera conservare devono essere ridefinite nell'istruzione, altrimenti verranno eliminate. Per ulteriori informazioni, consulta [ALTER TABLE REPLACE COLUMNS](alter-table-replace-columns.md).
+ Solo per le tabelle Apache Iceberg, puoi utilizzare l'istruzione [ALTER TABLE CHANGE COLUMN](querying-iceberg-alter-table-change-column.md) per modificare il tipo di dati di una colonna. `ALTER TABLE REPLACE COLUMNS` non è supportato per le tabelle Iceberg. Per ulteriori informazioni, consulta [Evoluzione dello schema della tabella Iceberg](querying-iceberg-evolving-table-schema.md).
**Importante**
Consigliamo vivamente di testare e verificare le query prima di modificare il tipo di dati. Se Athena non è in grado di utilizzare il tipo di dati di destinazione, la query `CREATE TABLE` potrebbe avere esito negativo.
## Utilizzare tipi di dati compatibili
Quando possibile, utilizza tipi di dati compatibili. La tabella seguente elenca i tipi di dati che possono essere trattati come altri tipi di dati:
| Tipo di dati originale | Tipi di dati di destinazione disponibili |
| --- | --- |
| STRING | BYTE, TINYINT, SMALLINT, INT, BIGINT |
| BYTE | TINYINT, SMALLINT, INT, BIGINT |
| TINYINT | SMALLINT, INT, BIGINT |
| SMALLINT | INT, BIGINT |
| INT | BIGINT |
| FLOAT | DOUBLE |
L'esempio seguente mostra l'utilizzo dell'istruzione `CREATE TABLE` per la tabella `orders_json` originale per creare una nuova tabella denominata `orders_json_bigint`. La nuova tabella utilizza `BIGINT` anziché `INT` come tipo di dati per la colonna ``o_shippriority``.
```
CREATE EXTERNAL TABLE orders_json_bigint (
`o_orderkey` int,
`o_custkey` int,
`o_orderstatus` string,
`o_totalprice` double,
`o_orderdate` string,
`o_orderpriority` string,
`o_clerk` string,
`o_shippriority` BIGINT
)
ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe'
LOCATION 's3://amzn-s3-demo-bucket/orders_json';
```
La seguente query viene eseguita correttamente, in modo analogo alla query `SELECT` originale, prima della modifica del tipo di dati:
```
Select * from orders_json
LIMIT 10;
```
# Aggiornare tabelle con partizioni
In Athena, una tabella e le relative partizioni devono utilizzare gli stessi formati di dati, tuttavia i loro schemi possono differire. Quando si crea una nuova partizione, questa in genere eredita lo schema della tabella. Nel corso del tempo, gli schemi possono iniziare a differire. I motivi includono:
+ Se lo schema della tua tabella cambia, gli schemi delle partizioni non vengono aggiornati per mantenere la sincronizzazione con lo schema della tabella.
+ Il AWS Glue Crawler consente di scoprire dati in partizioni con schemi diversi. Ciò significa che se si crea una tabella in Athena con AWS Glue, dopo che il crawler ha terminato l'elaborazione, gli schemi per la tabella e le relative partizioni potrebbero essere diversi.
+ Se aggiungi partizioni direttamente utilizzando un'API. AWS
Athena elabora correttamente le tabelle con partizioni se soddisfano i seguenti vincoli. Se tali requisiti non vengono soddisfatti, Athena emette un errore HIVE\$1PARTITION\$1SCHEMA\$1MISMATCH.
+ Ciascuno schema di partizione è compatibile con lo schema della tabella.
+ Il formato di dati della tabella consente il tipo di aggiornamento che si desidera eseguire: aggiunta, eliminazione, riordinamento o modifica del tipo di dati di una colonna.
Ad esempio, per i formati CSV e TSV è possibile rinominare colonne, aggiungere nuove colonne alla fine della tabella e modificare il tipo di dati di una colonna se i tipi sono compatibili, ma non è possibile rimuovere colonne. Per altri formati, è possibile aggiungere o rimuovere colonne oppure modificare il tipo di dati di una colonna in un altro tipo se i tipi sono compatibili. Per ulteriori informazioni, consulta il [Riepilogo: aggiornamenti e formati di dati in Athena](handling-schema-updates-chapter.md#summary-of-updates).
## Evitare errori di mancata corrispondenza tra schemi per tabelle con partizioni
All'inizio dell'esecuzione di una query, Athena verifica lo schema della tabella controllando che ogni tipo di dati colonna sia compatibile tra la tabella e la partizione.
+ Per i tipi di storage dei dati Parquet e ORC, Athena si avvale dei nomi delle colonne e li utilizza per la verifica del proprio schema basato sul nome di colonna. Ciò consente di eliminare gli errori `HIVE_PARTITION_SCHEMA_MISMATCH` per le tabelle con partizioni in Parquet e ORC. (Questo vale per ORC se la SerDe proprietà è impostata per accedere all'indice per nome:. `orc.column.index.access=FALSE` Per impostazione predefinita, Parquet legge l'indice per nome).
+ Per CSV, JSON e Avro, Athena usa una verifica dello schema basata sull'indice. Questo significa che, se si verifica un errore di mancata corrispondenza di schema, è necessario eliminare la partizione che provoca tale differenza e ricrearla, in modo che Athena possa eseguire le query senza errori.
Athena confronta lo schema della tabella con gli schemi della partizione. Se crei una tabella in CSV, JSON e AVRO in Athena con AWS Glue Crawler, dopo che il Crawler ha terminato l'elaborazione, gli schemi per la tabella e le sue partizioni potrebbero essere diversi. Se non c'è corrispondenza tra lo schema della tabella e gli schemi delle partizioni, le query falliranno in Athena a causa dell'errore di verifica dello schema simile a questo: 'crawler\$1test.click\$1avro' è dichiarato come tipo "string", ma la partizione "partition\$10 = 2017-01-17" ha dichiarato la colonna "col68" come tipo "doppio"'.
Una tipica soluzione per questi errori è eliminare la partizione che provoca l'errore e ricrearla. Per ulteriori informazioni, consultare [ALTER TABLE DROP PARTITION](alter-table-drop-partition.md) e [ALTER TABLE ADD PARTITION](alter-table-add-partition.md).
# Eseguire query su matrici
Amazon Athena consente di creare matrici, concatenarle, convertirle in diversi tipi di dati e in seguito filtrarle, appiattirle e ordinarle.
**Topics**
+ [Creare matrici](creating-arrays.md)
+ [Concatena stringhe e matrici](concatenating-strings-and-arrays.md)
+ [Convertire tipi di dati della matrice](converting-array-data-types.md)
+ [Individuare lunghezze di array](finding-lengths.md)
+ [Accedere agli elementi della matrice](accessing-array-elements.md)
+ [Appiattire matrici nidificate](flattening-arrays.md)
+ [Creare matrici da sottoquery](creating-arrays-from-subqueries.md)
+ [Filtrare le matrici](filtering-arrays.md)
+ [Ordinare matrici](sorting-arrays.md)
+ [Utilizzo delle funzioni di aggregazione con le matrici](arrays-and-aggregation.md)
+ [Convertire le matrici in stringhe](converting-arrays-to-strings.md)
+ [Utilizzo delle matrici per creare mappe](arrays-create-maps.md)
+ [Eseguire query su matrici con tipi complessi](rows-and-structs.md)
# Creare matrici
Per creare una matrice letterale in Athena, utilizzare la parola chiave `ARRAY`, seguita da parentesi `[ ]` e includere gli elementi della matrice separati da virgole.
## Esempi
Questa query crea una matrice con quattro elementi.
```
SELECT ARRAY [1,2,3,4] AS items
```
Restituisce:
```
+-----------+
| items |
+-----------+
| [1,2,3,4] |
+-----------+
```
Questa query crea due matrici.
```
SELECT ARRAY[ ARRAY[1,2], ARRAY[3,4] ] AS items
```
Restituisce:
```
+--------------------+
| items |
+--------------------+
| [[1, 2], [3, 4]] |
+--------------------+
```
Per creare una matrice da colonne selezionate di tipi compatibili, utilizzare una query, come in questo esempio:
```
WITH
dataset AS (
SELECT 1 AS x, 2 AS y, 3 AS z
)
SELECT ARRAY [x,y,z] AS items FROM dataset
```
Questa query restituisce:
```
+-----------+
| items |
+-----------+
| [1,2,3] |
+-----------+
```
In questo esempio, due matrici vengono selezionate e restituite come un messaggio di benvenuto.
```
WITH
dataset AS (
SELECT
ARRAY ['hello', 'amazon', 'athena'] AS words,
ARRAY ['hi', 'alexa'] AS alexa
)
SELECT ARRAY[words, alexa] AS welcome_msg
FROM dataset
```
Questa query restituisce:
```
+----------------------------------------+
| welcome_msg |
+----------------------------------------+
| [[hello, amazon, athena], [hi, alexa]] |
+----------------------------------------+
```
Per creare una matrice di coppie chiave-valore, utilizzare l'operatore `MAP` che richiede una matrice di chiavi seguite da una matrice di valori, come in questo esempio:
```
SELECT ARRAY[
MAP(ARRAY['first', 'last', 'age'],ARRAY['Bob', 'Smith', '40']),
MAP(ARRAY['first', 'last', 'age'],ARRAY['Jane', 'Doe', '30']),
MAP(ARRAY['first', 'last', 'age'],ARRAY['Billy', 'Smith', '8'])
] AS people
```
Questa query restituisce:
```
+-----------------------------------------------------------------------------------------------------+
| people |
+-----------------------------------------------------------------------------------------------------+
| [{last=Smith, first=Bob, age=40}, {last=Doe, first=Jane, age=30}, {last=Smith, first=Billy, age=8}] |
+-----------------------------------------------------------------------------------------------------+
```
# Concatena stringhe e matrici
La concatenazione di stringhe e la concatenazione di matrici utilizzano tecniche simili.
## Concatena stringhe.
Per concatenare due stringhe, è possibile utilizzare l'operatore doppio pipe `||`, come nell'esempio seguente.
```
SELECT 'This' || ' is' || ' a' || ' test.' AS Concatenated_String
```
Questa query restituisce:
****
| \$1 | Concatenated\$1String |
| --- | --- |
| 1 | `This is a test.` |
Puoi utilizzare la funzione `concat()` per ottenere lo stesso risultato.
```
SELECT concat('This', ' is', ' a', ' test.') AS Concatenated_String
```
Questa query restituisce:
****
| \$1 | Concatenated\$1String |
| --- | --- |
| 1 | `This is a test.` |
È possibile utilizzare la funzione `concat_ws()` per concatenare stringhe con il separatore specificato nel primo argomento.
```
SELECT concat_ws(' ', 'This', 'is', 'a', 'test.') as Concatenated_String
```
Questa query restituisce:
****
| \$1 | Concatenated\$1String |
| --- | --- |
| 1 | `This is a test.` |
Per concatenare due colonne del tipo di dati stringa utilizzando un punto, fai riferimento alle due colonne utilizzando virgolette doppie e racchiudi il punto tra virgolette singole come stringa codificata. Se una colonna non è del tipo di dati stringa, puoi utilizzare prima `CAST("column_name" as VARCHAR)` per eseguire il cast della colonna.
```
SELECT "col1" || '.' || "col2" as Concatenated_String
FROM my_table
```
Questa query restituisce:
****
| \$1 | Concatenated\$1String |
| --- | --- |
| 1 | `col1_string_value.col2_string_value` |
## Concatena matrici
È possibile utilizzare le stesse tecniche per concatenare le matrici.
Per concatenare più matrici, utilizza l'operatore doppio pipe `||`.
```
SELECT ARRAY [4,5] || ARRAY[ ARRAY[1,2], ARRAY[3,4] ] AS items
```
Questa query restituisce:
****
| \$1 | items |
| --- | --- |
| 1 | `[[4, 5], [1, 2], [3, 4]]` |
Per combinare più array in un solo array, utilizza l'operatore doppio pipe o la funzione `concat()`.
```
WITH
dataset AS (
SELECT
ARRAY ['Hello', 'Amazon', 'Athena'] AS words,
ARRAY ['Hi', 'Alexa'] AS alexa
)
SELECT concat(words, alexa) AS welcome_msg
FROM dataset
```
Questa query restituisce:
****
| \$1 | welcome\$1msg |
| --- | --- |
| 1 | `[Hello, Amazon, Athena, Hi, Alexa]` |
Per ulteriori informazioni sulle funzioni `concat()` di altre stringhe, consulta [Funzioni e operatori per le stringhe](https://trino.io/docs/current/functions/string.html) nella documentazione di Trino.
# Convertire tipi di dati della matrice
Per convertire i dati delle matrici in tipi di dati supportati, utilizza l'operatore `CAST`, come `CAST(value AS type)`. Athena supporta tutti i tipi di dati nativi di Presto.
```
SELECT
ARRAY [CAST(4 AS VARCHAR), CAST(5 AS VARCHAR)]
AS items
```
Questa query restituisce:
```
+-------+
| items |
+-------+
| [4,5] |
+-------+
```
Creare due matrici con elementi della coppia chiave-valore, convertirli in formato JSON e concatenarli, come nel seguente esempio:
```
SELECT
ARRAY[CAST(MAP(ARRAY['a1', 'a2', 'a3'], ARRAY[1, 2, 3]) AS JSON)] ||
ARRAY[CAST(MAP(ARRAY['b1', 'b2', 'b3'], ARRAY[4, 5, 6]) AS JSON)]
AS items
```
Questa query restituisce:
```
+--------------------------------------------------+
| items |
+--------------------------------------------------+
| [{"a1":1,"a2":2,"a3":3}, {"b1":4,"b2":5,"b3":6}] |
+--------------------------------------------------+
```
# Individuare lunghezze di array
La funzione `cardinality` restituisce la lunghezza di un array, come in questo esempio:
```
SELECT cardinality(ARRAY[1,2,3,4]) AS item_count
```
Questa query restituisce:
```
+------------+
| item_count |
+------------+
| 4 |
+------------+
```
# Accedere agli elementi della matrice
Per accedere agli elementi della matrice, utilizza l'operatore `[]`, dove 1 specifica il primo elemento, 2 specifica il secondo e così via, come in questo esempio:
```
WITH dataset AS (
SELECT
ARRAY[CAST(MAP(ARRAY['a1', 'a2', 'a3'], ARRAY[1, 2, 3]) AS JSON)] ||
ARRAY[CAST(MAP(ARRAY['b1', 'b2', 'b3'], ARRAY[4, 5, 6]) AS JSON)]
AS items )
SELECT items[1] AS item FROM dataset
```
Questa query restituisce:
```
+------------------------+
| item |
+------------------------+
| {"a1":1,"a2":2,"a3":3} |
+------------------------+
```
Per accedere agli elementi di una matrice in una determinata posizione (nota come posizione indice), utilizza la funzione `element_at()` e specifica il nome della matrice e la posizione indice:
+ Se l'indice è maggiore di 0, `element_at()` restituisce l'elemento specificato, contando dall'inizio alla fine della matrice. Si comporta come l'operatore `[]`.
+ Se l'indice è minore di 0, `element_at()` restituisce l'elemento, contando dalla fine all'inizio della matrice.
La seguente query crea una matrice `words` e seleziona il primo elemento `hello` come `first_word`, il secondo elemento `amazon` (contando dalla fine della matrice) come `middle_word` e il terzo elemento `athena` come `last_word`.
```
WITH dataset AS (
SELECT ARRAY ['hello', 'amazon', 'athena'] AS words
)
SELECT
element_at(words, 1) AS first_word,
element_at(words, -2) AS middle_word,
element_at(words, cardinality(words)) AS last_word
FROM dataset
```
Questa query restituisce:
```
+----------------------------------------+
| first_word | middle_word | last_word |
+----------------------------------------+
| hello | amazon | athena |
+----------------------------------------+
```
# Appiattire matrici nidificate
Quando si utilizzano matrici nidificate, spesso è necessario espanderne gli elementi in una singola matrice oppure espandere la matrice stessa in più righe.
## Usare la funzione di appiattimento
Per appiattire gli elementi di una matrice nidificata in una singola matrice di valori, utilizza la funzione `flatten`. Questa query restituisce una riga per ciascun elemento della matrice.
```
SELECT flatten(ARRAY[ ARRAY[1,2], ARRAY[3,4] ]) AS items
```
Questa query restituisce:
```
+-----------+
| items |
+-----------+
| [1,2,3,4] |
+-----------+
```
## Usare CROSS JOIN e UNNEST
Per appiattire una matrice in più righe, utilizza `CROSS JOIN` in combinazione con l'operatore `UNNEST`, come in questo esempio:
```
WITH dataset AS (
SELECT
'engineering' as department,
ARRAY['Sharon', 'John', 'Bob', 'Sally'] as users
)
SELECT department, names FROM dataset
CROSS JOIN UNNEST(users) as t(names)
```
Questa query restituisce:
```
+----------------------+
| department | names |
+----------------------+
| engineering | Sharon |
+----------------------|
| engineering | John |
+----------------------|
| engineering | Bob |
+----------------------|
| engineering | Sally |
+----------------------+
```
Per appiattire una matrice di coppie chiave-valore, ridisponi le chiavi selezionate in colonne, come in questo esempio:
```
WITH
dataset AS (
SELECT
'engineering' as department,
ARRAY[
MAP(ARRAY['first', 'last', 'age'],ARRAY['Bob', 'Smith', '40']),
MAP(ARRAY['first', 'last', 'age'],ARRAY['Jane', 'Doe', '30']),
MAP(ARRAY['first', 'last', 'age'],ARRAY['Billy', 'Smith', '8'])
] AS people
)
SELECT names['first'] AS
first_name,
names['last'] AS last_name,
department FROM dataset
CROSS JOIN UNNEST(people) AS t(names)
```
Questa query restituisce:
```
+--------------------------------------+
| first_name | last_name | department |
+--------------------------------------+
| Bob | Smith | engineering |
| Jane | Doe | engineering |
| Billy | Smith | engineering |
+--------------------------------------+
```
Da un elenco di dipendenti, seleziona quello con il miglior punteggio combinato. `UNNEST` può essere utilizzato nella clausola `FROM` senza essere preceduto da `CROSS JOIN`, poiché è l'operatore join predefinito e pertanto è implicito.
```
WITH
dataset AS (
SELECT ARRAY[
CAST(ROW('Sally', 'engineering', ARRAY[1,2,3,4]) AS ROW(name VARCHAR, department VARCHAR, scores ARRAY(INTEGER))),
CAST(ROW('John', 'finance', ARRAY[7,8,9]) AS ROW(name VARCHAR, department VARCHAR, scores ARRAY(INTEGER))),
CAST(ROW('Amy', 'devops', ARRAY[12,13,14,15]) AS ROW(name VARCHAR, department VARCHAR, scores ARRAY(INTEGER)))
] AS users
),
users AS (
SELECT person, score
FROM
dataset,
UNNEST(dataset.users) AS t(person),
UNNEST(person.scores) AS t(score)
)
SELECT person.name, person.department, SUM(score) AS total_score FROM users
GROUP BY (person.name, person.department)
ORDER BY (total_score) DESC
LIMIT 1
```
Questa query restituisce:
```
+---------------------------------+
| name | department | total_score |
+---------------------------------+
| Amy | devops | 54 |
+---------------------------------+
```
Da un elenco di dipendenti, seleziona quello con il miglior punteggio individuale.
```
WITH
dataset AS (
SELECT ARRAY[
CAST(ROW('Sally', 'engineering', ARRAY[1,2,3,4]) AS ROW(name VARCHAR, department VARCHAR, scores ARRAY(INTEGER))),
CAST(ROW('John', 'finance', ARRAY[7,8,9]) AS ROW(name VARCHAR, department VARCHAR, scores ARRAY(INTEGER))),
CAST(ROW('Amy', 'devops', ARRAY[12,13,14,15]) AS ROW(name VARCHAR, department VARCHAR, scores ARRAY(INTEGER)))
] AS users
),
users AS (
SELECT person, score
FROM
dataset,
UNNEST(dataset.users) AS t(person),
UNNEST(person.scores) AS t(score)
)
SELECT person.name, score FROM users
ORDER BY (score) DESC
LIMIT 1
```
Questa query restituisce:
```
+--------------+
| name | score |
+--------------+
| Amy | 15 |
+--------------+
```
### Considerazioni su CROSS JOIN e UNNEST
Se `UNNEST` viene utilizzato su uno o più array nella query e uno degli array è `NULL`, la query non restituisce righe. Se `UNNEST` viene utilizzato su un array che è una stringa vuota, viene restituita la stringa vuota.
Ad esempio, nella query seguente, poiché il secondo array è nullo, la query non restituisce alcuna riga.
```
SELECT
col1,
col2
FROM UNNEST (ARRAY ['apples','oranges','lemons']) AS t(col1)
CROSS JOIN UNNEST (ARRAY []) AS t(col2)
```
Nell'esempio successivo, il secondo array viene modificato per contenere una stringa vuota. Per ogni riga, la query restituisce il valore in `col1` e una stringa vuota per il valore in `col2`. La stringa vuota nel secondo array è necessaria per restituire i valori del primo array.
```
SELECT
col1,
col2
FROM UNNEST (ARRAY ['apples','oranges','lemons']) AS t(col1)
CROSS JOIN UNNEST (ARRAY ['']) AS t(col2)
```
# Creare matrici da sottoquery
Creare una matrice da una raccolta di righe.
```
WITH
dataset AS (
SELECT ARRAY[1,2,3,4,5] AS items
)
SELECT array_agg(i) AS array_items
FROM dataset
CROSS JOIN UNNEST(items) AS t(i)
```
Questa query restituisce:
```
+-----------------+
| array_items |
+-----------------+
| [1, 2, 3, 4, 5] |
+-----------------+
```
Per creare una matrice di valori univoci da un set di righe, utilizzare la parola chiave `distinct`.
```
WITH
dataset AS (
SELECT ARRAY [1,2,2,3,3,4,5] AS items
)
SELECT array_agg(distinct i) AS array_items
FROM dataset
CROSS JOIN UNNEST(items) AS t(i)
```
Questa query restituisce il seguente risultato. Si noti che l'ordine non è garantito.
```
+-----------------+
| array_items |
+-----------------+
| [1, 2, 3, 4, 5] |
+-----------------+
```
Per ulteriori informazioni sull'utilizzo della funzione `array_agg`, consulta la sezione [Aggregate functions](https://trino.io/docs/current/functions/aggregate.html) (Funzioni aggregate) nella documentazione di Trino.
# Filtrare le matrici
Creare una matrice da una raccolta di righe nel caso in cui soddisfino i criteri di filtro.
```
WITH
dataset AS (
SELECT ARRAY[1,2,3,4,5] AS items
)
SELECT array_agg(i) AS array_items
FROM dataset
CROSS JOIN UNNEST(items) AS t(i)
WHERE i > 3
```
Questa query restituisce:
```
+-------------+
| array_items |
+-------------+
| [4, 5] |
+-------------+
```
Filtrare una matrice in base al fatto che uno dei suoi elementi contenga un valore specifico, ad esempio 2, come nel seguente esempio:
```
WITH
dataset AS (
SELECT ARRAY
[
ARRAY[1,2,3,4],
ARRAY[5,6,7,8],
ARRAY[9,0]
] AS items
)
SELECT i AS array_items FROM dataset
CROSS JOIN UNNEST(items) AS t(i)
WHERE contains(i, 2)
```
Questa query restituisce:
```
+--------------+
| array_items |
+--------------+
| [1, 2, 3, 4] |
+--------------+
```
## Utilizzare la funzione `filter`.
```
filter(ARRAY [list_of_values], boolean_function)
```
È possibile utilizzare la `filter` funzione su un'`ARRAY`espressione per creare un nuovo array che è il sottoinsieme degli elementi in *list\$1of\$1values* for *boolean\$1function* is true. La `filter` funzione può essere utile nei casi in cui non è possibile utilizzarla*UNNEST*.
Nell'esempio seguente vengono filtrati i valori maggiori di zero nella matrice `[1,0,5,-1]`.
```
SELECT filter(ARRAY [1,0,5,-1], x -> x>0)
```
**Risultati**
`[1,5]`
Nell'esempio seguente vengono filtrati i valori non-null nella matrice `[-1, NULL, 10, NULL]`.
```
SELECT filter(ARRAY [-1, NULL, 10, NULL], q -> q IS NOT NULL)
```
**Risultati**
`[-1,10]`
# Ordinare matrici
Per creare un array ordinato di valori univoci da un set di righe, puoi utilizzare la funzione [array\$1sort](https://prestodb.io/docs/current/functions/array.html#array_sort) come nell'esempio seguente.
```
WITH
dataset AS (
SELECT ARRAY[3,1,2,5,2,3,6,3,4,5] AS items
)
SELECT array_sort(array_agg(distinct i)) AS array_items
FROM dataset
CROSS JOIN UNNEST(items) AS t(i)
```
Questa query restituisce:
```
+--------------------+
| array_items |
+--------------------+
| [1, 2, 3, 4, 5, 6] |
+--------------------+
```
Per informazioni sull'espansione di un array in più righe, consulta la sezione [Appiattire matrici nidificate](flattening-arrays.md).
# Utilizzo delle funzioni di aggregazione con le matrici
+ Per aggiungere valori all'interno di un array, utilizza `SUM`, come nell'esempio seguente.
+ Per aggregare più righe all'interno di un array, utilizza `array_agg`. Per informazioni, consulta [Creare matrici da sottoquery](creating-arrays-from-subqueries.md).
**Nota**
`ORDER BY` è supportato per le funzioni di aggregazione a partire dalla versione 2 del motore Athena.
```
WITH
dataset AS (
SELECT ARRAY
[
ARRAY[1,2,3,4],
ARRAY[5,6,7,8],
ARRAY[9,0]
] AS items
),
item AS (
SELECT i AS array_items
FROM dataset, UNNEST(items) AS t(i)
)
SELECT array_items, sum(val) AS total
FROM item, UNNEST(array_items) AS t(val)
GROUP BY array_items;
```
Nell'ultima istruzione `SELECT`, invece di utilizzare `sum()` e `UNNEST`, è possibile utilizzare `reduce()` per ridurre il tempo di elaborazione e il trasferimento dei dati, come nell'esempio seguente.
```
WITH
dataset AS (
SELECT ARRAY
[
ARRAY[1,2,3,4],
ARRAY[5,6,7,8],
ARRAY[9,0]
] AS items
),
item AS (
SELECT i AS array_items
FROM dataset, UNNEST(items) AS t(i)
)
SELECT array_items, reduce(array_items, 0 , (s, x) -> s + x, s -> s) AS total
FROM item;
```
Qualsiasi query restituisce i seguenti risultati. L'ordine dei risultati restituiti non è garantito.
```
+----------------------+
| array_items | total |
+----------------------+
| [1, 2, 3, 4] | 10 |
| [5, 6, 7, 8] | 26 |
| [9, 0] | 9 |
+----------------------+
```
# Convertire le matrici in stringhe
Per convertire una matrice in una stringa singola, utilizza la funzione `array_join`. Il seguente esempio standalone crea una tabella denominata `dataset` che contiene una matrice alias chiamata `words`. La query utilizza `array_join` per unire gli elementi della matrice in `words`, separarli con spazi e restituire la stringa risultante in una colonna alias chiamata `welcome_msg`.
```
WITH
dataset AS (
SELECT ARRAY ['hello', 'amazon', 'athena'] AS words
)
SELECT array_join(words, ' ') AS welcome_msg
FROM dataset
```
Questa query restituisce:
```
+---------------------+
| welcome_msg |
+---------------------+
| hello amazon athena |
+---------------------+
```
# Utilizzo delle matrici per creare mappe
Le mappe sono coppie chiave-valore formate da tipi di dati disponibili in Athena. Per creare mappe, utilizza l'operatore `MAP` e passalo in due matrici: la prima è costituita dai nomi delle colonne (chiave) e la seconda dai valori. Tutti i valori nelle matrici devono essere dello stesso tipo. Se uno qualsiasi degli elementi nelle matrici di valori deve essere di tipo diverso, è possibile convertirlo più tardi.
## Esempi
In quest'esempio viene selezionato un utente da un set di dati. e si utilizza l'operatore `MAP`, facendolo poi passare da due matrici. La prima matrice include i valori per i nomi di colonna, ad esempio "primo", "ultimo" ed "età". La seconda matrice è formata da valori per ciascuna colonna, ad esempio "Bob", "Smith", "35".
```
WITH dataset AS (
SELECT MAP(
ARRAY['first', 'last', 'age'],
ARRAY['Bob', 'Smith', '35']
) AS user
)
SELECT user FROM dataset
```
Questa query restituisce:
```
+---------------------------------+
| user |
+---------------------------------+
| {last=Smith, first=Bob, age=35} |
+---------------------------------+
```
È possibile recuperare i valori `Map` selezionando il nome di campo seguito da `[key_name]`, come in questo esempio:
```
WITH dataset AS (
SELECT MAP(
ARRAY['first', 'last', 'age'],
ARRAY['Bob', 'Smith', '35']
) AS user
)
SELECT user['first'] AS first_name FROM dataset
```
Questa query restituisce:
```
+------------+
| first_name |
+------------+
| Bob |
+------------+
```
# Eseguire query su matrici con tipi complessi e strutture nidificate
I dati di origine contengono spesso matrici con tipi di dati complessi e strutture nidificate. Alcuni esempi di questa sezione mostrano come modificare il tipo di dati degli elementi, individuare elementi all'interno di matrici e trovare parole chiave utilizzando le query Athena.
**Topics**
+ [Creazione di una `ROW`](creating-row.md)
+ [Modificare i nomi di campo nelle matrici utilizzando `CAST`](changing-row-arrays-with-cast.md)
+ [Filtrare le matrici utilizzando la notazione `.`](filtering-with-dot.md)
+ [Filtrare le matrici con valori nidificati](filtering-nested-with-dot.md)
+ [Filtrare le matrici utilizzando `UNNEST`](filtering-with-unnest.md)
+ [Cercare parole chiave nelle matrici utilizzando `regexp_like`](filtering-with-regexp.md)
# Creazione di una `ROW`
**Nota**
Negli esempi di questa sezione viene utilizzato `ROW` come strumento per creare i dati di esempio con cui lavorare. Quando si eseguono le query di tabelle all'interno di Athena, non è necessario creare tipi di dati `ROW`, poiché sono già creati dall'origine dati. Quando si utilizza `CREATE_TABLE`, Athena definisce un `STRUCT` al suo interno, lo popola con i dati e crea il tipo di dati `ROW` per l'utente, per ogni riga nel set di dati. Il tipo di dati `ROW` sottostante è composto da campi designati di qualsiasi tipo di dati SQL supportato.
```
WITH dataset AS (
SELECT
ROW('Bob', 38) AS users
)
SELECT * FROM dataset
```
Questa query restituisce:
```
+-------------------------+
| users |
+-------------------------+
| {field0=Bob, field1=38} |
+-------------------------+
```
# Modificare i nomi di campo nelle matrici utilizzando `CAST`
Per modificare il nome di campo in una matrice che contiene valori `ROW`, è possibile utilizzare `CAST` per l'istruzione `ROW`:
```
WITH dataset AS (
SELECT
CAST(
ROW('Bob', 38) AS ROW(name VARCHAR, age INTEGER)
) AS users
)
SELECT * FROM dataset
```
Questa query restituisce:
```
+--------------------+
| users |
+--------------------+
| {NAME=Bob, AGE=38} |
+--------------------+
```
**Nota**
Nell'esempio sopra riportato, si dichiara `name` come `VARCHAR`, perché è il suo tipo in Presto. Se dichiari questo `STRUCT` all'interno di un'istruzione `CREATE TABLE`, utilizza il tipo `String`, perché Hive definisce questo tipo di dati come `String`.
# Filtrare le matrici utilizzando la notazione `.`
Nell'esempio seguente, seleziona il `accountId` campo dalla `userIdentity` colonna di una tabella di AWS CloudTrail log utilizzando la `.` notazione a punti. Per ulteriori informazioni, vedere [AWS CloudTrail Interrogazione](cloudtrail-logs.md) dei registri.
```
SELECT
CAST(useridentity.accountid AS bigint) as newid
FROM cloudtrail_logs
LIMIT 2;
```
Questa query restituisce:
```
+--------------+
| newid |
+--------------+
| 112233445566 |
+--------------+
| 998877665544 |
+--------------+
```
Per eseguire query di una matrice di valori, invia questa query:
```
WITH dataset AS (
SELECT ARRAY[
CAST(ROW('Bob', 38) AS ROW(name VARCHAR, age INTEGER)),
CAST(ROW('Alice', 35) AS ROW(name VARCHAR, age INTEGER)),
CAST(ROW('Jane', 27) AS ROW(name VARCHAR, age INTEGER))
] AS users
)
SELECT * FROM dataset
```
Tale operazione restituisce questo risultato:
```
+-----------------------------------------------------------------+
| users |
+-----------------------------------------------------------------+
| [{NAME=Bob, AGE=38}, {NAME=Alice, AGE=35}, {NAME=Jane, AGE=27}] |
+-----------------------------------------------------------------+
```
# Filtrare le matrici con valori nidificati
Le matrici di grandi dimensioni spesso contengono strutture nidificate ed è necessario essere in grado di filtrare o cercare i valori all'interno di tali matrici.
Per definire un set di dati per una matrice di valori che include un valore `BOOLEAN` nidificato, emetti la query seguente:
```
WITH dataset AS (
SELECT
CAST(
ROW('aws.amazon.com', ROW(true)) AS ROW(hostname VARCHAR, flaggedActivity ROW(isNew BOOLEAN))
) AS sites
)
SELECT * FROM dataset
```
Tale operazione restituisce questo risultato:
```
+----------------------------------------------------------+
| sites |
+----------------------------------------------------------+
| {HOSTNAME=aws.amazon.com, FLAGGEDACTIVITY={ISNEW=true}} |
+----------------------------------------------------------+
```
Quindi, per filtrare e individuare il valore `BOOLEAN` di tale elemento, continua a utilizzare la notazione `.`.
```
WITH dataset AS (
SELECT
CAST(
ROW('aws.amazon.com', ROW(true)) AS ROW(hostname VARCHAR, flaggedActivity ROW(isNew BOOLEAN))
) AS sites
)
SELECT sites.hostname, sites.flaggedactivity.isnew
FROM dataset
```
Questa query seleziona i campi nidificati e restituisce questo risultato:
```
+------------------------+
| hostname | isnew |
+------------------------+
| aws.amazon.com | true |
+------------------------+
```
# Filtrare le matrici utilizzando `UNNEST`
Per filtrare una matrice che include una struttura nidificata in base a uno dei suoi elementi figlio, invia una query con un operatore `UNNEST`. Per ulteriori informazioni su `UNNEST`, consulta la sezione relativa all'[appiattimento delle matrici nidificate](flattening-arrays.md).
Ad esempio, questa query individua nomi host dei siti nel set di dati.
```
WITH dataset AS (
SELECT ARRAY[
CAST(
ROW('aws.amazon.com', ROW(true)) AS ROW(hostname VARCHAR, flaggedActivity ROW(isNew BOOLEAN))
),
CAST(
ROW('news.cnn.com', ROW(false)) AS ROW(hostname VARCHAR, flaggedActivity ROW(isNew BOOLEAN))
),
CAST(
ROW('netflix.com', ROW(false)) AS ROW(hostname VARCHAR, flaggedActivity ROW(isNew BOOLEAN))
)
] as items
)
SELECT sites.hostname, sites.flaggedActivity.isNew
FROM dataset, UNNEST(items) t(sites)
WHERE sites.flaggedActivity.isNew = true
```
Restituisce:
```
+------------------------+
| hostname | isnew |
+------------------------+
| aws.amazon.com | true |
+------------------------+
```
# Cercare parole chiave nelle matrici utilizzando `regexp_like`
I seguenti esempi illustrano come cercare una parola chiave in un set di dati in un elemento all'interno di una matrice, utilizzando la funzione [regexp\$1like](https://prestodb.io/docs/current/functions/regexp.html). Come input prende in considerazione un modello di espressione regolare da analizzare o un elenco di termini separati da una barra verticale (\$1), valuta i modelli e determina se la stringa specificata li contiene.
L'espressione regolare deve essere contenuta all'interno della stringa e non deve corrispondere con essa. Affinché corrisponda all'intera stringa, racchiudi il motivo con ^ all'inizio e \$1 al termine, ad esempio `'^pattern$'`.
Considera una matrice di siti contenenti il loro nome host e un elemento `flaggedActivity`. Tale elemento include una `ARRAY` che a sua volta contiene diversi elementi `MAP`, ciascuno dei quali elenca diverse parole chiave comuni e il relativo conteggio popolarità. Supponi di voler trovare una determinata parola chiave all'interno di una `MAP` in questa matrice.
Per cercare questo set di dati per i siti con una parola chiave specifica, utilizziamo `regexp_like` anziché l'operatore `LIKE` SQL simile, perché la ricerca di un numero elevato di parole chiave è più efficiente con `regexp_like`.
**Example Esempio 1: utilizzo di `regexp_like`**
La query in questo esempio utilizza la funzione `regexp_like` per cercare termini `'politics|bigdata'`, ubicati nei valori all'interno delle matrici:
```
WITH dataset AS (
SELECT ARRAY[
CAST(
ROW('aws.amazon.com', ROW(ARRAY[
MAP(ARRAY['term', 'count'], ARRAY['bigdata', '10']),
MAP(ARRAY['term', 'count'], ARRAY['serverless', '50']),
MAP(ARRAY['term', 'count'], ARRAY['analytics', '82']),
MAP(ARRAY['term', 'count'], ARRAY['iot', '74'])
])
) AS ROW(hostname VARCHAR, flaggedActivity ROW(flags ARRAY(MAP(VARCHAR, VARCHAR)) ))
),
CAST(
ROW('news.cnn.com', ROW(ARRAY[
MAP(ARRAY['term', 'count'], ARRAY['politics', '241']),
MAP(ARRAY['term', 'count'], ARRAY['technology', '211']),
MAP(ARRAY['term', 'count'], ARRAY['serverless', '25']),
MAP(ARRAY['term', 'count'], ARRAY['iot', '170'])
])
) AS ROW(hostname VARCHAR, flaggedActivity ROW(flags ARRAY(MAP(VARCHAR, VARCHAR)) ))
),
CAST(
ROW('netflix.com', ROW(ARRAY[
MAP(ARRAY['term', 'count'], ARRAY['cartoons', '1020']),
MAP(ARRAY['term', 'count'], ARRAY['house of cards', '112042']),
MAP(ARRAY['term', 'count'], ARRAY['orange is the new black', '342']),
MAP(ARRAY['term', 'count'], ARRAY['iot', '4'])
])
) AS ROW(hostname VARCHAR, flaggedActivity ROW(flags ARRAY(MAP(VARCHAR, VARCHAR)) ))
)
] AS items
),
sites AS (
SELECT sites.hostname, sites.flaggedactivity
FROM dataset, UNNEST(items) t(sites)
)
SELECT hostname
FROM sites, UNNEST(sites.flaggedActivity.flags) t(flags)
WHERE regexp_like(flags['term'], 'politics|bigdata')
GROUP BY (hostname)
```
Questa query restituisce due siti:
```
+----------------+
| hostname |
+----------------+
| aws.amazon.com |
+----------------+
| news.cnn.com |
+----------------+
```
**Example Esempio 2: utilizzo di `regexp_like`**
La query nell'esempio seguente aggiunge il punteggio totale di popolarità per i siti che soddisfano i termini di ricerca con la funzione `regexp_like`, quindi li ordina dal più alto al più basso.
```
WITH dataset AS (
SELECT ARRAY[
CAST(
ROW('aws.amazon.com', ROW(ARRAY[
MAP(ARRAY['term', 'count'], ARRAY['bigdata', '10']),
MAP(ARRAY['term', 'count'], ARRAY['serverless', '50']),
MAP(ARRAY['term', 'count'], ARRAY['analytics', '82']),
MAP(ARRAY['term', 'count'], ARRAY['iot', '74'])
])
) AS ROW(hostname VARCHAR, flaggedActivity ROW(flags ARRAY(MAP(VARCHAR, VARCHAR)) ))
),
CAST(
ROW('news.cnn.com', ROW(ARRAY[
MAP(ARRAY['term', 'count'], ARRAY['politics', '241']),
MAP(ARRAY['term', 'count'], ARRAY['technology', '211']),
MAP(ARRAY['term', 'count'], ARRAY['serverless', '25']),
MAP(ARRAY['term', 'count'], ARRAY['iot', '170'])
])
) AS ROW(hostname VARCHAR, flaggedActivity ROW(flags ARRAY(MAP(VARCHAR, VARCHAR)) ))
),
CAST(
ROW('netflix.com', ROW(ARRAY[
MAP(ARRAY['term', 'count'], ARRAY['cartoons', '1020']),
MAP(ARRAY['term', 'count'], ARRAY['house of cards', '112042']),
MAP(ARRAY['term', 'count'], ARRAY['orange is the new black', '342']),
MAP(ARRAY['term', 'count'], ARRAY['iot', '4'])
])
) AS ROW(hostname VARCHAR, flaggedActivity ROW(flags ARRAY(MAP(VARCHAR, VARCHAR)) ))
)
] AS items
),
sites AS (
SELECT sites.hostname, sites.flaggedactivity
FROM dataset, UNNEST(items) t(sites)
)
SELECT hostname, array_agg(flags['term']) AS terms, SUM(CAST(flags['count'] AS INTEGER)) AS total
FROM sites, UNNEST(sites.flaggedActivity.flags) t(flags)
WHERE regexp_like(flags['term'], 'politics|bigdata')
GROUP BY (hostname)
ORDER BY total DESC
```
Questa query restituisce due siti:
```
+------------------------------------+
| hostname | terms | total |
+----------------+-------------------+
| news.cnn.com | politics | 241 |
+----------------+-------------------+
| aws.amazon.com | bigdata | 10 |
+----------------+-------------------+
```
# Eseguire query su dati geospaziali.
I dati geospaziali contengono identificatori che specificano una posizione geografica per un oggetto. Esempi di questo tipo di dati includono i bollettini meteorologici, le indicazioni stradali sulle mappe, i tweet con posizioni geografiche, le ubicazioni dei negozi e le tratte delle compagnie aeree. I dati geospaziali svolgono un ruolo importante per le attività di analisi aziendale, creazione di report e di previsione.
Gli identificatori geospaziali quali latitudine e longitudine consentono di convertire qualsiasi indirizzo postale in un set di coordinate geografiche.
## Cos'è una query geospaziale?
Le query geospaziali sono tipi speciali di query SQL supportati in Athena. Si differiscono dalle query SQL non spaziali nei seguenti modi:
+ Utilizzano i seguenti tipi di dati geometrici specializzati: `point`, `line`, `multiline`, `polygon` e `multipolygon`.
+ Esprimono relazioni tra tipi di dati geometrici, ad esempio `distance`, `equals`, `crosses`, `touches`, `overlaps`, `disjoint`, tra le altre.
Se si utilizzano query geospaziali in Athena, è possibile eseguire queste e altre operazioni simili:
+ Individuare la distanza tra due punti;
+ Controllare se un'area (poligono) ne contiene un'altra;
+ Controllare se una linea attraversa o tocca un'altra linea o un poligono.
Ad esempio, per ottenere un tipo di dati geometria `point` da valori di tipo `double` per le coordinate geografiche di Monte Rainier in Athena, utilizzare la funzione geospaziale `ST_Point (longitude, latitude)`, come nell'esempio seguente.
```
ST_Point(-121.7602, 46.8527)
```
## Formati dei dati di input e tipi di dati di geometria
Per utilizzare le funzioni geospaziali in Athena, inserisci i dati nel formato WKT o usa Hive JSON. SerDe È inoltre possibile utilizzare i tipi di dati di geometria supportati in Athena.
### Formati dei dati di input
Per gestire le query geospaziali, Athena supporta i dati di input in questi formati di dati:
+ **WKT (Well-known Text)**. In Athena, WKT è rappresentato da un tipo di dati `varchar(x)` o `string`.
+ **Dati geospaziali codificati JSON**. [Per analizzare i file JSON con dati geospaziali e creare tabelle per essi, Athena utilizza Hive JSON. SerDe](https://github.com/Esri/spatial-framework-for-hadoop/wiki/Hive-JSON-SerDe) Per ulteriori informazioni sull'utilizzo di questa funzionalità SerDe in Athena, vedere. [Librerie JSON SerDe](json-serde.md)
### Tipi di dati di geometria
Per gestire le query geospaziali, Athena supporta questi tipi di dati di geometria specializzati:
+ `point`
+ `line`
+ `polygon`
+ `multiline`
+ `multipolygon`
## Funzioni geospaziali supportate
Per informazioni sulle funzioni geospaziali della versione 3 del motore Athena, consulta [Funzioni geospaziali](https://trino.io/docs/current/functions/geospatial.html) nella documentazione di Trino.
# Esempi: query geospaziali
Gli esempi in questo argomento creano due tabelle a partire dai dati di esempio disponibili GitHub e interrogano le tabelle in base ai dati. I dati di esempio, che sono solo a scopo illustrativo e non sono garantiti per essere accurati, si trovano nei seguenti file:
+ **[https://github.com/Esri/gis-tools-for-hadoop/blob/master/samples/data/earthquake-data/earthquakes.csv](https://github.com/Esri/gis-tools-for-hadoop/blob/master/samples/data/earthquake-data/earthquakes.csv)**: elenca i terremoti che si sono verificati in California. Nella tabella di esempio `earthquakes` vengono utilizzati i campi di questi dati.
+ **[https://github.com/Esri/gis-tools-for-hadoop/blob/master/samples/data/counties-data/california-counties.json](https://github.com/Esri/gis-tools-for-hadoop/blob/master/samples/data/counties-data/california-counties.json)**: elenca i dati della contea per lo stato della California in [formato ESRI-compliant GeoJSON](https://doc.arcgis.com/en/arcgis-online/reference/geojson.htm). I dati includono molti campi, ad esempio `AREA`, `PERIMETER`, `STATE`, `COUNTY`, e `NAME`, ma nella tabella `counties` di esempio ne vengono utilizzati solo due: `Name` (stringa) e `BoundaryShape` (binario).
**Nota**
Athena utilizza `com.esri.json.hadoop.EnclosedEsriJsonInputFormat` per convertire i dati JSON in formato binario geospaziale.
Il seguente esempio di codice crea una tabella denominata `earthquakes`.
```
CREATE external TABLE earthquakes
(
earthquake_date string,
latitude double,
longitude double,
depth double,
magnitude double,
magtype string,
mbstations string,
gap string,
distance string,
rms string,
source string,
eventid string
)
ROW FORMAT DELIMITED FIELDS TERMINATED BY ','
STORED AS TEXTFILE LOCATION 's3://amzn-s3-demo-bucket/my-query-log/csv/';
```
Il seguente esempio di codice crea una tabella denominata `counties`.
```
CREATE external TABLE IF NOT EXISTS counties
(
Name string,
BoundaryShape binary
)
ROW FORMAT SERDE 'com.esri.hadoop.hive.serde.EsriJsonSerDe'
STORED AS INPUTFORMAT 'com.esri.json.hadoop.EnclosedEsriJsonInputFormat'
OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION 's3://amzn-s3-demo-bucket/my-query-log/json/';
```
La seguente query di esempio utilizza la funzione `CROSS JOIN` nelle tabelle `counties` e `earthquake`. L'esempio utilizza `ST_CONTAINS` per eseguire query per le contee i cui confini includono le località dei terremoti, specificate con `ST_POINT`. La query raggruppa quindi gruppi tali paesi per nome, li ordina per conteggio e li restituisce in modo decrescente.
```
SELECT counties.name,
COUNT(*) cnt
FROM counties
CROSS JOIN earthquakes
WHERE ST_CONTAINS (ST_GeomFromLegacyBinary(counties.boundaryshape), ST_POINT(earthquakes.longitude, earthquakes.latitude))
GROUP BY counties.name
ORDER BY cnt DESC
```
Questa query restituisce:
```
+------------------------+
| name | cnt |
+------------------------+
| Kern | 36 |
+------------------------+
| San Bernardino | 35 |
+------------------------+
| Imperial | 28 |
+------------------------+
| Inyo | 20 |
+------------------------+
| Los Angeles | 18 |
+------------------------+
| Riverside | 14 |
+------------------------+
| Monterey | 14 |
+------------------------+
| Santa Clara | 12 |
+------------------------+
| San Benito | 11 |
+------------------------+
| Fresno | 11 |
+------------------------+
| San Diego | 7 |
+------------------------+
| Santa Cruz | 5 |
+------------------------+
| Ventura | 3 |
+------------------------+
| San Luis Obispo | 3 |
+------------------------+
| Orange | 2 |
+------------------------+
| San Mateo | 1 |
+------------------------+
```
## Risorse aggiuntive
Per altri esempi di query geospaziali, consulta i seguenti post di blog:
+ [Estendi le query geospaziali in Amazon Athena con e UDFs AWS Lambda](https://aws.amazon.com/blogs/big-data/extend-geospatial-queries-in-amazon-athena-with-udfs-and-aws-lambda/)
+ [Visualizza oltre 200 anni di dati climatici globali utilizzando Amazon Athena e Amazon Quick](https://aws.amazon.com/blogs/big-data/visualize-over-200-years-of-global-climate-data-using-amazon-athena-and-amazon-quicksight/).
+ [Interrogazioni OpenStreetMap con Amazon Athena](https://aws.amazon.com/blogs/big-data/querying-openstreetmap-with-amazon-athena/)
# Dati JSON
Amazon Athena consente di analizzare i valori con codifica JSON, estrarre i dati da JSON, cercare valori e trovare i valori di lunghezza e dimensioni per matrici JSON. Per apprendere le nozioni di base sull’interrogazione dei dati JSON in Athena, prendi in considerazione i seguenti dati planetari di esempio:
```
{name:"Mercury",distanceFromSun:0.39,orbitalPeriod:0.24,dayLength:58.65}
{name:"Venus",distanceFromSun:0.72,orbitalPeriod:0.62,dayLength:243.02}
{name:"Earth",distanceFromSun:1.00,orbitalPeriod:1.00,dayLength:1.00}
{name:"Mars",distanceFromSun:1.52,orbitalPeriod:1.88,dayLength:1.03}
```
Notate come ogni record (essenzialmente, ogni riga della tabella) si trovi su una riga distinta. Per interrogare questi dati JSON, puoi usare un'`CREATE TABLE`istruzione come la seguente:
```
CREATE EXTERNAL TABLE `planets_json`(
`name` string,
`distancefromsun` double,
`orbitalperiod` double,
`daylength` double)
ROW FORMAT SERDE
'org.openx.data.jsonserde.JsonSerDe'
STORED AS INPUTFORMAT
'org.apache.hadoop.mapred.TextInputFormat'
OUTPUTFORMAT
'org.apache.hadoop.hive.ql.io.IgnoreKeyTextOutputFormat'
LOCATION
's3://amzn-s3-demo-bucket/json/'
```
Per interrogare i dati, utilizzate un’`SELECT`istruzione semplice come nell’esempio seguente.
```
SELECT * FROM planets_json
```
I risultati sono simili ai seguenti:
****
| \$1 | nome | distanza dal sole | periodo orbitale | durata del giorno |
| --- | --- | --- | --- | --- |
| 1 | Mercurio | 0,39 | 0,24 | 58,65 |
| 2 | Venere | 0,72 | 0,62 | 243,02 |
| 3 | Terra | 1.0 | 1.0 | 1.0 |
| 4 | Marte | 1,52 | 1,88 | 1,03 |
Nota come l’`CREATE TABLE`istruzione utilizza il[OpenX JSON SerDe](openx-json-serde.md), che richiede che ogni record JSON si trovi su una riga separata. Se il JSON è in un bel formato di stampa o se tutti i record sono su una sola riga, i dati non verranno letti correttamente.
Per interrogare dati JSON in un bel formato di stampa, puoi usare [Amazon Ion Hive SerDe](ion-serde.md) invece di SerDe OpenX JSON. Considerate i dati precedenti memorizzati in un grazioso formato di stampa:
```
{
name:"Mercury",
distanceFromSun:0.39,
orbitalPeriod:0.24,
dayLength:58.65
}
{
name:"Venus",
distanceFromSun:0.72,
orbitalPeriod:0.62,
dayLength:243.02
}
{
name:"Earth",
distanceFromSun:1.00,
orbitalPeriod:1.00,
dayLength:1.00
}
{
name:"Mars",
distanceFromSun:1.52,
orbitalPeriod:1.88,
dayLength:1.03
}
```
Per interrogare questi dati senza riformattarli, puoi usare un'`CREATE TABLE`istruzione come la seguente. Nota che, invece di specificare OpenX SerDe JSON, l'istruzione specifica. `STORED AS ION`
```
CREATE EXTERNAL TABLE `planets_ion`(
`name` string,
`distancefromsun` DECIMAL(10, 2),
`orbitalperiod` DECIMAL(10, 2),
`daylength` DECIMAL(10, 2))
STORED AS ION
LOCATION
's3://amzn-s3-demo-bucket/json-ion/'
```
La query `SELECT * FROM planets_ion` produce gli stessi risultati di prima. Per ulteriori informazioni sulla creazione di tabelle in questo modo utilizzando Amazon Ion Hive SerDe, consulta[Creare tabelle Amazon Ion](ion-serde-using-create-table.md).
L’esempio precedente i dati JSON non contengono tipi di dati complessi come array o strutture annidate. Per ulteriori informazioni sull’esecuzione di query sui dati JSON annidati, consulta. [Esempio di deserializzazione di un JSON nidificato](openx-json-serde.md#nested-json-serde-example)
**Topics**
+ [Best practice per la lettura di dati JSON](parsing-json-data.md)
+ [Estrarre dati JSON da stringhe](extracting-data-from-JSON.md)
+ [Cercare valori nelle matrici JSON](searching-for-values.md)
+ [Ottenere matrici JSON di lunghezza e dimensione](length-and-size.md)
+ [Risolvere i problemi relativi alle query JSON](json-troubleshooting.md)
# Best practice per la lettura di dati JSON
JavaScript Object Notation (JSON) è un metodo comune per codificare le strutture di dati come testo. Molte applicazioni e numerosi strumenti restituiscono dati con codifica JSON.
In Amazon Athena, è possibile creare tabelle da dati esterni e includervi i dati con codifica JSON. Per tali tipi di dati di origine, utilizza Athena insieme a [Librerie JSON SerDe](json-serde.md).
Segui i seguenti suggerimenti per leggere i dati con codifica JSON:
+ Scegli quello giusto SerDe, un JSON nativo o un SerDe `org.openx.data.jsonserde.JsonSerDe` OpenX SerDe`org.apache.hive.hcatalog.data.JsonSerDe`,. Per ulteriori informazioni, consulta [Librerie JSON SerDe](json-serde.md).
+ Assicurati che ogni record con codifica JSON sia rappresentato su una riga separata, non formattata.
**Nota**
SerDe Si aspetta che ogni documento JSON si trovi su una singola riga di testo senza caratteri di terminazione di riga che separano i campi del record. Se il testo JSON è in un bel formato di stampa, potresti ricevere un messaggio di errore come HIVE\$1CURSOR\$1ERROR: Row is not a valid JSON Object o HIVE\$1CURSOR\$1ERROR:: Unexpected end-of-input: expected: expected close marker for OBJECT quando tenti di interrogare la tabella dopo averla JsonParseException creata. Per ulteriori informazioni, consulta [JSON Data Files](https://github.com/rcongiu/Hive-JSON-Serde#json-data-files) nella documentazione di SerDe OpenX su. GitHub
+ Genera i dati con codifica JSON in colonne con distinzione tra maiuscole e minuscole.
+ Fornisci un'opzione per ignorare i record in formato errato, come in questo esempio.
```
CREATE EXTERNAL TABLE json_table (
column_a string,
column_b int
)
ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe'
WITH SERDEPROPERTIES ('ignore.malformed.json' = 'true')
LOCATION 's3://amzn-s3-demo-bucket/path/';
```
+ Converti i campi nei dati di origine che hanno uno schema indeterminato in stringhe con codifica JSON in Athena.
Quando Athena crea tabelle basate su dati con codifica JSON, analizza i dati in base allo schema esistente e predefinito. Tuttavia, è possibile che non tutti i dati presentino uno schema predefinito. In questi casi, per semplificare la gestione degli schemi, spesso è consigliabile convertire i campi in dati di origine che dispongano di uno schema indeterminato su stringhe JSON in Athena, per poi utilizzare [Librerie JSON SerDe](json-serde.md).
Prendiamo ad esempio in considerazione un'applicazione IoT che pubblica eventi con campi comuni da diversi sensori. Uno di tali campi devono archiviare un payload personalizzato univoco per il sensore che invia l'evento. In questo caso, poiché lo schema non è noto, è consigliabile archiviare le informazioni in forma di stringa con codifica JSON. A tale scopo, occorre convertire i dati nella tabella Athena in JSON, come nell'esempio seguente. È inoltre possibile convertire i dati con codifica JSON in tipi di dati Athena.
**Topics**
+ [Convertire i tipi di dati Athena in JSON](converting-native-data-types-to-json.md)
+ [Convertire tipi di dati JSON in Athena](converting-json-to-native-data-types.md)
# Convertire i tipi di dati Athena in JSON
Per convertire i tipi di dati Athena in JSON, utilizza `CAST`.
```
WITH dataset AS (
SELECT
CAST('HELLO ATHENA' AS JSON) AS hello_msg,
CAST(12345 AS JSON) AS some_int,
CAST(MAP(ARRAY['a', 'b'], ARRAY[1,2]) AS JSON) AS some_map
)
SELECT * FROM dataset
```
Questa query restituisce:
```
+-------------------------------------------+
| hello_msg | some_int | some_map |
+-------------------------------------------+
| "HELLO ATHENA" | 12345 | {"a":1,"b":2} |
+-------------------------------------------+
```
# Convertire tipi di dati JSON in Athena
Per convertire i dati JSON nei tipi di dati Athena, utilizza `CAST`.
**Nota**
In questo esempio, per indicare le stringhe con codifica JSON, inizia con la parola chiave `JSON` e utilizza virgolette singole, ad esempio `JSON '12345'`
```
WITH dataset AS (
SELECT
CAST(JSON '"HELLO ATHENA"' AS VARCHAR) AS hello_msg,
CAST(JSON '12345' AS INTEGER) AS some_int,
CAST(JSON '{"a":1,"b":2}' AS MAP(VARCHAR, INTEGER)) AS some_map
)
SELECT * FROM dataset
```
Questa query restituisce:
```
+-------------------------------------+
| hello_msg | some_int | some_map |
+-------------------------------------+
| HELLO ATHENA | 12345 | {a:1,b:2} |
+-------------------------------------+
```
# Estrarre dati JSON da stringhe
È possibile che alcuni dei dati di origine che contengono stringhe codificate JSON non debbano essere necessariamente deserializzate in una tabella Athena. In tal caso, è comunque possibile eseguire operazioni SQL su questi dati utilizzando le funzioni JSON disponibili in Presto.
Considera questa stringa JSON come un set di dati di esempio.
```
{"name": "Susan Smith",
"org": "engineering",
"projects":
[
{"name":"project1", "completed":false},
{"name":"project2", "completed":true}
]
}
```
## Esempi: Estrarre proprietà
Per estrarre le proprietà `name` e `projects` dalla stringa JSON, utilizza la funzione `json_extract`, come nell'esempio seguente. La funzione `json_extract` analizza la colonna contenente la stringa JSON e vi esegue la ricerca impiegando un'espressione LIKE `JSONPath` con la notazione del punto `.`.
**Nota**
`JSONPath` esegue un attraversamento semplice della struttura. utilizzando il simbolo `$` per indicare la radice del documento JSON, seguita da un punto e da un elemento nidificato direttamente sotto il livello radice, ad esempio `$.name`.
```
WITH dataset AS (
SELECT '{"name": "Susan Smith",
"org": "engineering",
"projects": [{"name":"project1", "completed":false},
{"name":"project2", "completed":true}]}'
AS myblob
)
SELECT
json_extract(myblob, '$.name') AS name,
json_extract(myblob, '$.projects') AS projects
FROM dataset
```
Il valore restituito è una stringa con codifica JSON e non un tipo di dati Athena nativo.
```
+-----------------------------------------------------------------------------------------------+
| name | projects |
+-----------------------------------------------------------------------------------------------+
| "Susan Smith" | [{"name":"project1","completed":false},{"name":"project2","completed":true}] |
+-----------------------------------------------------------------------------------------------+
```
Per estrarre il valore scalare dalla stringa JSON, utilizza la funzione `json_extract_scalar(json, json_path)`. È simile a `json_extract`, ma restituisce un valore di stringa `varchar` anziché una stringa con codifica JSON. Il valore del *json\$1path* parametro deve essere uno scalare (un valore booleano, un numero o una stringa).
**Nota**
Non utilizzare la funzione `json_extract_scalar` su matrici, mappe o strutture.
```
WITH dataset AS (
SELECT '{"name": "Susan Smith",
"org": "engineering",
"projects": [{"name":"project1", "completed":false},{"name":"project2", "completed":true}]}'
AS myblob
)
SELECT
json_extract_scalar(myblob, '$.name') AS name,
json_extract_scalar(myblob, '$.projects') AS projects
FROM dataset
```
Questa query restituisce:
```
+---------------------------+
| name | projects |
+---------------------------+
| Susan Smith | |
+---------------------------+
```
Per ottenere il primo elemento della proprietà `projects` nella matrice di esempio, utilizza la funzione `json_array_get` e specifica la posizione indice.
```
WITH dataset AS (
SELECT '{"name": "Bob Smith",
"org": "engineering",
"projects": [{"name":"project1", "completed":false},{"name":"project2", "completed":true}]}'
AS myblob
)
SELECT json_array_get(json_extract(myblob, '$.projects'), 0) AS item
FROM dataset
```
Restituirà il valore nella posizione indice specificata nella matrice codificata JSON.
```
+---------------------------------------+
| item |
+---------------------------------------+
| {"name":"project1","completed":false} |
+---------------------------------------+
```
Per restituire un tipo di stringa Athena, utilizza l'operatore `[]` all'interno di un'espressione `JSONPath`, quindi utilizza la funzione `json_extract_scalar`. Per ulteriori informazioni su `[]`, consultare [Accedere agli elementi della matrice](accessing-array-elements.md).
```
WITH dataset AS (
SELECT '{"name": "Bob Smith",
"org": "engineering",
"projects": [{"name":"project1", "completed":false},{"name":"project2", "completed":true}]}'
AS myblob
)
SELECT json_extract_scalar(myblob, '$.projects[0].name') AS project_name
FROM dataset
```
Tale operazione restituisce questo risultato:
```
+--------------+
| project_name |
+--------------+
| project1 |
+--------------+
```
# Cercare valori nelle matrici JSON
Per determinare se un determinato valore esiste all'interno di una matrice con codifica JSON, utilizza la funzione `json_array_contains`.
La query seguente elenca i nomi degli utenti che partecipano a "project2".
```
WITH dataset AS (
SELECT * FROM (VALUES
(JSON '{"name": "Bob Smith", "org": "legal", "projects": ["project1"]}'),
(JSON '{"name": "Susan Smith", "org": "engineering", "projects": ["project1", "project2", "project3"]}'),
(JSON '{"name": "Jane Smith", "org": "finance", "projects": ["project1", "project2"]}')
) AS t (users)
)
SELECT json_extract_scalar(users, '$.name') AS user
FROM dataset
WHERE json_array_contains(json_extract(users, '$.projects'), 'project2')
```
Questa query restituisce un elenco di utenti.
```
+-------------+
| user |
+-------------+
| Susan Smith |
+-------------+
| Jane Smith |
+-------------+
```
La seguente query di esempio elenca i nomi degli utenti che hanno completato progetti con il numero totale di progetti completati. Esegue le seguenti operazioni:
+ Utilizza istruzioni `SELECT` nidificate per chiarezza.
+ Estrae la matrice di progetti.
+ Converte la matrice in una matrice nativa di coppie chiave-valore utilizzando `CAST`.
+ Estrae ogni singolo elemento di matrice utilizzando l'operatore `UNNEST`.
+ Filtra i valori ottenuti in base ai progetti completati e li conta.
**Nota**
Quando si utilizza `CAST` su `MAP`, è possibile specificare l'elemento chiave come `VARCHAR` (stringa nativa in Presto), lasciando però il valore come JSON, perché i valori in `MAP` sono di tipi diversi: String per la prima coppia chiave-valore e Boolean per il secondo.
```
WITH dataset AS (
SELECT * FROM (VALUES
(JSON '{"name": "Bob Smith",
"org": "legal",
"projects": [{"name":"project1", "completed":false}]}'),
(JSON '{"name": "Susan Smith",
"org": "engineering",
"projects": [{"name":"project2", "completed":true},
{"name":"project3", "completed":true}]}'),
(JSON '{"name": "Jane Smith",
"org": "finance",
"projects": [{"name":"project2", "completed":true}]}')
) AS t (users)
),
employees AS (
SELECT users, CAST(json_extract(users, '$.projects') AS
ARRAY(MAP(VARCHAR, JSON))) AS projects_array
FROM dataset
),
names AS (
SELECT json_extract_scalar(users, '$.name') AS name, projects
FROM employees, UNNEST (projects_array) AS t(projects)
)
SELECT name, count(projects) AS completed_projects FROM names
WHERE cast(element_at(projects, 'completed') AS BOOLEAN) = true
GROUP BY name
```
Questa query restituisce il seguente risultato:
```
+----------------------------------+
| name | completed_projects |
+----------------------------------+
| Susan Smith | 2 |
+----------------------------------+
| Jane Smith | 1 |
+----------------------------------+
```
# Ottenere matrici JSON di lunghezza e dimensione
Per ottenere matrici JSON di lunghezza e dimensione, è possibile utilizzare le funzioni `json_array_length` e `json_size`.
## Ad esempio: `json_array_length`
Per ottenere la lunghezza di una matrice con codifica JSON, utilizza la funzione `json_array_length`.
```
WITH dataset AS (
SELECT * FROM (VALUES
(JSON '{"name":
"Bob Smith",
"org":
"legal",
"projects": [{"name":"project1", "completed":false}]}'),
(JSON '{"name": "Susan Smith",
"org": "engineering",
"projects": [{"name":"project2", "completed":true},
{"name":"project3", "completed":true}]}'),
(JSON '{"name": "Jane Smith",
"org": "finance",
"projects": [{"name":"project2", "completed":true}]}')
) AS t (users)
)
SELECT
json_extract_scalar(users, '$.name') as name,
json_array_length(json_extract(users, '$.projects')) as count
FROM dataset
ORDER BY count DESC
```
Questa query restituisce il risultato seguente:
```
+---------------------+
| name | count |
+---------------------+
| Susan Smith | 2 |
+---------------------+
| Bob Smith | 1 |
+---------------------+
| Jane Smith | 1 |
+---------------------+
```
## Ad esempio: `json_size`
Per ottenere le dimensioni di una matrice o di oggetto con codifica JSON, utilizza la funzione `json_size` e specifica la colonna contenente la stringa JSON e l'espressione `JSONPath` per la matrice o l'oggetto.
```
WITH dataset AS (
SELECT * FROM (VALUES
(JSON '{"name": "Bob Smith", "org": "legal", "projects": [{"name":"project1", "completed":false}]}'),
(JSON '{"name": "Susan Smith", "org": "engineering", "projects": [{"name":"project2", "completed":true},{"name":"project3", "completed":true}]}'),
(JSON '{"name": "Jane Smith", "org": "finance", "projects": [{"name":"project2", "completed":true}]}')
) AS t (users)
)
SELECT
json_extract_scalar(users, '$.name') as name,
json_size(users, '$.projects') as count
FROM dataset
ORDER BY count DESC
```
Questa query restituisce il risultato seguente:
```
+---------------------+
| name | count |
+---------------------+
| Susan Smith | 2 |
+---------------------+
| Bob Smith | 1 |
+---------------------+
| Jane Smith | 1 |
+---------------------+
```
# Risolvere i problemi relativi alle query JSON
Per assistenza sulla risoluzione dei problemi relativi alle query relative a JSON, consulta [Errori correlati a JSON](troubleshooting-athena.md#troubleshooting-athena-json-related-errors) o le risorse seguenti:
+ [Ricevo messaggi di errore quando cerco di leggere dati JSON su Amazon Athena](https://aws.amazon.com/premiumsupport/knowledge-center/error-json-athena/)
+ [Come posso risolvere «HIVE\$1CURSOR\$1ERROR: Row is not a valid JSON object - JSONException: Duplicate key» durante la lettura di file da Athena? AWS Config](https://aws.amazon.com/premiumsupport/knowledge-center/json-duplicate-key-error-athena-config/)
+ [La query SELECT COUNT in Amazon Athena restituisce solo un record, anche se il file di input JSON dispone di più record](https://aws.amazon.com/premiumsupport/knowledge-center/select-count-query-athena-json-records/)
+ [In che modo è possibile visualizzare il file sorgente Amazon S3 per cercare una riga di una tabella Athena?](https://aws.amazon.com/premiumsupport/knowledge-center/find-s3-source-file-athena-table-row/)
Consulta anche [Considerazioni e restrizioni per le query SQL in Amazon Athena](other-notable-limitations.md).
# Utilizzare Machine Learning (ML) con Amazon Athena
Machine Learning (ML) con Amazon Athena ti consente di utilizzare Athena per scrivere istruzioni SQL che eseguono inferenze di Machine Learning (ML) utilizzando Amazon AI. SageMaker Questa caratteristica semplifica l'accesso ai modelli ML per l'analisi dei dati, eliminando la necessità di utilizzare metodi di programmazione complessi per eseguire l'inferenza.
Per usare ML con Athena, si definisce un ML con la funzione Athena con la clausola `USING EXTERNAL FUNCTION`. La funzione punta all'endpoint del modello di SageMaker intelligenza artificiale che desideri utilizzare e specifica i nomi delle variabili e i tipi di dati da passare al modello. Le clausole successive nella query fanno riferimento alla funzione per passare valori al modello. Il modello esegue l'inferenza in base ai valori passati dalla query e quindi restituisce i risultati dell'inferenza. Per ulteriori informazioni sull' SageMaker intelligenza artificiale e su come funzionano gli endpoint SageMaker AI, consulta la [Amazon SageMaker AI Developer Guide](https://docs.aws.amazon.com/sagemaker/latest/dg/).
Per un esempio che utilizza il machine learning con Athena e l'inferenza SageMaker AI per rilevare un valore anomalo in un set di risultati, consulta l'articolo del AWS Big Data Blog [Rilevare valori anomali richiamando la funzione di inferenza di apprendimento automatico di Amazon](https://aws.amazon.com/blogs/big-data/detecting-anomalous-values-by-invoking-the-amazon-athena-machine-learning-inference-function/) Athena.
## Considerazioni e limitazioni
+ **Regioni disponibili**: la funzionalità Athena ML è disponibile laddove è supportata la versione 2 o successiva del motore Regioni AWS Athena.
+ SageMaker L'**endpoint del modello AI deve essere accettato e restituito `text/csv`**: per ulteriori informazioni sui formati di dati, consulta [Common data formats for inference](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html) nella *Amazon SageMaker AI Developer Guide*.
+ **Athena non invia intestazioni CSV**: se l'endpoint SageMaker AI lo è`text/csv`, il gestore di input non deve presumere che la prima riga dell'input sia un'intestazione CSV. Poiché Athena non invia intestazioni CSV, l'output restituito ad Athena conterrà una riga in meno di quella prevista da Athena e causerà un errore.
+ **SageMaker Scalabilità degli endpoint AI**: assicurati che l'endpoint del modello SageMaker AI di riferimento sia sufficientemente scalato per le chiamate Athena all'endpoint. Per ulteriori informazioni, consulta la sezione [Scalabilità automatica dei modelli di SageMaker intelligenza](https://docs.aws.amazon.com/sagemaker/latest/dg/endpoint-auto-scaling.html) artificiale nella *Amazon SageMaker AI Developer Guide* e [CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/dg/API_CreateEndpointConfig.html)nell'*Amazon SageMaker AI API Reference*.
+ **Autorizzazioni IAM**: per eseguire una query che specifica un ML con la funzione Athena, è necessario consentire al principale IAM che esegue la query di eseguire l'`sagemaker:InvokeEndpoint`azione per l'endpoint del modello AI di riferimento SageMaker . Per ulteriori informazioni, consulta [Autorizzazione per l’accesso per ML con Athena](machine-learning-iam-access.md).
+ **ML con funzioni Athena non può essere usato direttamente nelle clausole `GROUP BY`**
**Topics**
+ [Considerazioni e limitazioni](#considerations-and-limitations)
+ [Utilizzare ML con sintassi Athena](ml-syntax.md)
+ [Vedere esempi di utilizzo per i clienti](ml-videos.md)
# Utilizzare ML con sintassi Athena
La clausola `USING EXTERNAL FUNCTION` specifica un ML con funzione o più funzioni Athena a cui è possibile fare riferimento da un'istruzione `SELECT` successiva nella query. Definire il nome della funzione, i nomi delle variabili e i tipi di dati per le variabili e i valori restituiti.
## Riepilogo
La seguente sintassi mostra una clausola `USING EXTERNAL FUNCTION` che specifica un ML con funzione Athena.
```
USING EXTERNAL FUNCTION ml_function_name (variable1 data_type[, variable2 data_type][,...])
RETURNS data_type
SAGEMAKER 'sagemaker_endpoint'
SELECT ml_function_name()
```
## Parameters
**UTILIZZO DI UNA FUNZIONE ESTERNA *ml\$1function\$1name* (*variable1**data\$1type*[, *variable2**data\$1type*] [,...])**
*ml\$1function\$1name*definisce il nome della funzione, che può essere utilizzato nelle clausole di interrogazione successive. Ciascuno *variable data\$1type* specifica una variabile denominata e il tipo di dati corrispondente che il modello SageMaker AI accetta come input. Il tipo di dati specificato deve essere un tipo di dati Athena supportato.
**RESTITUISCE *data\$1type***
*data\$1type*specifica il tipo di dati SQL che *ml\$1function\$1name* restituisce la query come output dal modello SageMaker AI.
**SAGEMAKER '' *sagemaker\$1endpoint***
*sagemaker\$1endpoint*specifica l'endpoint del modello di intelligenza artificiale. SageMaker
**SELEZIONA [...] *ml\$1function\$1name*(*expression*) [...]**
La query SELECT che passa i valori alle variabili di funzione e il modello SageMaker AI per restituire un risultato. *ml\$1function\$1name*specifica la funzione definita in precedenza nella query, seguita da una *expression* che viene valutata per passare valori. I valori passati e restituiti devono corrispondere ai tipi di dati corrispondenti specificati per la funzione nella clausola `USING EXTERNAL FUNCTION`.
## Esempio
Nell'esempio seguente viene illustrata una query mediante ML con Athena.
**Example**
```
USING EXTERNAL FUNCTION predict_customer_registration(age INTEGER)
RETURNS DOUBLE
SAGEMAKER 'xgboost-2019-09-20-04-49-29-303'
SELECT predict_customer_registration(age) AS probability_of_enrolling, customer_id
FROM "sampledb"."ml_test_dataset"
WHERE predict_customer_registration(age) < 0.5;
```
# Vedere esempi di utilizzo per i clienti
I seguenti video, che utilizzano la versione di anteprima di Machine Learning (ML) con Amazon Athena, mostrano i modi in cui puoi usare l'intelligenza artificiale SageMaker con Athena.
## Previsione dell'abbandono del cliente
Il video seguente mostra come combinare Athena con le funzionalità di machine learning di Amazon SageMaker AI per prevedere il tasso di abbandono dei clienti.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/CUHbSpekRVg)
## Rilevamento delle botnet
Il video seguente mostra come un'azienda utilizza Amazon Athena e Amazon SageMaker AI per rilevare le botnet.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/0dUv-jCt2aw)
# Eseguire query con funzioni definite dall’utente
Funzioni definite dall'utente (FDU) in Amazon Athena consentono di creare funzioni personalizzate per elaborare registri o gruppi di registri. Una funzione definita dall'utente accetta parametri, esegue il lavoro e quindi restituisce un risultato.
Per utilizzare una funzione definita dall'utente in Athena, scrivi una clausola `USING EXTERNAL FUNCTION` prima di un'istruzione `SELECT` in una query SQL. L'istruzione `SELECT` fa riferimento alla funzione definita dall'utente e definisce le variabili che vengono passate alla funzione definita dall'utente quando viene eseguita la query. La query SQL richiama una funzione Lambda utilizzando il runtime Java quando chiama l'UDF. UDFssono definiti all'interno della funzione Lambda come metodi in un pacchetto di distribuzione Java. UDFsÈ possibile definirne più di uno nello stesso pacchetto di distribuzione Java per una funzione Lambda. Puoi anche specificare il nome della funzione Lambda nella clausola `USING EXTERNAL FUNCTION`.
Sono disponibili due opzioni per distribuire una funzione Lambda per Athena. UDFs Puoi distribuire la funzione direttamente utilizzando Lambda oppure puoi utilizzare AWS Serverless Application Repository. Per trovare le funzioni Lambda esistenti per UDFs, puoi cercare nell'archivio pubblico AWS Serverless Application Repository o privato e poi distribuirle su Lambda. Puoi inoltre creare o modificare il codice sorgente Java, creare un pacchetto in un file JAR e distribuirlo utilizzando Lambda o il AWS Serverless Application Repository. Per esempi di codice origine e pacchetti Java con cui iniziare, consulta [Creare e distribuiredi una UDF utilizzando Lambda](udf-creating-and-deploying.md). Per ulteriori informazioni su Lambda, consulta la [Guida per gli sviluppatori di AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/). [Per ulteriori informazioni in merito AWS Serverless Application Repository, consulta la Guida per gli sviluppatori.AWS Serverless Application Repository](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/)
Per un esempio che utilizza UDFs Athena per tradurre e analizzare il testo, consulta l'articolo del AWS Machine Learning Blog [Tradurre e analizzare il testo utilizzando le funzioni SQL con Amazon Athena, Amazon Translate e Amazon Comprehend oppure](https://aws.amazon.com/blogs/machine-learning/translate-and-analyze-text-using-sql-functions-with-amazon-athena-amazon-translate-and-amazon-comprehend/) guarda il. [video](udf-videos.md#udf-videos-xlate)
*Per un esempio di utilizzo UDFs per estendere le query geospaziali in Amazon Athena, consulta Estendere le [query geospaziali in Amazon Athena con e nel Big Data Blog](https://aws.amazon.com/blogs/big-data/extend-geospatial-queries-in-amazon-athena-with-udfs-and-aws-lambda/). UDFs AWS LambdaAWS *
**Topics**
+ [Video su UDFs In Athena](udf-videos.md)
+ [Considerazioni e limitazioni](udf-considerations-limitations.md)
+ [Eseguire query utilizzando la sintassi query UDF](udf-query-syntax.md)
+ [Creare e distribuiredi una UDF utilizzando Lambda](udf-creating-and-deploying.md)
# Video su UDFs In Athena
Guarda i video seguenti per saperne di più sull'utilizzo UDFs in Athena.
**Video: Presentazione delle funzioni definite dall'utente (UDFs) in Amazon Athena**
Il video seguente mostra come utilizzare UDFs Amazon Athena per oscurare informazioni sensibili.
**Nota**
La sintassi in questo video è precedente al rilascio, ma i concetti sono gli stessi. Utilizza Athena senza il gruppo di lavoro `AmazonAthenaPreviewFunctionality`.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/AxJ6jP4Pfmo)
**Video: Tradurre, analizzare e redigere campi di testo utilizzando query SQL in Amazon Athena**
Il video seguente mostra come utilizzare UDFs Amazon Athena insieme ad altri Servizi AWS per tradurre e analizzare il testo.
**Nota**
La sintassi in questo video è precedente al rilascio, ma i concetti sono gli stessi. Per la sintassi corretta, vedere il post del blog correlato [Tradurre, redigere e analizzare il testo utilizzando le funzioni SQL con Amazon Athena, Amazon Translate e Amazon Comprehend](https://aws.amazon.com/blogs/machine-learning/translate-and-analyze-text-using-sql-functions-with-amazon-athena-amazon-translate-and-amazon-comprehend/) sul*blog AWS Machine Learning*.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/Od7rXG-WMO4)
# Considerazioni e limitazioni
Considerate i seguenti punti quando utilizzate la funzione definita dall'utente (UDFs) in Athena.
+ **Funzioni Athena integrate**: le funzioni integrate in Athena sono progettate per essere altamente performanti. Ti consigliamo di utilizzare le funzioni integrate UDFs quando possibile. Per ulteriori informazioni sulle funzioni incorporate, consulta [Funzioni in Amazon Athena](functions.md).
+ ** UDFs Solo scalare**: Athena supporta solo lo UDFs scalare, che elabora una riga alla volta e restituisce un valore a colonna singola. Athena passa un batch di righe, potenzialmente in parallelo, all'UDF ogni volta che invoca Lambda. Durante la progettazione UDFs e le interrogazioni, presta attenzione al potenziale impatto di questa elaborazione sul traffico di rete.
+ **Le funzioni del gestore UDF utilizzano un formato abbreviato**: usa il formato abbreviato (non il formato completo) per le funzioni UDF (ad esempio, `package.Class` anziché `package.Class::method`).
+ **I metodi UDF devono essere scritti in lettere minuscole**: i metodi UDF devono essere scritti in lettere minuscole; la notazione a cammello non è consentita.
+ **I metodi UDF richiedono parametri**: i metodi UDF devono avere almeno un parametro di input. Il tentativo di richiamare una UDF definita senza parametri di input causa un'eccezione di runtime. UDFs sono pensati per eseguire funzioni sui record di dati, ma una UDF senza argomenti non accetta dati, quindi si verifica un'eccezione.
+ **Supporto Java runtime**: attualmente, Athena UDFs supporta i runtime Java 8, Java 11 e Java 17 per Lambda. Per ulteriori informazioni, consulta [Creazione di funzioni Lambda con Java](https://docs.aws.amazon.com/lambda/latest/dg/lambda-java.html) nella *Guida per gli sviluppatori di AWS Lambda *.
**Nota**
Per Java 17, bisogna impostare il valore della variabile di ambiente `JAVA_TOOL_OPTIONS` come `--add-opens=java.base/java.nio=ALL-UNNAMED` in Lambda.
+ **Autorizzazioni IAM** — Per eseguire e creare istruzioni di query UDF in Athena, l'entità principale IAM che esegue la query deve essere autorizzata a eseguire operazioni in aggiunta alle funzioni Athena. Per ulteriori informazioni, consulta [Consenti l'accesso ad Athena UDFs: politiche di esempio](udf-iam-access.md).
+ Quote **Lambda: le quote** Lambda si applicano a. UDFs Per ulteriori informazioni, consulta la sezione [Quote Lambda](https://docs.aws.amazon.com/lambda/latest/dg/limits.html) nella *Guida per gli sviluppatori di AWS Lambda *.
+ **Filtraggio a livello di riga: il filtro** a livello di riga di Lake Formation non è supportato per. UDFs
+ Visualizzazioni: non è **possibile utilizzare le viste** con. UDFs
+ **Problemi noti**: per la maggior parte up-to-date dei problemi noti, consulta [Limitazioni e problemi](https://github.com/awslabs/aws-athena-query-federation/wiki/Limitations_And_Issues) nella sezione awslabs/ aws-athena-query-federation di. GitHub
# Eseguire query utilizzando la sintassi query UDF
La `USING EXTERNAL FUNCTION` clausola specifica una o più UDF a UDFs cui è possibile fare riferimento da un'istruzione successiva nella query. `SELECT` È necessario il nome del metodo per la funzione definita dall'utente e il nome della funzione Lambda che ospita la funzione definita dall'utente. Al posto del nome della funzione Lambda, puoi utilizzare l'ARN Lambda. Negli scenari con più account, è necessario l'utilizzo dell'ARN Lambda.
## Riepilogo
```
USING EXTERNAL FUNCTION UDF_name(variable1 data_type[, variable2 data_type][,...])
RETURNS data_type
LAMBDA 'lambda_function_name_or_ARN'
[, EXTERNAL FUNCTION UDF_name2(variable1 data_type[, variable2 data_type][,...])
RETURNS data_type
LAMBDA 'lambda_function_name_or_ARN'[,...]]
SELECT [...] UDF_name(expression) [, UDF_name2(expression)] [...]
```
## Parameters
**UTILIZZO DELLA FUNZIONE ESTERNA *UDF\$1name* (*variable1**data\$1type*[, *variable2**data\$1type*] [,...])**
*UDF\$1name*specifica il nome dell'UDF, che deve corrispondere a un metodo Java all'interno della funzione Lambda di riferimento. Ciascuno *variable data\$1type* specifica una variabile denominata e il tipo di dati corrispondente che l'UDF accetta come input. *data\$1type*Deve essere uno dei tipi di dati Athena supportati elencati nella tabella seguente e deve essere mappato al tipo di dati Java corrispondente.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/udf-query-syntax.html)
**RESTITUZIONI *data\$1type***
`data_type` specifica il tipo di dati SQL restituito dall'UDF come output. I tipi di dati Athena elencati nella tabella precedente sono supportati. Per il tipo di `DECIMAL` dati, usa la sintassi `RETURNS DECIMAL(precision, scale)` where *precision* e *scale* sono numeri interi.
**LAMBDA '' *lambda\$1function***
*lambda\$1function*specifica il nome della funzione Lambda da richiamare durante l'esecuzione dell'UDF.
**SELEZIONA [...] *UDF\$1name*(*expression*) [...]**
L'`SELECT`interrogazione che passa i valori all'UDF e restituisce un risultato. *UDF\$1name*specifica l'UDF da utilizzare, seguita da una *expression* che viene valutata per passare valori. I valori passati e restituiti devono corrispondere ai tipi di dati corrispondenti specificati per la funzione definita dall'utente nella clausola `USING EXTERNAL FUNCTION`.
### Esempi
Per esempio, le query basate sul codice [UDFHandlerAthena](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-udfs/src/main/java/com/amazonaws/athena/connectors/udfs/AthenaUDFHandler.java) .java GitHub on, consulta la pagina del connettore Amazon GitHub [Athena UDF](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-udfs).
# Creare e distribuiredi una UDF utilizzando Lambda
Per creare una funzione definita dall'utente personalizzata, crea una nuova classe Java estendendo la classe `UserDefinedFunctionHandler`. Il codice sorgente del [UserDefinedFunctionHandlerfile.java](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-federation-sdk/src/main/java/com/amazonaws/athena/connector/lambda/handlers/UserDefinedFunctionHandler.java) nell'SDK è disponibile nell'[archivio awslabs/aws-athena-query-federation/athena -federation-sdk, insieme GitHub a esempi di implementazioni UDF che puoi esaminare e modificare](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-federation-sdk) [per creare una UDF personalizzata](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-udfs).
La procedura in questa sezione illustra la scrittura e la creazione di un file Jar della funzione definita dall'utente personalizzata utilizzando [Apache Maven](https://maven.apache.org/index.html) dalla riga di comando e una distribuzione.
Procedere con i seguenti passaggi per creare una funzione definita dall’utente personalizzata per Athena utilizzando Maven
1. [Duplicazione dell'SDK e preparazione dell'ambiente di sviluppo](#udf-create-install-sdk-prep-environment)
1. [Creazione del progetto Maven](#create-maven-project)
1. [Aggiunta di dipendenze e plugin al progetto Maven](#udf-add-maven-dependencies)
1. [Scrivere codice Java per UDFs](#udf-write-java)
1. [Compilazione del file JAR](#udf-create-package-jar)
1. [Distribuisci il JAR in AWS Lambda](#udf-create-deploy)
## Duplicazione dell'SDK e preparazione dell'ambiente di sviluppo
Prima di iniziare, assicurati che git sia installato sul tuo sistema utilizzando `sudo yum install git -y`.
**AWS Per installare il Query Federation SDK**
+ Immettere quanto segue nella riga di comando per clonare il repository SDK. Questo repository include l'SDK, esempi e una suite di connettori di origine dati. Per ulteriori informazioni sui connettori di origine dati, consulta [Utilizza Amazon Athena Federated Query](federated-queries.md).
```
git clone https://github.com/awslabs/aws-athena-query-federation.git
```
**Per installare i prerequisiti per questa procedura**
Se state lavorando su una macchina di sviluppo su cui sono già installati Apache Maven AWS CLI, lo strumento di AWS Serverless Application Model compilazione e sviluppo, potete saltare questo passaggio.
1. Dalla radice della directory `aws-athena-query-federation` creata durante la clonazione, esegui lo script [prepare\$1dev\$1env.sh](https://github.com/awslabs/aws-athena-query-federation/blob/master/tools/prepare_dev_env.sh) che prepara l'ambiente di sviluppo.
1. Aggiorna la shell per generare nuove variabili create dal processo di installazione o riavvia la sessione del terminale.
```
source ~/.profile
```
**Importante**
Se salti questo passaggio, in seguito riceverai degli errori relativi all'impossibilità dello strumento AWS CLI o AWS SAM build di pubblicare la tua funzione Lambda.
## Creazione del progetto Maven
Esegui il comando seguente per creare il progetto Maven. Sostituiscila *groupId* con l'ID univoco della tua organizzazione e *my-athena-udf* sostituiscila con il nome dell'applicazione. Per ulteriori informazioni, vedi [Come faccio a creare il mio primo progetto Maven](https://maven.apache.org/guides/getting-started/index.html#How_do_I_make_my_first_Maven_project)? nella documentazione di Apache Maven.
```
mvn -B archetype:generate \
-DarchetypeGroupId=org.apache.maven.archetypes \
-DgroupId=groupId \
-DartifactId=my-athena-udfs
```
## Aggiunta di dipendenze e plugin al progetto Maven
Aggiungi le seguenti configurazioni al file `pom.xml` del progetto Maven. Per un esempio, consultate il [file pom.xml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-udfs/pom.xml) in. GitHub
```
2022.47.1
com.amazonaws
aws-athena-federation-sdk
${aws-athena-federation-sdk.version}
org.apache.maven.plugins
maven-shade-plugin
3.2.1
false
*:*
META-INF/*.SF
META-INF/*.DSA
META-INF/*.RSA
package
shade
```
## Scrivere codice Java per UDFs
Crea una nuova classe estendendo [UserDefinedFunctionHandler.java.](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-federation-sdk/src/main/java/com/amazonaws/athena/connector/lambda/handlers/UserDefinedFunctionHandler.java) Scrivi i tuoi dati UDFs all'interno della classe.
Nell'esempio seguente, all'interno della classe vengono creati due metodi Java per UDFs `compress()` e `decompress()``MyUserDefinedFunctions`.
```
*package *com.mycompany.athena.udfs;
public class MyUserDefinedFunctions
extends UserDefinedFunctionHandler
{
private static final String SOURCE_TYPE = "MyCompany";
public MyUserDefinedFunctions()
{
super(SOURCE_TYPE);
}
/**
* Compresses a valid UTF-8 String using the zlib compression library.
* Encodes bytes with Base64 encoding scheme.
*
* @param input the String to be compressed
* @return the compressed String
*/
public String compress(String input)
{
byte[] inputBytes = input.getBytes(StandardCharsets.UTF_8);
// create compressor
Deflater compressor = new Deflater();
compressor.setInput(inputBytes);
compressor.finish();
// compress bytes to output stream
byte[] buffer = new byte[4096];
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(inputBytes.length);
while (!compressor.finished()) {
int bytes = compressor.deflate(buffer);
byteArrayOutputStream.write(buffer, 0, bytes);
}
try {
byteArrayOutputStream.close();
}
catch (IOException e) {
throw new RuntimeException("Failed to close ByteArrayOutputStream", e);
}
// return encoded string
byte[] compressedBytes = byteArrayOutputStream.toByteArray();
return Base64.getEncoder().encodeToString(compressedBytes);
}
/**
* Decompresses a valid String that has been compressed using the zlib compression library.
* Decodes bytes with Base64 decoding scheme.
*
* @param input the String to be decompressed
* @return the decompressed String
*/
public String decompress(String input)
{
byte[] inputBytes = Base64.getDecoder().decode((input));
// create decompressor
Inflater decompressor = new Inflater();
decompressor.setInput(inputBytes, 0, inputBytes.length);
// decompress bytes to output stream
byte[] buffer = new byte[4096];
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(inputBytes.length);
try {
while (!decompressor.finished()) {
int bytes = decompressor.inflate(buffer);
if (bytes == 0 && decompressor.needsInput()) {
throw new DataFormatException("Input is truncated");
}
byteArrayOutputStream.write(buffer, 0, bytes);
}
}
catch (DataFormatException e) {
throw new RuntimeException("Failed to decompress string", e);
}
try {
byteArrayOutputStream.close();
}
catch (IOException e) {
throw new RuntimeException("Failed to close ByteArrayOutputStream", e);
}
// return decoded string
byte[] decompressedBytes = byteArrayOutputStream.toByteArray();
return new String(decompressedBytes, StandardCharsets.UTF_8);
}
}
```
## Compilazione del file JAR
Esegui `mvn clean install` per compilare il progetto. Una volta completato con successo, viene creato un file JAR nella `target` cartella denominata del progetto`artifactId-version.jar`, dove si *artifactId* trova il nome fornito nel progetto Maven, ad esempio. `my-athena-udfs`
## Distribuisci il JAR in AWS Lambda
Hai a disposizione due opzioni per distribuire il codice in Lambda:
+ Distribuisci utilizzando AWS Serverless Application Repository (consigliato)
+ Creazione di una funzione Lambda dal file JAR
### Opzione 1: eseguire la distribuzione su AWS Serverless Application Repository
Quando si distribuisce il file JAR su AWS Serverless Application Repository, si crea un file YAML AWS SAM modello che rappresenta l'architettura dell'applicazione. Quindi devi specificare questo file YAML e un bucket Amazon S3 in cui gli artefatti dell'applicazione vengono caricati e resi disponibili ad AWS Serverless Application Repository. Nella procedura riportata di seguito viene utilizzato lo script [publish.sh](https://github.com/awslabs/aws-athena-query-federation/blob/master/tools/publish.sh) che si trova nella directory `athena-query-federation/tools` dell'SDK di Athena Query Federation clonato in precedenza.
Per ulteriori informazioni e requisiti, consulta [Pubblicazione di applicazioni](https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverlessrepo-publishing-applications.html) nella *AWS Serverless Application Repository Developer Guide*, [concetti di AWS SAM template](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-basics.html) nella *AWS Serverless Application Model Developer Guide* e [Pubblicazione di applicazioni serverless utilizzando la AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-publishing-applications.html).
Nell'esempio seguente vengono illustrati i parametri in un file YAML. Aggiungi parametri simili al file YAML e salvalo nella directory del progetto. Vedi [athena-udf.yaml](https://github.com/awslabs/aws-athena-query-federation/blob/master/athena-udfs/athena-udfs.yaml) in per un esempio completo. GitHub
```
Transform: 'AWS::Serverless-2016-10-31'
Metadata:
'AWS::ServerlessRepo::Application':
Name: MyApplicationName
Description: 'The description I write for my application'
Author: 'Author Name'
Labels:
- athena-federation
SemanticVersion: 1.0.0
Parameters:
LambdaFunctionName:
Description: 'The name of the Lambda function that will contain your UDFs.'
Type: String
LambdaTimeout:
Description: 'Maximum Lambda invocation runtime in seconds. (min 1 - 900 max)'
Default: 900
Type: Number
LambdaMemory:
Description: 'Lambda memory in MB (min 128 - 3008 max).'
Default: 3008
Type: Number
Resources:
ConnectorConfig:
Type: 'AWS::Serverless::Function'
Properties:
FunctionName: !Ref LambdaFunctionName
Handler: "full.path.to.your.handler. For example, com.amazonaws.athena.connectors.udfs.MyUDFHandler"
CodeUri: "Relative path to your JAR file. For example, ./target/athena-udfs-1.0.jar"
Description: "My description of the UDFs that this Lambda function enables."
Runtime: java8
Timeout: !Ref LambdaTimeout
MemorySize: !Ref LambdaMemory
```
Copia lo script `publish.sh` nella directory del progetto in cui è stato salvato il file YAML ed esegui il comando seguente:
```
./publish.sh MyS3Location MyYamlFile
```
Ad esempio, se la posizione del bucket è `s3://amzn-s3-demo-bucket/mysarapps/athenaudf` e il file YAML è stato salvato come `my-athena-udfs.yaml`:
```
./publish.sh amzn-s3-demo-bucket/mysarapps/athenaudf my-athena-udfs
```
**Come creare una funzione Lambda**
1. Apri la console Lambda all'indirizzo [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/), scegli **Crea funzione**, quindi scegli **Browse serverless app repository**
1. Scegliere **Private applications (Applicazioni private)**, trovare l'applicazione nell'elenco o cercarla usando le parole chiave e selezionarla.
1. Rivedere e fornire i dettagli dell'applicazione, quindi scegliere **Deploy (Distribuisci)**.
Ora puoi usare i nomi dei metodi definiti nel file JAR della funzione Lambda come in UDFs Athena.
### Opzione 2: Creare direttamente una funzione Lambda
Puoi anche creare una funzione Lambda direttamente utilizzando la console o. AWS CLI L'esempio seguente illustra l'utilizzo del comando CLI della `create-function` Lambda.
```
aws lambda create-function \
--function-name MyLambdaFunctionName \
--runtime java8 \
--role arn:aws:iam::1234567890123:role/my_lambda_role \
--handler com.mycompany.athena.udfs.MyUserDefinedFunctions \
--timeout 900 \
--zip-file fileb://./target/my-athena-udfs-1.0-SNAPSHOT.jar
```
# Eseguire query tra regioni
Athena supporta la possibilità di interrogare i dati di Amazon S3 in Regione AWS una regione diversa dalla regione in cui utilizzi Athena. L'esecuzione di query tra regioni è utile quando lo spostamento dei dati non è pratico o consentito oppure quando si desidera eseguire query sui dati in più aree geografiche. Anche se Athena non è disponibile in una determinata regione, i dati di quest'ultima possono essere richiamati da un'altra regione in cui è disponibile Athena.
Per eseguire query sui dati in una regione, il tuo account deve essere abilitato nella regione in questione anche se i dati Amazon S3 non appartengono al tuo account. Per alcune regioni come Stati Uniti orientali (Ohio), l'accesso alla regione viene automaticamente abilitato al momento della creazione dell'account. Altre regioni richiedono che il tuo account sia «attivato» nella regione prima di poterlo utilizzare. Per un elenco delle regioni che richiedono l’attivazione, consulta [Regioni disponibili](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html#concepts-available-regions) nella *Guida per l’utente di Amazon EC2*. [Per istruzioni specifiche sull'adesione a una regione, consulta Gestire le regioni in. AWS*Riferimenti generali di Amazon Web Services*](https://docs.aws.amazon.com/general/latest/gr/rande-manage.html)
## Considerazioni e limitazioni
+ **Autorizzazioni di accesso ai dati**: per eseguire correttamente query sui dati di Amazon S3 da Athena tra regioni, il tuo account deve disporre delle autorizzazioni per leggere i dati. Se i dati su cui desidere esguire query appartengono a un altro account, questo deve concederti l'accesso alla posizione Amazon S3 che contiene i dati.
+ **Costi per il trasferimento dati**: per le query tra regioni sono previsti costi di trasferimento dati Amazon S3. L'esecuzione di una query può comportare il trasferimento di più dati rispetto alla dimensione del set di dati. È consigliabile iniziare a testare le query su un sottoinsieme di dati e valutare i costi in [AWS Cost Explorer](https://aws.amazon.com/aws-cost-management/aws-cost-explorer/).
+ **AWS Glue**— È possibile utilizzare AWS Glue in più regioni. Potrebbero essere applicati costi aggiuntivi per il AWS Glue traffico interregionale. Per ulteriori informazioni, consulta [Creare AWS Glue connessioni tra account e regioni](https://aws.amazon.com/blogs/big-data/create-cross-account-and-cross-region-aws-glue-connections/) nel *AWS Big Data Blog*.
+ **Opzioni di crittografia Amazon S3**: le opzioni di crittografia SSE-S3 e SSE-KMS sono supportate per le query tra regioni; mentre CSE-KMS non lo è. Per ulteriori informazioni, consulta [Opzioni di crittografia supportate da Amazon S3](encryption.md#encryption-options-S3-and-Athena).
+ Interrogazioni **federate: l'utilizzo di query** federate non è supportato. Regioni AWS
A condizione che siano soddisfatte le condizioni di cui sopra, puoi creare una tabella Athena che punti al valore `LOCATION` specificato e interrogare i dati in modo trasparente. Non è necessaria alcuna sintassi speciale. Per ulteriori informazioni sulla creazione delle tabelle Athena, consulta [Crea tabelle in Athena](creating-tables.md).
# Interroga il AWS Glue Data Catalog
Poiché AWS Glue Data Catalog viene utilizzato da molti Servizi AWS come archivio centrale di metadati, potresti voler interrogare i metadati del Data Catalog. A tale scopo, è possibile utilizzare le query SQL in Athena. Puoi usare Athena per interrogare i metadati AWS Glue del catalogo come database, tabelle, partizioni e colonne.
Per ottenere i metadati AWS Glue del catalogo, interrogate il `information_schema` database sul backend Athena. Le query di esempio in questo argomento mostrano come utilizzare Athena per eseguire query sui metadati del catalogo AWS Glue per i casi di utilizzo comuni.
## Considerazioni e limitazioni
+ Invece di interrogare il database `information_schema`, puoi utilizzare i singoli [comandi DDL](ddl-reference.md)di Apache Hive per estrarre informazioni sui metadati per database, tabelle, viste, partizioni e colonne specifici da Athena. Tuttavia, l'output è in formato non tabulare.
+ `information_schema`L'interrogazione è più performante se si dispone di una quantità di metadati da piccola a moderata. AWS Glue Se disponi di una quantità di metadati elevata, possono verificarsi degli errori.
+ Non è possibile utilizzare `CREATE VIEW` per creare una visualizzazione nel database `information_schema`.
**Topics**
+ [Considerazioni e limitazioni](#querying-glue-catalog-considerations-limitations)
+ [Elencare database e ricercare un database specificato](querying-glue-catalog-querying-available-databases-including-rdbms.md)
+ [Elencare le tabelle in un database specificato e ricercare una tabella per nome](querying-glue-catalog-listing-tables.md)
+ [Elencare partizioni per una tabella specifica](querying-glue-catalog-listing-partitions.md)
+ [Elencare o ricercare colonne per una tabella o una vista specificata](querying-glue-catalog-listing-columns.md)
+ [Elenca le colonne che hanno in comune tabelle specifiche](querying-glue-catalog-listing-columns-in-common.md)
+ [Elencare tutte le colonne di ogni tabella](querying-glue-catalog-listing-all-columns-for-all-tables.md)
# Elencare database e ricercare un database specificato
Negli esempi in questa sezione viene illustrato come elencare i database nei metadati in base al nome dello schema.
**Example Elencare i database**
La query di esempio seguente elenca i database della tabella `information_schema.schemata`.
```
SELECT schema_name
FROM information_schema.schemata
LIMIT 10;
```
Nella tabella seguente sono riportati i risultati di esempio.
****
| | |
| --- |--- |
| 6 | alb-databas1 |
| 7 | alb\$1original\$1cust |
| 8 | alblogsdatabase |
| 9 | athena\$1db\$1test |
| 10 | athena\$1ddl\$1db |
**Example Ricerca di un database specificato**
Nella query di esempio seguente, `rdspostgresql` è un database di esempio.
```
SELECT schema_name
FROM information_schema.schemata
WHERE schema_name = 'rdspostgresql'
```
Nella tabella seguente sono riportati i risultati di esempio.
****
| | schema\$1name |
| --- | --- |
| 1 | rdspostgresql |
# Elencare le tabelle in un database specificato e ricercare una tabella per nome
Per elencare i metadati per le tabelle, è possibile eseguire query in base allo schema di tabella o al nome della tabella.
**Example Elencare le tabelle per schema**
Nella query seguente sono elencate le tabelle che utilizzano lo schema di tabella `rdspostgresql`.
```
SELECT table_schema,
table_name,
table_type
FROM information_schema.tables
WHERE table_schema = 'rdspostgresql'
```
La tabella seguente mostra un risultato di esempio.
****
| | table\$1schema | table\$1name | table\$1type |
| --- | --- | --- | --- |
| 1 | rdspostgresql | rdspostgresqldb1\$1public\$1account | BASE TABLE |
**Example Ricercare una tabella per nome**
La query seguente ottiene informazioni sui metadati per la tabella `athena1`.
```
SELECT table_schema,
table_name,
table_type
FROM information_schema.tables
WHERE table_name = 'athena1'
```
La tabella seguente mostra un risultato di esempio.
****
| | table\$1schema | table\$1name | table\$1type |
| --- | --- | --- | --- |
| 1 | predefinito | athena1 | BASE TABLE |
# Elencare partizioni per una tabella specifica
Puoi utilizzare`SHOW PARTITIONS table_name` per elencare le partizioni di una tabella specificata, come nell'esempio seguente.
```
SHOW PARTITIONS cloudtrail_logs_test2
```
È possibile utilizzare una query di metadati `$partitions` per elencare i numeri e i valori di partizione per una tabella specifica.
**Example - Esecuzione di query sulle partizioni di una tabella utilizzando la sintassi \$1partitions**
La query di esempio seguente elenca le partizioni della tabella `cloudtrail_logs_test2` utilizzando la sintassi `$partitions`.
```
SELECT * FROM default."cloudtrail_logs_test2$partitions" ORDER BY partition_number
```
Nella tabella seguente sono riportati i risultati di esempio.
****
| | table\$1catalog | table\$1schema | table\$1name | Anno | Mese | Day (Giorno) |
| --- | --- | --- | --- | --- | --- | --- |
| 1 | awsdatacatalog | predefinito | cloudtrail\$1logs\$1test2 | 2020 | 08 | 10 |
| 2 | awsdatacatalog | predefinito | cloudtrail\$1logs\$1test2 | 2020 | 08 | 11 |
| 3 | awsdatacatalog | predefinito | cloudtrail\$1logs\$1test2 | 2020 | 08 | 12 |
# Elencare o ricercare colonne per una tabella o una vista specificata
È possibile elencare tutte le colonne per una tabella, tutte le colonne per una vista o ricercare una colonna per nome in un database e una tabella specificati.
Per elencare le colonne, utilizzare una query `SELECT *`. Nella clausola `FROM`, specificare `information_schema.columns`. Nella clausola `WHERE`, utilizzare `table_schema='database_name'` per specificare il database e `table_name = 'table_name'` per specificare la tabella o la visualizzazione con le colonne che si desidera elencare.
**Example Elencare tutte le colonne di una tabella specificata**
La query di esempio seguente elenca tutte le colonne della tabella `rdspostgresqldb1_public_account`.
```
SELECT *
FROM information_schema.columns
WHERE table_schema = 'rdspostgresql'
AND table_name = 'rdspostgresqldb1_public_account'
```
Nella tabella seguente sono riportati i risultati di esempio.
****
| | table\$1catalog | table\$1schema | table\$1name | column\$1name | ordinal\$1position | column\$1default | is\$1nullable | data\$1type | comment | extra\$1info |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 1 | awsdatacatalog | rdspostgresql | rdspostgresqldb1\$1public\$1account | password | 1 | | YES | varchar | | |
| 2 | awsdatacatalog | rdspostgresql | rdspostgresqldb1\$1public\$1account | user\$1id | 2 | | YES | intero | | |
| 3 | awsdatacatalog | rdspostgresql | rdspostgresqldb1\$1public\$1account | created\$1on | 3 | | YES | timestamp | | |
| 4 | awsdatacatalog | rdspostgresql | rdspostgresqldb1\$1public\$1account | last\$1login | 4 | | YES | timestamp | | |
| 5 | awsdatacatalog | rdspostgresql | rdspostgresqldb1\$1public\$1account | e-mail | 5 | | YES | varchar | | |
| 6 | awsdatacatalog | rdspostgresql | rdspostgresqldb1\$1public\$1account | username | 6 | | YES | varchar | | |
**Example Elencare le colonne di una visualizzazione specificata**
La query di esempio seguente elenca tutte le colonne nel database `default` per la vista `arrayview`.
```
SELECT *
FROM information_schema.columns
WHERE table_schema = 'default'
AND table_name = 'arrayview'
```
Nella tabella seguente sono riportati i risultati di esempio.
****
| | table\$1catalog | table\$1schema | table\$1name | column\$1name | ordinal\$1position | column\$1default | is\$1nullable | data\$1type | comment | extra\$1info |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 1 | awsdatacatalog | predefinito | arrayview | searchdate | 1 | | YES | varchar | | |
| 2 | awsdatacatalog | predefinito | arrayview | sid | 2 | | YES | varchar | | |
| 3 | awsdatacatalog | predefinito | arrayview | btid | 3 | | YES | varchar | | |
| 4 | awsdatacatalog | predefinito | arrayview | p | 4 | | YES | varchar | | |
| 5 | awsdatacatalog | predefinito | arrayview | infantprice | 5 | | YES | varchar | | |
| 6 | awsdatacatalog | predefinito | arrayview | sump | 6 | | YES | varchar | | |
| 7 | awsdatacatalog | predefinito | arrayview | journeymaparray | 7 | | YES | array(varchar) | | |
**Example Ricercare una colonna per nome in un database e una tabella specificati**
La query di esempio seguente cerca i metadati per la colonna `sid` nella vista `arrayview` del database `default`.
```
SELECT *
FROM information_schema.columns
WHERE table_schema = 'default'
AND table_name = 'arrayview'
AND column_name='sid'
```
La tabella seguente mostra un risultato di esempio.
****
| | table\$1catalog | table\$1schema | table\$1name | column\$1name | ordinal\$1position | column\$1default | is\$1nullable | data\$1type | comment | extra\$1info |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 1 | awsdatacatalog | predefinito | arrayview | sid | 2 | | YES | varchar | | |
# Elenca le colonne che hanno in comune tabelle specifiche
Puoi elencare le colonne che hanno in comune tabelle specifiche di un database.
+ Utilizzo della sintassi `SELECT column_name FROM information_schema.columns`.
+ Per la clausola `WHERE`, utilizza la sintassi `WHERE table_name IN ('table1', 'table2')`.
**Example - Elencare le colonne comuni per due tabelle nello stesso database**
La seguente query di esempio elenca le colonne che le tabelle `table1` e `table2` hanno in comune.
```
SELECT column_name
FROM information_schema.columns
WHERE table_name IN ('table1', 'table2')
GROUP BY column_name
HAVING COUNT(*) > 1;
```
# Elencare tutte le colonne di ogni tabella
Puoi elencare tutte le colonne di ogni tabella in `AwsDataCatalog` o di tutte le tabelle in un database specifico in `AwsDataCatalog`.
+ Per elencare tutte le colonne di ogni database in `AwsDataCatalog`, utilizza la query `SELECT * FROM information_schema.columns`.
+ Per limitare i risultati a un database specifico, utilizza `table_schema='database_name'` nella clausola `WHERE`.
**Example - Elencare tutte le colonne di ogni tabella di un database specifico**
La query di esempio seguente elenca tutte le colonne di ogni tabella nel database `webdata`.
```
SELECT * FROM information_schema.columns WHERE table_schema = 'webdata'
```
# Servizio AWS Registri delle interrogazioni
Questa sezione include diverse procedure per utilizzare Amazon Athena per interrogare i set di dati più diffusi, come AWS CloudTrail log, log CloudFront Amazon, log Classic Load Balancer, log Application Load Balancer, log di flusso Amazon VPC e log Network Load Balancer.
Per le attività riportate in questa sezione viene impiegata la console Athena, tuttavia puoi usare anche altri strumenti come il [driver JDBC Athena](connect-with-jdbc.md), la [AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/athena/) o la [documentazione di riferimento all'API Amazon Athena](https://docs.aws.amazon.com/athena/latest/APIReference/).
Per informazioni sull'utilizzo per AWS CloudFormation creare automaticamente tabelle di Servizio AWS log, partizioni e query di esempio in Athena, consulta [Automatizzare la creazione di tabelle di Servizio AWS log e interrogarle con Amazon Athena](https://aws.amazon.com/blogs/big-data/automating-aws-service-logs-table-creation-and-querying-them-with-amazon-athena/) nel Big Data Blog. AWS Per informazioni sull'utilizzo di una libreria Python per creare un framework comune AWS Glue per l'elaborazione dei Servizio AWS log e la loro interrogazione in Athena, consulta Easly query [logs](https://aws.amazon.com/blogs/big-data/easily-query-aws-service-logs-using-amazon-athena/) using Amazon Athena. Servizio AWS
Gli argomenti di questa sezione presuppongono che tu abbia configurato le autorizzazioni adeguate per accedere ad Athena e al bucket Amazon S3 in cui devono risiedere i dati su cui eseguire la query. Per ulteriori informazioni, consultare [Configurare l’accesso amministrativo e programmatico](setting-up.md) e [Nozioni di base](getting-started.md).
**Topics**
+ [Application Load Balancer](application-load-balancer-logs.md)
+ [Elastic Load Balancing](elasticloadbalancer-classic-logs.md)
+ [CloudFront](cloudfront-logs.md)
+ [CloudTrail](cloudtrail-logs.md)
+ [Amazon EMR](emr-logs.md)
+ [Global Accelerator](querying-global-accelerator-flow-logs.md)
+ [GuardDuty](querying-guardduty.md)
+ [Network Firewall](querying-network-firewall-logs.md)
+ [Network Load Balancer](networkloadbalancer-classic-logs.md)
+ [Route 53](querying-r53-resolver-logs.md)
+ [Amazon SES](querying-ses-logs.md)
+ [Amazon VPC](vpc-flow-logs.md)
+ [AWS WAF](waf-logs.md)
# Eseguire query nei log di Application Load Balancer
Un Application Load Balancer è un'opzione di bilanciamento del carico in Elastic Load Balancing che consente di smistare il traffico in una distribuzione a microservizi con container. Eseguire query sui log dell'Application Load Balancer consente di individuare l'origine del traffico, la latenza e i byte trasferiti a e da istanze Elastic Load Balancing e applicazioni di back-end. Per ulteriori informazioni, consultare [Log di accesso per l’Application Load Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-access-logs.html) e [Log di connessione per Application Load Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-connection-logs.html) nella *Guida per l’utente di Application Load Balancer*.
## Prerequisiti
+ Abilita i [log di accesso](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-access-logs.html) o i [log di connessione ](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-connection-logs.html) in modo che i log di Application Load Balancer possano essere salvati nel bucket Amazon S3.
+ Un database per mantenere la tabella da creare per Athena. Per creare un database, puoi usare Athena o AWS Glue la console. Per ulteriori informazioni, consulta [Creare database in Athena](creating-databases.md) in questa guida o [Lavorare con i database nella console AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/console-databases.html) nella *Guida per gli sviluppatori di AWS Glue *.
**Topics**
+ [Prerequisiti](#application-load-balancer-logs-prerequisites)
+ [Creazione della tabella per l’accesso ALB ai log](create-alb-access-logs-table.md)
+ [Creazione della tabella per i log di accesso ALB in Athena utilizzando la proiezione delle partizioni](create-alb-access-logs-table-partition-projection.md)
+ [Esempio di query per i log di accesso di ALB](query-alb-access-logs-examples.md)
+ [Creare la tabella per i log di connessione ALB](create-alb-connection-logs-table.md)
+ [Creazione della tabella per i log di connessione ALB in Athena utilizzando la proiezione delle partizioni](create-alb-connection-logs-table-partition-projection.md)
+ [Esempio di query per i log di connessione ALB](query-alb-connection-logs-examples.md)
+ [Risorse aggiuntive](application-load-balancer-logs-additional-resources.md)
# Creazione della tabella per l’accesso ALB ai log
1. Copiare e incollare la seguente dichiarazione `CREATE TABLE` nell’editor di query della console Athena, quindi modificarla se necessario in base alle esigenze di immissione dei log. Per informazioni sull'utilizzo della console Athena, consulta [Nozioni di base](getting-started.md). Sostituire il percorso nella clausola `LOCATION` con la propria posizione della cartella del log di accesso di Amazon S3. Per ulteriori informazioni sulla posizione da cui accedere al file del log, consultare [Accedere a file di log](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-access-logs.html#access-log-file-format) nella *Guida per l’utente di Application Load Balancer*.
Per ulteriori informazioni su ciascun campo, consultare [Voci del log di accesso](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-access-logs.html#access-log-entry-format) nella *Guida per l’utente per Application Load Balancer*.
**Nota**
L’istruzione di esempio seguente `CREATE TABLE` include le colonne `classification`, `classification_reason` e `conn_trace_id` (’ID tracciabilità’ o TID). Per creare una tabella per i log di accesso di Application Load Balancer che non contengono queste voci, rimuovere le due colonne corrispondenti dall’istruzione `CREATE TABLE` e modificare l’espressione regolare di conseguenza.
```
CREATE EXTERNAL TABLE IF NOT EXISTS alb_access_logs (
type string,
time string,
elb string,
client_ip string,
client_port int,
target_ip string,
target_port int,
request_processing_time double,
target_processing_time double,
response_processing_time double,
elb_status_code int,
target_status_code string,
received_bytes bigint,
sent_bytes bigint,
request_verb string,
request_url string,
request_proto string,
user_agent string,
ssl_cipher string,
ssl_protocol string,
target_group_arn string,
trace_id string,
domain_name string,
chosen_cert_arn string,
matched_rule_priority string,
request_creation_time string,
actions_executed string,
redirect_url string,
lambda_error_reason string,
target_port_list string,
target_status_code_list string,
classification string,
classification_reason string,
conn_trace_id string
)
ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.RegexSerDe'
WITH SERDEPROPERTIES (
'serialization.format' = '1',
'input.regex' =
'([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*):([0-9]*) ([^ ]*)[:-]([0-9]*) ([-.0-9]*) ([-.0-9]*) ([-.0-9]*) (|[-0-9]*) (-|[-0-9]*) ([-0-9]*) ([-0-9]*) \"([^ ]*) (.*) (- |[^ ]*)\" \"([^\"]*)\" ([A-Z0-9-_]+) ([A-Za-z0-9.-]*) ([^ ]*) \"([^\"]*)\" \"([^\"]*)\" \"([^\"]*)\" ([-.0-9]*) ([^ ]*) \"([^\"]*)\" \"([^\"]*)\" \"([^ ]*)\" \"([^\\s]+?)\" \"([^\\s]+)\" \"([^ ]*)\" \"([^ ]*)\" ?([^ ]*)? ?( .*)?'
)
LOCATION 's3://amzn-s3-demo-bucket/access-log-folder-path/'
```
**Nota**
Suggeriamo che lo schema *`?( .*)?`* alla fine del parametro `input.regex` rimanga sempre invariato per gestire le future voci del log nel caso in cui vengano aggiunti nuovi campi di log ALB.
1. Eseguire la query nella console Athena. Una volta completata la query, Athena registra la tabella `alb_access_logs`, rendendo i dati in essa contenuti pronti per l'esecuzione di query.
# Creazione della tabella per i log di accesso ALB in Athena utilizzando la proiezione delle partizioni
Poiché i log ALB dispongono di una struttura nota il cui schema di partizione può essere specificato in anticipo, è possibile ridurre il runtime delle query e automatizzare la gestione delle partizioni utilizzando la funzionalità di proiezione delle partizioni di Athena. La proiezione delle partizioni aggiunge automaticamente nuove partizioni man mano che vengono aggiunti nuovi dati. Ciò elimina la necessità di aggiungere manualmente le partizioni utilizzando `ALTER TABLE ADD PARTITION`.
L’esempio di istruzione seguente `CREATE TABLE` utilizza automaticamente la proiezione delle partizioni nei log ALB da una data specificata fino alla presente per una singola regione AWS . L'istruzione si basa sull'esempio della sezione precedente, ma aggiunge le clausole `PARTITIONED BY` e `TBLPROPERTIES` per abilitare la proiezione delle partizioni. Nelle clausole `LOCATION` e `storage.location.template`, sostituire i segnaposto con valori che identificano la posizione del bucket Amazon S3 dei propri log di accesso ALB. Per maggiori informazioni sulla posizione del file del log di accesso consultare [File del log di accesso](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-access-logs.html#access-log-file-format) nella *Guida utente per Application Load Balancers*. Per`projection.day.range`, sostituisci *2022**01*//*01*con la data di inizio che desideri utilizzare. Dopo aver eseguito la query con esito positivo, è possibile eseguire query sulla tabella. Non è necessario eseguire `ALTER TABLE ADD PARTITION` per caricare le partizioni. Per informazioni su ogni campo del file di registro, vedere [Elenco log di accesso](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-access-logs.html#access-log-entry-format).
```
CREATE EXTERNAL TABLE IF NOT EXISTS alb_access_logs (
type string,
time string,
elb string,
client_ip string,
client_port int,
target_ip string,
target_port int,
request_processing_time double,
target_processing_time double,
response_processing_time double,
elb_status_code int,
target_status_code string,
received_bytes bigint,
sent_bytes bigint,
request_verb string,
request_url string,
request_proto string,
user_agent string,
ssl_cipher string,
ssl_protocol string,
target_group_arn string,
trace_id string,
domain_name string,
chosen_cert_arn string,
matched_rule_priority string,
request_creation_time string,
actions_executed string,
redirect_url string,
lambda_error_reason string,
target_port_list string,
target_status_code_list string,
classification string,
classification_reason string,
conn_trace_id string
)
PARTITIONED BY
(
day STRING
)
ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.RegexSerDe'
WITH SERDEPROPERTIES (
'serialization.format' = '1',
'input.regex' =
'([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*):([0-9]*) ([^ ]*)[:-]([0-9]*) ([-.0-9]*) ([-.0-9]*) ([-.0-9]*) (|[-0-9]*) (-|[-0-9]*) ([-0-9]*) ([-0-9]*) \"([^ ]*) (.*) (- |[^ ]*)\" \"([^\"]*)\" ([A-Z0-9-_]+) ([A-Za-z0-9.-]*) ([^ ]*) \"([^\"]*)\" \"([^\"]*)\" \"([^\"]*)\" ([-.0-9]*) ([^ ]*) \"([^\"]*)\" \"([^\"]*)\" \"([^ ]*)\" \"([^\\s]+?)\" \"([^\\s]+)\" \"([^ ]*)\" \"([^ ]*)\" ?([^ ]*)? ?( .*)?'
)
LOCATION 's3://amzn-s3-demo-bucket/AWSLogs//elasticloadbalancing//'
TBLPROPERTIES
(
"projection.enabled" = "true",
"projection.day.type" = "date",
"projection.day.range" = "2022/01/01,NOW",
"projection.day.format" = "yyyy/MM/dd",
"projection.day.interval" = "1",
"projection.day.interval.unit" = "DAYS",
"storage.location.template" = "s3://amzn-s3-demo-bucket/AWSLogs//elasticloadbalancing//${day}"
)
```
Per maggiori informazioni sulla proiezione delle partizioni, consulta [Proiezione delle partizioni con Amazon Athena](partition-projection.md).
**Nota**
Suggeriamo che lo schema *?( .\$1)?* alla fine del parametro `input.regex` rimanga sempre invariato per gestire le future voci del log nel caso in cui vengano aggiunti nuovi campi di log ALB.
# Esempio di query per i log di accesso di ALB
La seguente query conteggia il numero di richieste HTTP GET ricevute dal load balancer, raggruppate in base all'indirizzo IP del client:
```
SELECT COUNT(request_verb) AS
count,
request_verb,
client_ip
FROM alb_access_logs
GROUP BY request_verb, client_ip
LIMIT 100;
```
Un'altra query mostra i siti URLs visitati dagli utenti del browser Safari:
```
SELECT request_url
FROM alb_access_logs
WHERE user_agent LIKE '%Safari%'
LIMIT 10;
```
La seguente query mostra i record con valori del codice di stato ELB maggiori o uguali a 500.
```
SELECT * FROM alb_access_logs
WHERE elb_status_code >= 500
```
Il seguente esempio illustra come analizzare i log per `datetime`:
```
SELECT client_ip, sum(received_bytes)
FROM alb_access_logs
WHERE parse_datetime(time,'yyyy-MM-dd''T''HH:mm:ss.SSSSSS''Z')
BETWEEN parse_datetime('2018-05-30-12:00:00','yyyy-MM-dd-HH:mm:ss')
AND parse_datetime('2018-05-31-00:00:00','yyyy-MM-dd-HH:mm:ss')
GROUP BY client_ip;
```
La query seguente esegue una query sulla tabella che utilizza la proiezione delle partizioni per tutti i log di accesso ALB dal giorno specificato.
```
SELECT *
FROM alb_access_logs
WHERE day = '2022/02/12'
```
# Creare la tabella per i log di connessione ALB
1. Copiare e incollare l’istruzione `CREATE TABLE` del seguente esempio nell’editor di query della console Athena, quindi modificala se necessario per i requisiti di immissione del proprio log. Per informazioni sull'utilizzo della console Athena, consulta [Nozioni di base](getting-started.md). Sostituisci il percorso nella clausola `LOCATION` con la posizione della cartella del log di connessione Amazon S3. Per ulteriori informazioni sulla posizione dei file di log delle connessioni, consultare [File di log delle connessioni](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-connection-logs.html#connection-log-file-format) nella *Guida utente per Application Load Balancer*. Per informazioni su ogni campo del file di log, vedere [Immissioni log di connessione](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-connection-logs.html#connection-log-entry-format).
```
CREATE EXTERNAL TABLE IF NOT EXISTS alb_connection_logs (
time string,
client_ip string,
client_port int,
listener_port int,
tls_protocol string,
tls_cipher string,
tls_handshake_latency double,
leaf_client_cert_subject string,
leaf_client_cert_validity string,
leaf_client_cert_serial_number string,
tls_verify_status string,
conn_trace_id string
)
ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.RegexSerDe'
WITH SERDEPROPERTIES (
'serialization.format' = '1',
'input.regex' =
'([^ ]*) ([^ ]*) ([0-9]*) ([0-9]*) ([A-Za-z0-9.-]*) ([^ ]*) ([-.0-9]*) \"([^\"]*)\" ([^ ]*) ([^ ]*) ([^ ]*) ?([^ ]*)?( .*)?'
)
LOCATION 's3://amzn-s3-demo-bucket/connection-log-folder-path/'
```
1. Eseguire la query nella console Athena. Una volta completata la query, Athena registra la tabella `alb_connection_logs`, rendendo i dati in essa contenuti pronti per l'esecuzione di query.
# Creazione della tabella per i log di connessione ALB in Athena utilizzando la proiezione delle partizioni
Poiché i log di connessione ALB dispongono di una struttura nota il cui schema di partizione può essere specificato in anticipo, è possibile ridurre il runtime delle query e automatizzare la gestione delle partizioni utilizzando la funzionalità di proiezione delle partizioni di Athena. La proiezione delle partizioni aggiunge automaticamente nuove partizioni man mano che vengono aggiunti nuovi dati. Ciò elimina la necessità di aggiungere manualmente le partizioni utilizzando `ALTER TABLE ADD PARTITION`.
L’esempio di istruzione seguente `CREATE TABLE` utilizza automaticamente la proiezione delle partizioni nei log di connessione ALB da una data specificata fino alla presente per una singola regione AWS . L'istruzione si basa sull'esempio della sezione precedente, ma aggiunge le clausole `PARTITIONED BY` e `TBLPROPERTIES` per abilitare la proiezione delle partizioni. Nelle clausole `LOCATION` e `storage.location.template`, sostituire i segnaposto con valori che identificano la posizione del bucket Amazon S3 dei propri log di connessione ALB. Per ulteriori informazioni sulla posizione dei file di log delle connessioni, vedere [File di log delle connessioni](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-connection-logs.html#connection-log-file-format) nella *Guida dell’utente per Application Load Balancer*. Per`projection.day.range`, sostituisci *2023**01*//*01*con la data di inizio che desideri utilizzare. Dopo aver eseguito la query con esito positivo, è possibile eseguire query sulla tabella. Non è necessario eseguire `ALTER TABLE ADD PARTITION` per caricare le partizioni. Per informazioni su ogni campo del file di vedere, vedere [Immissioni log di connessione](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-connection-logs.html#connection-log-entry-format).
```
CREATE EXTERNAL TABLE IF NOT EXISTS alb_connection_logs (
time string,
client_ip string,
client_port int,
listener_port int,
tls_protocol string,
tls_cipher string,
tls_handshake_latency double,
leaf_client_cert_subject string,
leaf_client_cert_validity string,
leaf_client_cert_serial_number string,
tls_verify_status string,
conn_trace_id string
)
PARTITIONED BY
(
day STRING
)
ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.RegexSerDe'
WITH SERDEPROPERTIES (
'serialization.format' = '1',
'input.regex' =
'([^ ]*) ([^ ]*) ([0-9]*) ([0-9]*) ([A-Za-z0-9.-]*) ([^ ]*) ([-.0-9]*) \"([^\"]*)\" ([^ ]*) ([^ ]*) ([^ ]*) ?([^ ]*)?( .*)?'
)
LOCATION 's3://amzn-s3-demo-bucket/AWSLogs//elasticloadbalancing//'
TBLPROPERTIES
(
"projection.enabled" = "true",
"projection.day.type" = "date",
"projection.day.range" = "2023/01/01,NOW",
"projection.day.format" = "yyyy/MM/dd",
"projection.day.interval" = "1",
"projection.day.interval.unit" = "DAYS",
"storage.location.template" = "s3://amzn-s3-demo-bucket/AWSLogs//elasticloadbalancing//${day}"
)
```
Per maggiori informazioni sulla proiezione delle partizioni, consulta [Proiezione delle partizioni con Amazon Athena](partition-projection.md).
# Esempio di query per i log di connessione ALB
Le seguenti query contano le occorrenze in cui il valore per `tls_verify_status` non era `'Success'`, raggruppate per indirizzo IP del client:
```
SELECT DISTINCT client_ip, count() AS count FROM alb_connection_logs
WHERE tls_verify_status != 'Success'
GROUP BY client_ip
ORDER BY count() DESC;
```
La seguente query cerca le occorrenze in cui il valore per `tls_handshake_latency` è superiore a 2 secondi nell’intervallo di tempo specificato:
```
SELECT * FROM alb_connection_logs
WHERE
(
parse_datetime(time, 'yyyy-MM-dd''T''HH:mm:ss.SSSSSS''Z')
BETWEEN
parse_datetime('2024-01-01-00:00:00', 'yyyy-MM-dd-HH:mm:ss')
AND
parse_datetime('2024-03-20-00:00:00', 'yyyy-MM-dd-HH:mm:ss')
)
AND
(tls_handshake_latency >= 2.0);
```
# Risorse aggiuntive
Per ulteriori informazioni sull’utilizzo dei log ALB, consultare le seguenti risorse.
+ [Come posso analizzare i log di accesso di Application Load Balancer utilizzando Amazon Athena?](https://repost.aws/knowledge-center/athena-analyze-access-logs) nel *Centro conoscenze di AWS *.
+ Per informazioni sui codici di stato HTTP in Elastic Load Balancing, consulta [Risoluzione dei problemi con Application Load Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-troubleshooting.html) nella *Guida per l'utente di Application Load Balancer*.
+ [Cataloga e analizza i log di Application Load Balancer in modo più efficiente con classificatori AWS Glue personalizzati e Amazon Athena](https://aws.amazon.com/blogs/big-data/catalog-and-analyze-application-load-balancer-logs-more-efficiently-with-aws-glue-custom-classifiers-and-amazon-athena/) *nel Big Data Blog.AWS *
# Eseguire query su log Classic Load Balancer
Usa i log di Classic Load Balancer per analizzare e comprendere i modelli di traffico da e verso le istanze di Elastic Load Balancing e le applicazioni di back-end. È possibile visualizzare sorgente di traffico, latenza e byte trasferiti.
Prima di analizzare i log di Elastic Load Balancing, configurali affinché siano salvati nel bucket Amazon S3 di destinazione. Per ulteriori informazioni, consulta la sezione relativa all'[accesso ai log di Classic Load Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/enable-access-logs.html).
**Per creare la tabella per i log di Elastic Load Balancing**
1. Copiare e incollare la seguente istruzione DDL nella console Athena. Controlla la [sintassi ](https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/access-log-collection.html#access-log-entry-format)dei record di log di Elastic Load Balancing. Potrebbe essere necessario aggiornare la seguente query per includere le colonne e la sintassi Regex per la versione più recente del record.
```
CREATE EXTERNAL TABLE IF NOT EXISTS elb_logs (
timestamp string,
elb_name string,
request_ip string,
request_port int,
backend_ip string,
backend_port int,
request_processing_time double,
backend_processing_time double,
client_response_time double,
elb_response_code string,
backend_response_code string,
received_bytes bigint,
sent_bytes bigint,
request_verb string,
url string,
protocol string,
user_agent string,
ssl_cipher string,
ssl_protocol string
)
ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.RegexSerDe'
WITH SERDEPROPERTIES (
'serialization.format' = '1',
'input.regex' = '([^ ]*) ([^ ]*) ([^ ]*):([0-9]*) ([^ ]*)[:-]([0-9]*) ([-.0-9]*) ([-.0-9]*) ([-.0-9]*) (|[-0-9]*) (-|[-0-9]*) ([-0-9]*) ([-0-9]*) \\\"([^ ]*) ([^ ]*) (- |[^ ]*)\\\" (\"[^\"]*\") ([A-Z0-9-]+) ([A-Za-z0-9.-]*)$'
)
LOCATION 's3://amzn-s3-demo-bucket/AWSLogs/AWS_account_ID/elasticloadbalancing/';
```
1. Modifica il bucket Amazon S3 `LOCATION` per specificare la destinazione dei tuoi log di Elastic Load Balancing.
1. Eseguire la query nella console Athena. Una volta completata la query, Athena registra la tabella `elb_logs`, rendendo i dati in essa contenuti pronti per le query. Per ulteriori informazioni, consulta [Query di esempio](#query-elb-classic-example).
## Query di esempio
Eseguire una query simile all'esempio seguente. In tale query sono elencati i server di applicazioni di back-end che hanno restituito un codice di risposta di errore `4XX` o `5XX`. Utilizza l'operatore `LIMIT` per limitare il numero di log di cui eseguire la query alla volta.
```
SELECT
timestamp,
elb_name,
backend_ip,
backend_response_code
FROM elb_logs
WHERE backend_response_code LIKE '4%' OR
backend_response_code LIKE '5%'
LIMIT 100;
```
Utilizza una successiva query per sommare il tempo di risposta di tutte le transazioni raggruppate in base all'indirizzo IP del back-end e al nome dell'istanza Elastic Load Balancing.
```
SELECT sum(backend_processing_time) AS
total_ms,
elb_name,
backend_ip
FROM elb_logs WHERE backend_ip <> ''
GROUP BY backend_ip, elb_name
LIMIT 100;
```
Per ulteriori informazioni, consulta la sezione relativa all'[analisi dei dati su S3 utilizzando Athena](https://aws.amazon.com/blogs/big-data/analyzing-data-in-s3-using-amazon-athena/).
# Interroga i CloudFront log di Amazon
Puoi configurare Amazon CloudFront CDN per esportare i log di accesso alla distribuzione Web su Amazon Simple Storage Service. Usa questi log per esplorare i modelli di navigazione degli utenti tra le proprietà web servite da. CloudFront
Prima di iniziare a eseguire query sui log, abilita i log di accesso per le distribuzioni Web sulla tua distribuzione CloudFront preferita. Per informazioni, consulta [i log di accesso](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/AccessLogs.html) nella *Amazon CloudFront Developer Guide*. Prendi nota del bucket Amazon S3 in cui salvi questi log.
**Topics**
+ [Crea una tabella per i log CloudFront standard (legacy)](create-cloudfront-table-standard-logs.md)
+ [Crea una tabella per CloudFront i log in Athena utilizzando il partizionamento manuale con JSON](create-cloudfront-table-manual-json.md)
+ [Crea una tabella per CloudFront i registri in Athena utilizzando il partizionamento manuale con Parquet](create-cloudfront-table-manual-parquet.md)
+ [Crea una tabella per CloudFront i log in Athena utilizzando la proiezione delle partizioni con JSON](create-cloudfront-table-partition-json.md)
+ [Crea una tabella per CloudFront i registri in Athena utilizzando la proiezione delle partizioni con Parquet](create-cloudfront-table-partition-parquet.md)
+ [Crea una tabella per i log in tempo reale CloudFront](create-cloudfront-table-real-time-logs.md)
+ [Risorse aggiuntive](cloudfront-logs-additional-resources.md)
# Crea una tabella per i log CloudFront standard (legacy)
**Nota**
La procedura seguente funziona per i log di accesso alla distribuzione Web. CloudFront Non si applica ai log di streaming delle distribuzioni RTMP.
**Per creare una tabella per i campi CloudFront standard dei file di log**
1. Copia e incolla la seguente istruzione DDL di esempio nell'Editor di query della console Athena. L'istruzione di esempio utilizza i campi del file di registro documentati nella sezione [Campi dei file di log standard](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/AccessLogs.html#BasicDistributionFileFormat) della *Amazon CloudFront Developer Guide*. Modifica il parametro `LOCATION` per il bucket Amazon S3 in cui sono archiviati i log. Per ulteriori informazioni sull'utilizzo dell'editor di query, consulta [Nozioni di base](getting-started.md).
Questa query specifica `ROW FORMAT DELIMITED` e `FIELDS TERMINATED BY '\t'` per indicare che i campi sono delimitati da caratteri di tabulazione. Per`ROW FORMAT DELIMITED`, Athena utilizza per impostazione [LazySimpleSerDe](lazy-simple-serde.md)predefinita. Nella colonna `date` viene inserito il carattere escape con l'apice inverso (`) perché è una parola riservata in Athena. Per informazioni, consulta [Impostare il carattere escape di parole chiave riservate nelle query](reserved-words.md).
```
CREATE EXTERNAL TABLE IF NOT EXISTS cloudfront_standard_logs (
`date` DATE,
time STRING,
x_edge_location STRING,
sc_bytes BIGINT,
c_ip STRING,
cs_method STRING,
cs_host STRING,
cs_uri_stem STRING,
sc_status INT,
cs_referrer STRING,
cs_user_agent STRING,
cs_uri_query STRING,
cs_cookie STRING,
x_edge_result_type STRING,
x_edge_request_id STRING,
x_host_header STRING,
cs_protocol STRING,
cs_bytes BIGINT,
time_taken FLOAT,
x_forwarded_for STRING,
ssl_protocol STRING,
ssl_cipher STRING,
x_edge_response_result_type STRING,
cs_protocol_version STRING,
fle_status STRING,
fle_encrypted_fields INT,
c_port INT,
time_to_first_byte FLOAT,
x_edge_detailed_result_type STRING,
sc_content_type STRING,
sc_content_len BIGINT,
sc_range_start BIGINT,
sc_range_end BIGINT
)
ROW FORMAT DELIMITED
FIELDS TERMINATED BY '\t'
LOCATION 's3://amzn-s3-demo-bucket/'
TBLPROPERTIES ( 'skip.header.line.count'='2' )
```
1. Eseguire la query nella console Athena. Una volta completata la query, Athena registra la tabella `cloudfront_standard_logs`, rendendo i dati in essa contenuti pronti per l'esecuzione di query.
## Query di esempio
La seguente query somma il numero di byte serviti CloudFront tra il 9 giugno e l'11 giugno 2018. Racchiudi fra virgolette doppie il nome della colonna della data perché è una parola riservata.
```
SELECT SUM(bytes) AS total_bytes
FROM cloudfront_standard_logs
WHERE "date" BETWEEN DATE '2018-06-09' AND DATE '2018-06-11'
LIMIT 100;
```
Per eliminare righe duplicate (ad esempio, righe vuote duplicate) dai risultati della query, è possibile utilizzare l'istruzione `SELECT DISTINCT`, come nell'esempio seguente.
```
SELECT DISTINCT *
FROM cloudfront_standard_logs
LIMIT 10;
```
# Crea una tabella per CloudFront i log in Athena utilizzando il partizionamento manuale con JSON
**Per creare una tabella per i campi CloudFront standard dei file di log utilizzando un formato JSON**
1. Copia e incolla la seguente istruzione DDL di esempio nell'Editor di query della console Athena. L'istruzione di esempio utilizza i campi del file di registro documentati nella sezione [Campi dei file di log standard](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/AccessLogs.html#BasicDistributionFileFormat) della *Amazon CloudFront Developer Guide*. Modifica il parametro `LOCATION` per il bucket Amazon S3 in cui sono archiviati i log.
Questa query utilizza OpenX JSON SerDe con le seguenti SerDe proprietà per leggere correttamente i campi JSON in Athena.
```
CREATE EXTERNAL TABLE `cf_logs_manual_partition_json`(
`date` string ,
`time` string ,
`x-edge-location` string ,
`sc-bytes` string ,
`c-ip` string ,
`cs-method` string ,
`cs(host)` string ,
`cs-uri-stem` string ,
`sc-status` string ,
`cs(referer)` string ,
`cs(user-agent)` string ,
`cs-uri-query` string ,
`cs(cookie)` string ,
`x-edge-result-type` string ,
`x-edge-request-id` string ,
`x-host-header` string ,
`cs-protocol` string ,
`cs-bytes` string ,
`time-taken` string ,
`x-forwarded-for` string ,
`ssl-protocol` string ,
`ssl-cipher` string ,
`x-edge-response-result-type` string ,
`cs-protocol-version` string ,
`fle-status` string ,
`fle-encrypted-fields` string ,
`c-port` string ,
`time-to-first-byte` string ,
`x-edge-detailed-result-type` string ,
`sc-content-type` string ,
`sc-content-len` string ,
`sc-range-start` string ,
`sc-range-end` string )
ROW FORMAT SERDE
'org.openx.data.jsonserde.JsonSerDe'
WITH SERDEPROPERTIES (
'paths'='c-ip,c-port,cs(Cookie),cs(Host),cs(Referer),cs(User-Agent),cs-bytes,cs-method,cs-protocol,cs-protocol-version,cs-uri-query,cs-uri-stem,date,fle-encrypted-fields,fle-status,sc-bytes,sc-content-len,sc-content-type,sc-range-end,sc-range-start,sc-status,ssl-cipher,ssl-protocol,time,time-taken,time-to-first-byte,x-edge-detailed-result-type,x-edge-location,x-edge-request-id,x-edge-response-result-type,x-edge-result-type,x-forwarded-for,x-host-header')
STORED AS INPUTFORMAT
'org.apache.hadoop.mapred.TextInputFormat'
OUTPUTFORMAT
'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION
's3://amzn-s3-demo-bucket/'
```
1. Eseguire la query nella console Athena. Una volta completata la query, Athena registra la tabella `cf_logs_manual_partition_json`, rendendo i dati in essa contenuti pronti per l'esecuzione di query.
## Query di esempio
La seguente query somma il numero di byte serviti CloudFront per il 15 gennaio 2025.
```
SELECT sum(cast("sc-bytes" as BIGINT)) as sc
FROM cf_logs_manual_partition_json
WHERE "date"='2025-01-15'
```
Per eliminare righe duplicate (ad esempio, righe vuote duplicate) dai risultati della query, è possibile utilizzare l'istruzione `SELECT DISTINCT`, come nell'esempio seguente.
```
SELECT DISTINCT * FROM cf_logs_manual_partition_json
```
# Crea una tabella per CloudFront i registri in Athena utilizzando il partizionamento manuale con Parquet
**Per creare una tabella per i campi CloudFront standard dei file di log utilizzando un formato Parquet**
1. Copia e incolla la seguente istruzione DDL di esempio nell'Editor di query della console Athena. L'istruzione di esempio utilizza i campi del file di registro documentati nella sezione [Campi dei file di log standard](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/AccessLogs.html#BasicDistributionFileFormat) della *Amazon CloudFront Developer Guide*.
Questa query utilizza ParquetHiveSerDe le seguenti SerDe proprietà per leggere correttamente i campi Parquet in Athena.
```
CREATE EXTERNAL TABLE `cf_logs_manual_partition_parquet`(
`date` string,
`time` string,
`x_edge_location` string,
`sc_bytes` string,
`c_ip` string,
`cs_method` string,
`cs_host` string,
`cs_uri_stem` string,
`sc_status` string,
`cs_referer` string,
`cs_user_agent` string,
`cs_uri_query` string,
`cs_cookie` string,
`x_edge_result_type` string,
`x_edge_request_id` string,
`x_host_header` string,
`cs_protocol` string,
`cs_bytes` string,
`time_taken` string,
`x_forwarded_for` string,
`ssl_protocol` string,
`ssl_cipher` string,
`x_edge_response_result_type` string,
`cs_protocol_version` string,
`fle_status` string,
`fle_encrypted_fields` string,
`c_port` string,
`time_to_first_byte` string,
`x_edge_detailed_result_type` string,
`sc_content_type` string,
`sc_content_len` string,
`sc_range_start` string,
`sc_range_end` string)
ROW FORMAT SERDE
'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe'
STORED AS INPUTFORMAT
'org.apache.hadoop.hive.ql.io.parquet.MapredParquetInputFormat'
OUTPUTFORMAT
'org.apache.hadoop.hive.ql.io.parquet.MapredParquetOutputFormat'
LOCATION
's3://amzn-s3-demo-bucket/'
```
1. Eseguire la query nella console Athena. Una volta completata la query, Athena registra la tabella `cf_logs_manual_partition_parquet`, rendendo i dati in essa contenuti pronti per l'esecuzione di query.
## Query di esempio
La seguente query somma il numero di byte serviti CloudFront per il 19 gennaio 2025.
```
SELECT sum(cast("sc_bytes" as BIGINT)) as sc
FROM cf_logs_manual_partition_parquet
WHERE "date"='2025-01-19'
```
Per eliminare righe duplicate (ad esempio, righe vuote duplicate) dai risultati della query, è possibile utilizzare l'istruzione `SELECT DISTINCT`, come nell'esempio seguente.
```
SELECT DISTINCT * FROM cf_logs_manual_partition_parquet
```
# Crea una tabella per CloudFront i log in Athena utilizzando la proiezione delle partizioni con JSON
È possibile ridurre il tempo di runtime delle query e automatizzare la gestione delle partizioni con la funzionalità di proiezione delle partizioni Athena. La proiezione delle partizioni aggiunge automaticamente nuove partizioni man mano che vengono aggiunti nuovi dati. Ciò elimina la necessità di aggiungere manualmente le partizioni utilizzando `ALTER TABLE ADD PARTITION`.
L'esempio seguente, l'istruzione CREATE TABLE utilizza automaticamente la proiezione delle partizioni sui CloudFront log di una distribuzione specificata fino a quando non sono presenti per una singola distribuzione. CloudFront Regione AWS Dopo aver eseguito la query con esito positivo, è possibile eseguire query sulla tabella.
```
CREATE EXTERNAL TABLE `cloudfront_logs_pp`(
`date` string,
`time` string,
`x-edge-location` string,
`sc-bytes` string,
`c-ip` string,
`cs-method` string,
`cs(host)` string,
`cs-uri-stem` string,
`sc-status` string,
`cs(referer)` string,
`cs(user-agent)` string,
`cs-uri-query` string,
`cs(cookie)` string,
`x-edge-result-type` string,
`x-edge-request-id` string,
`x-host-header` string,
`cs-protocol` string,
`cs-bytes` string,
`time-taken` string,
`x-forwarded-for` string,
`ssl-protocol` string,
`ssl-cipher` string,
`x-edge-response-result-type` string,
`cs-protocol-version` string,
`fle-status` string,
`fle-encrypted-fields` string,
`c-port` string,
`time-to-first-byte` string,
`x-edge-detailed-result-type` string,
`sc-content-type` string,
`sc-content-len` string,
`sc-range-start` string,
`sc-range-end` string)
PARTITIONED BY(
distributionid string,
year int,
month int,
day int,
hour int )
ROW FORMAT SERDE
'org.openx.data.jsonserde.JsonSerDe'
WITH SERDEPROPERTIES (
'paths'='c-ip,c-port,cs(Cookie),cs(Host),cs(Referer),cs(User-Agent),cs-bytes,cs-method,cs-protocol,cs-protocol-version,cs-uri-query,cs-uri-stem,date,fle-encrypted-fields,fle-status,sc-bytes,sc-content-len,sc-content-type,sc-range-end,sc-range-start,sc-status,ssl-cipher,ssl-protocol,time,time-taken,time-to-first-byte,x-edge-detailed-result-type,x-edge-location,x-edge-request-id,x-edge-response-result-type,x-edge-result-type,x-forwarded-for,x-host-header')
STORED AS INPUTFORMAT
'org.apache.hadoop.mapred.TextInputFormat'
OUTPUTFORMAT
'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION
's3://amzn-s3-demo-bucket/AWSLogs/AWS_ACCOUNT_ID/CloudFront/'
TBLPROPERTIES (
'projection.distributionid.type'='enum',
'projection.distributionid.values'='E2Oxxxxxxxxxxx',
'projection.day.range'='01,31',
'projection.day.type'='integer',
'projection.day.digits'='2',
'projection.enabled'='true',
'projection.month.range'='01,12',
'projection.month.type'='integer',
'projection.month.digits'='2',
'projection.year.range'='2025,2026',
'projection.year.type'='integer',
'projection.hour.range'='00,23',
'projection.hour.type'='integer',
'projection.hour.digits'='2',
'storage.location.template'='s3://amzn-s3-demo-bucket/AWSLogs/AWS_ACCOUNT_ID/CloudFront/${distributionid}/${year}/${month}/${day}/${hour}/')
```
Di seguito sono riportate alcune considerazioni sulle proprietà utilizzate nell’esempio precedente.
+ **Nome tabella**: il nome della tabella *`cloudfront_logs_pp`* è sostituibile. È possibile cambiarlo con il nome che si desidera.
+ **Posizione**: modificare `s3://amzn-s3-demo-bucket/AWSLogs/AWS_ACCOUNT_ID/` in modo che punti al proprio bucket Amazon S3.
+ **Distribuzione IDs**: per`projection.distributionid.values`, è possibile specificare più distribuzioni IDs se le si separano con virgole. Ad esempio, **, **.
+ **Intervallo di anni**: nel `projection.year.range`, è possibile definire l’intervallo di anni in base ai propri dati. Ad esempio, è possibile adattarlo a qualsiasi periodo, come *2025*, *2026*.
**Nota**
L’inclusione di partizioni vuote, come quelle per date future (esempio: 2025-2040), può influire sulle prestazioni delle query. Tuttavia, la proiezione delle partizioni è progettata proprio per gestire in maniera efficace date future. Per mantenere prestazioni ottimali, assicurarsi che le partizioni siano gestite con attenzione ed evitare troppe partizioni vuote quando possibile.
+ **Modello di posizione di archiviazione**: è necessario assicurarsi di aggiornarlo `storage.location.template` correttamente in base alla seguente struttura di CloudFront partizionamento e al percorso S3.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/create-cloudfront-table-partition-json.html)
Dopo aver verificato che la struttura di CloudFront partizionamento e la struttura S3 corrispondono ai modelli richiesti, aggiornali come segue: `storage.location.template`
```
'storage.location.template'='s3://amzn-s3-demo-bucket/AWSLogs/account_id/CloudFront/${distributionid}/folder2/${year}/${month}/${day}/${hour}/folder3/'
```
**Nota**
La corretta configurazione del `storage.location.template` è fondamentale per garantire la corretta archiviazione e recupero dei dati.
# Crea una tabella per CloudFront i registri in Athena utilizzando la proiezione delle partizioni con Parquet
L'esempio seguente dell'istruzione CREATE TABLE utilizza automaticamente la proiezione delle partizioni sui CloudFront registri in Parquet, da una distribuzione specificata CloudFront fino a quella presente per una singola distribuzione. Regione AWS Dopo aver eseguito la query con esito positivo, è possibile eseguire query sulla tabella.
```
CREATE EXTERNAL TABLE `cloudfront_logs_parquet_pp`(
`date` string,
`time` string,
`x_edge_location` string,
`sc_bytes` string,
`c_ip` string,
`cs_method` string,
`cs_host` string,
`cs_uri_stem` string,
`sc_status` string,
`cs_referer` string,
`cs_user_agent` string,
`cs_uri_query` string,
`cs_cookie` string,
`x_edge_result_type` string,
`x_edge_request_id` string,
`x_host_header` string,
`cs_protocol` string,
`cs_bytes` string,
`time_taken` string,
`x_forwarded_for` string,
`ssl_protocol` string,
`ssl_cipher` string,
`x_edge_response_result_type` string,
`cs_protocol_version` string,
`fle_status` string,
`fle_encrypted_fields` string,
`c_port` string,
`time_to_first_byte` string,
`x_edge_detailed_result_type` string,
`sc_content_type` string,
`sc_content_len` string,
`sc_range_start` string,
`sc_range_end` string)
PARTITIONED BY(
distributionid string,
year int,
month int,
day int,
hour int )
ROW FORMAT SERDE
'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe'
STORED AS INPUTFORMAT
'org.apache.hadoop.hive.ql.io.parquet.MapredParquetInputFormat'
OUTPUTFORMAT
'org.apache.hadoop.hive.ql.io.parquet.MapredParquetOutputFormat'
LOCATION
's3://amzn-s3-demo-bucket/AWSLogs/AWS_ACCOUNT_ID/CloudFront/'
TBLPROPERTIES (
'projection.distributionid.type'='enum',
'projection.distributionid.values'='E3OK0LPUNWWO3',
'projection.day.range'='01,31',
'projection.day.type'='integer',
'projection.day.digits'='2',
'projection.enabled'='true',
'projection.month.range'='01,12',
'projection.month.type'='integer',
'projection.month.digits'='2',
'projection.year.range'='2019,2025',
'projection.year.type'='integer',
'projection.hour.range'='01,12',
'projection.hour.type'='integer',
'projection.hour.digits'='2',
'storage.location.template'='s3://amzn-s3-demo-bucket/AWSLogs/AWS_ACCOUNT_ID/CloudFront/${distributionid}/${year}/${month}/${day}/${hour}/')
```
Di seguito sono riportate alcune considerazioni sulle proprietà utilizzate nell’esempio precedente.
+ **Nome tabella**: il nome della tabella *`cloudfront_logs_pp`* è sostituibile. È possibile cambiarlo con il nome che si desidera.
+ **Posizione**: modificare `s3://amzn-s3-demo-bucket/AWSLogs/AWS_ACCOUNT_ID/` in modo che punti al proprio bucket Amazon S3.
+ **Distribuzione IDs**: per`projection.distributionid.values`, è possibile specificare più distribuzioni IDs se le si separano con virgole. Ad esempio, **, **.
+ **Intervallo di anni**: nel `projection.year.range`, è possibile definire l’intervallo di anni in base ai propri dati. Ad esempio, è possibile adattarlo a qualsiasi periodo, come *2025*, *2026*.
**Nota**
L’inclusione di partizioni vuote, come quelle per date future (esempio: 2025-2040), può influire sulle prestazioni delle query. Tuttavia, la proiezione delle partizioni è progettata proprio per gestire in maniera efficace date future. Per mantenere prestazioni ottimali, assicurarsi che le partizioni siano gestite con attenzione ed evitare troppe partizioni vuote quando possibile.
+ **Modello di posizione di archiviazione**: è necessario assicurarsi di aggiornarlo `storage.location.template` correttamente in base alla seguente struttura di CloudFront partizionamento e al percorso S3.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/create-cloudfront-table-partition-parquet.html)
Dopo aver verificato che la struttura di CloudFront partizionamento e la struttura S3 corrispondono ai modelli richiesti, aggiornali come segue: `storage.location.template`
```
'storage.location.template'='s3://amzn-s3-demo-bucket/AWSLogs/account_id/CloudFront/${distributionid}/folder2/${year}/${month}/${day}/${hour}/folder3/'
```
**Nota**
La corretta configurazione del `storage.location.template` è fondamentale per garantire la corretta archiviazione e recupero dei dati.
# Crea una tabella per i log in tempo reale CloudFront
**Per creare una tabella per i campi dei file di registro CloudFront in tempo reale**
1. Copia e incolla la seguente istruzione DDL di esempio nell'Editor di query della console Athena. L'istruzione di esempio utilizza i campi del file di registro documentati nella sezione [Real-time logs](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/real-time-logs.html) della *Amazon CloudFront Developer Guide*. Modifica il parametro `LOCATION` per il bucket Amazon S3 in cui sono archiviati i log. Per ulteriori informazioni sull'utilizzo dell'editor di query, consulta [Nozioni di base](getting-started.md).
Questa query specifica `ROW FORMAT DELIMITED` e `FIELDS TERMINATED BY '\t'` per indicare che i campi sono delimitati da caratteri di tabulazione. Per`ROW FORMAT DELIMITED`, Athena utilizza per impostazione [LazySimpleSerDe](lazy-simple-serde.md)predefinita. Nella colonna `timestamp` viene inserito il carattere escape con l'apice inverso (`) perché è una parola riservata in Athena. Per informazioni, consulta [Impostare il carattere escape di parole chiave riservate nelle query](reserved-words.md).
L’esempio seguente contiene tutti i campi disponibili. È possibile aggiungere commenti o rimuovere campi non servono.
```
CREATE EXTERNAL TABLE IF NOT EXISTS cloudfront_real_time_logs (
`timestamp` STRING,
c_ip STRING,
time_to_first_byte BIGINT,
sc_status BIGINT,
sc_bytes BIGINT,
cs_method STRING,
cs_protocol STRING,
cs_host STRING,
cs_uri_stem STRING,
cs_bytes BIGINT,
x_edge_location STRING,
x_edge_request_id STRING,
x_host_header STRING,
time_taken BIGINT,
cs_protocol_version STRING,
c_ip_version STRING,
cs_user_agent STRING,
cs_referer STRING,
cs_cookie STRING,
cs_uri_query STRING,
x_edge_response_result_type STRING,
x_forwarded_for STRING,
ssl_protocol STRING,
ssl_cipher STRING,
x_edge_result_type STRING,
fle_encrypted_fields STRING,
fle_status STRING,
sc_content_type STRING,
sc_content_len BIGINT,
sc_range_start STRING,
sc_range_end STRING,
c_port BIGINT,
x_edge_detailed_result_type STRING,
c_country STRING,
cs_accept_encoding STRING,
cs_accept STRING,
cache_behavior_path_pattern STRING,
cs_headers STRING,
cs_header_names STRING,
cs_headers_count BIGINT,
primary_distribution_id STRING,
primary_distribution_dns_name STRING,
origin_fbl STRING,
origin_lbl STRING,
asn STRING
)
ROW FORMAT DELIMITED
FIELDS TERMINATED BY '\t'
LOCATION 's3://amzn-s3-demo-bucket/'
TBLPROPERTIES ( 'skip.header.line.count'='2' )
```
1. Eseguire la query nella console Athena. Una volta completata la query, Athena registra la tabella `cloudfront_real_time_logs`, rendendo i dati in essa contenuti pronti per l'esecuzione di query.
# Risorse aggiuntive
Per ulteriori informazioni sull'utilizzo di Athena per interrogare CloudFront i log, consulta i seguenti post del blog sui [AWS big data](https://aws.amazon.com/blogs/big-data/).
[Interroga facilmente Servizio AWS i log con Amazon](https://aws.amazon.com/blogs/big-data/easily-query-aws-service-logs-using-amazon-athena/) Athena (29 maggio 2019).
[Analizza i log di CloudFront accesso di Amazon su larga scala](https://aws.amazon.com/blogs/big-data/analyze-your-amazon-cloudfront-access-logs-at-scale/) (21 dicembre 2018).
[Crea un'architettura serverless per analizzare i log di CloudFront accesso di Amazon utilizzando AWS Lambda Amazon Athena e Amazon Managed Service for Apache](https://aws.amazon.com/blogs/big-data/build-a-serverless-architecture-to-analyze-amazon-cloudfront-access-logs-using-aws-lambda-amazon-athena-and-amazon-kinesis-analytics/) Flink (26 maggio 2017).
# AWS CloudTrail Registri delle interrogazioni
AWS CloudTrail è un servizio che registra chiamate ed eventi AWS API per gli account Amazon Web Services.
CloudTrail i log includono dettagli su tutte le chiamate API effettuate al tuo account Servizi AWS, inclusa la console. CloudTrail genera file di registro crittografati e li archivia in Amazon S3. Per ulteriori informazioni, consulta la [Guida per l'utente AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-user-guide.html).
**Nota**
Se desideri eseguire query SQL sulle informazioni sugli CloudTrail eventi tra account, regioni e date, prendi in considerazione l'utilizzo CloudTrail di Lake. CloudTrail Lake è un' AWS alternativa alla creazione di percorsi che aggregano le informazioni di un'azienda in un unico archivio di dati sugli eventi ricercabile. Invece di utilizzare lo storage bucket Amazon S3, memorizza gli eventi in un data lake, che consente di effettuare query più ricche e più rapide. È possibile utilizzarlo per creare query SQL che cercano eventi tra organizzazioni, regioni e intervalli di tempo personalizzati. Poiché esegui le query su CloudTrail Lake all'interno della CloudTrail console stessa, l'utilizzo di CloudTrail Lake non richiede Athena. Per ulteriori informazioni, consulta la documentazione di [CloudTrail Lake](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-lake.html).
L'utilizzo di Athena con CloudTrail i log è un modo efficace per migliorare l'analisi delle attività. Servizio AWS Ad esempio, puoi utilizzare le query per identificare le tendenze e isolare con maggiore precisione le attività in base ad attributi specifici, ad esempio l'indirizzo IP di origine o un utente.
Un'applicazione comune consiste nell'utilizzare CloudTrail i log per analizzare l'attività operativa per motivi di sicurezza e conformità. Per informazioni su un esempio dettagliato, consulta il post sul blog AWS Big Data, [Analyze security, compliance and operations activity using AWS CloudTrail and Amazon Athena](https://aws.amazon.com/blogs/big-data/aws-cloudtrail-and-amazon-athena-dive-deep-to-analyze-security-compliance-and-operational-activity/).
È possibile usare Athena per eseguire query su questi file di log direttamente da Amazon S3, specificando la voce `LOCATION` dei file di log. Ci sono due modi per farlo:
+ Creando tabelle per i file di CloudTrail log direttamente dalla CloudTrail console.
+ Creando manualmente tabelle per i file di CloudTrail registro nella console Athena.
**Topics**
+ [Comprendi CloudTrail i log e le tabelle Athena](create-cloudtrail-table-understanding.md)
+ [Usa la CloudTrail console per creare una tabella Athena per i log CloudTrail](create-cloudtrail-table-ct.md)
+ [Creare una tabella per CloudTrail i log in Athena utilizzando il partizionamento manuale](create-cloudtrail-table.md)
+ [Crea una tabella per un percorso a livello di organizzazione utilizzando il partizionamento manuale](create-cloudtrail-table-org-wide-trail.md)
+ [Crea la tabella per i CloudTrail log in Athena usando la proiezione delle partizioni](create-cloudtrail-table-partition-projection.md)
+ [Esempi di interrogazioni di CloudTrail registro](query-examples-cloudtrail-logs.md)
# Comprendi CloudTrail i log e le tabelle Athena
Prima di iniziare a creare tabelle, è necessario comprendere meglio come vengono CloudTrail archiviati i dati. Questo può aiutarti a creare le tabelle di cui hai bisogno, indipendentemente dal fatto che tu le crei dalla CloudTrail console o da Athena.
CloudTrail salva i log come file di testo JSON in formato gzip compresso (). `*.json.gz` La posizione dei file di registro dipende dalla modalità di configurazione dei percorsi, dalle regioni in cui si effettua la Regione AWS registrazione e da altri fattori.
Per ulteriori informazioni su dove vengono archiviati i log, la struttura JSON e i contenuti dei file di record, consulta i seguenti argomenti nella [Guida per l'utente di AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-user-guide.html):
+ [Individuazione dei file di CloudTrail registro](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-find-log-files.html)
+ [CloudTrail Esempi di file di registro](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-log-file-examples.html)
+ [CloudTrail contenuti dei record](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-record-contents.html)
+ [CloudTrail riferimento all'evento](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference.html)
Per raccogliere i log e salvarli su Amazon S3, CloudTrail abilita da. Console di gestione AWS Per ulteriori informazioni, consulta [Creazione di un percorso](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-a-trail-using-the-console-first-time.html) nella *Guida per l'utente di AWS CloudTrail *.
# Usa la CloudTrail console per creare una tabella Athena per i log CloudTrail
È possibile creare una tabella Athena non partizionata per CloudTrail interrogare i log direttamente dalla console. CloudTrail La creazione di una tabella Athena dalla CloudTrail console richiede l'accesso con un ruolo con autorizzazioni sufficienti per creare tabelle in Athena.
**Nota**
Non è possibile utilizzare la CloudTrail console per creare una tabella Athena per i log degli itinerari organizzativi. Crea invece la tabella manualmente utilizzando la console Athena in modo da poter specificare la posizione di archiviazione corretta. Per ulteriori informazioni sui percorsi dell'organizzazione, consulta [Creazione di un percorso per un'organizzazione](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/creating-trail-organization.html) nella *Guida per l'utente di AWS CloudTrail *.
+ Per informazioni sull'impostazione delle autorizzazioni di gruppo per Athena, consulta [Configurare l’accesso amministrativo e programmatico](setting-up.md).
+ Per informazioni sulla creazione di una tabella con partizioni, consulta [Creare una tabella per CloudTrail i log in Athena utilizzando il partizionamento manuale](create-cloudtrail-table.md).
**Per creare una tabella Athena per un CloudTrail percorso utilizzando la console CloudTrail**
1. Apri la CloudTrail console all'indirizzo [https://console.aws.amazon.com/cloudtrail/](https://console.aws.amazon.com/cloudtrail/).
1. Nel riquadro di navigazione scegliere **Event history** (Cronologia eventi).
1. Scegli **Crea la tabella Athena**.
![\[Scegli Crea la tabella Athena\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/cloudtrail-logs-create-athena-table.png)
1. Per **Storage location** (Posizione di archiviazione), utilizza la freccia giù per selezionare il bucket Amazon S3 in cui sono archiviati i file di log per il trail sul quale eseguire le query.
**Nota**
Per trovare il nome del bucket associato a un percorso, scegli **Percorsi** nel riquadro di CloudTrail navigazione e visualizza la colonna del **bucket S3** del percorso. Per visualizzare la posizione del bucket in Amazon S3, scegliere il link per il bucket nella colonna **Bucket S3**. In questo modo la console Amazon S3 viene aperta alla posizione del CloudTrail bucket.
1. Scegliere **Create table (Crea tabella)**. La tabella viene creata con un nome di default che include il nome del bucket Amazon S3.
# Creare una tabella per CloudTrail i log in Athena utilizzando il partizionamento manuale
È possibile creare manualmente tabelle per i file di CloudTrail registro nella console Athena e quindi eseguire query in Athena.
**Per creare una tabella Athena per un CloudTrail percorso utilizzando la console Athena**
1. Copia e incolla la seguente istruzione DDL nell’editor di query della console Athena, quindi modificala in base alle tue esigenze. Tieni presente che, poiché i file di CloudTrail registro non sono una traccia ordinata di chiamate API pubbliche, i campi nei file di registro non vengono visualizzati in un ordine specifico.
```
CREATE EXTERNAL TABLE cloudtrail_logs (
eventversion STRING,
useridentity STRUCT<
type:STRING,
principalid:STRING,
arn:STRING,
accountid:STRING,
invokedby:STRING,
accesskeyid:STRING,
username:STRING,
onbehalfof: STRUCT<
userid: STRING,
identitystorearn: STRING>,
sessioncontext:STRUCT<
attributes:STRUCT<
mfaauthenticated:STRING,
creationdate:STRING>,
sessionissuer:STRUCT<
type:STRING,
principalid:STRING,
arn:STRING,
accountid:STRING,
username:STRING>,
ec2roledelivery:string,
webidfederationdata: STRUCT<
federatedprovider: STRING,
attributes: map>
>
>,
eventtime STRING,
eventsource STRING,
eventname STRING,
awsregion STRING,
sourceipaddress STRING,
useragent STRING,
errorcode STRING,
errormessage STRING,
requestparameters STRING,
responseelements STRING,
additionaleventdata STRING,
requestid STRING,
eventid STRING,
resources ARRAY>,
eventtype STRING,
apiversion STRING,
readonly STRING,
recipientaccountid STRING,
serviceeventdetails STRING,
sharedeventid STRING,
vpcendpointid STRING,
vpcendpointaccountid STRING,
eventcategory STRING,
addendum STRUCT<
reason:STRING,
updatedfields:STRING,
originalrequestid:STRING,
originaleventid:STRING>,
sessioncredentialfromconsole STRING,
edgedevicedetails STRING,
tlsdetails STRUCT<
tlsversion:STRING,
ciphersuite:STRING,
clientprovidedhostheader:STRING>
)
PARTITIONED BY (region string, year string, month string, day string)
ROW FORMAT SERDE 'org.apache.hive.hcatalog.data.JsonSerDe'
STORED AS INPUTFORMAT 'com.amazon.emr.cloudtrail.CloudTrailInputFormat'
OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION 's3://amzn-s3-demo-bucket/AWSLogs/Account_ID/';
```
**Nota**
Suggeriamo di utilizzare il `org.apache.hive.hcatalog.data.JsonSerDe` mostrato nell’esempio. Sebbene a `com.amazon.emr.hive.serde.CloudTrailSerde` esista, attualmente non gestisce alcuni dei campi più recenti. CloudTrail
1. (Facoltativo) Rimuovi tutti i campi non obbligatori per la tabella. Se è necessario leggere solo un determinato set di colonne, la definizione della tabella può escludere le altre colonne.
1. Modifica `s3://amzn-s3-demo-bucket/AWSLogs/Account_ID/` perché punti al bucket Amazon S3 che contiene i dati di log che vuoi interrogare. L'esempio utilizza un `LOCATION` valore di log per un determinato account, ma è possibile utilizzare il grado di specificità più adatta alla tua applicazione. Ad esempio:
+ Per analizzare i dati provenienti da più account, puoi eseguire il rollback dell'identificatore `LOCATION` per selezionare tutti gli `AWSLogs` con `LOCATION 's3://amzn-s3-demo-bucket/AWSLogs/'`.
+ Per analizzare i dati provenienti da una data, account e regione specifici, utilizza `LOCATION 's3://amzn-s3-demo-bucket/123456789012/CloudTrail/us-east-1/2016/03/14/'.`
+ Per analizzare i dati sulle attività di rete anziché gli eventi di gestione, sostituire `/CloudTrail/` nella clausola `LOCATION` con `/CloudTrail-NetworkActivity/`.
Indicando il livello più elevato nella gerarchia degli oggetti hai la massima flessibilità nelle query con Athena.
1. Verificare che i campi siano elencati correttamente. Per ulteriori informazioni sull'elenco completo dei campi in un CloudTrail record, vedere il [contenuto del CloudTrail record](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-record-contents.html).
L’istruzione di esempio `CREATE TABLE` nella Fase 1 utilizza il [JSON Hive SerDe](hive-json-serde.md). Nell’esempio, i campi `requestparameters`, `responseelements` e `additionaleventdata` sono elencati come tipo `STRING` nella query, ma sono dati di tipo `STRUCT` utilizzati in JSON. Pertanto, per estrarre i dati da questi campi, utilizza le funzioni `JSON_EXTRACT`. Per ulteriori informazioni, consulta [Estrarre dati JSON da stringhe](extracting-data-from-JSON.md). Per migliorare le prestazioni, l'esempio partiziona i dati per anno Regione AWS, mese e giorno.
1. Esegui l'istruzione `CREATE TABLE` nella console Athena.
1. Utilizzare il comando [ALTER TABLE ADD PARTITION](alter-table-add-partition.md) per caricare le partizioni in modo da poterle interrogare, come nell'esempio seguente.
```
ALTER TABLE table_name ADD
PARTITION (region='us-east-1',
year='2019',
month='02',
day='01')
LOCATION 's3://amzn-s3-demo-bucket/AWSLogs/Account_ID/CloudTrail/us-east-1/2019/02/01/'
```
# Crea una tabella per un percorso a livello di organizzazione utilizzando il partizionamento manuale
Per creare una tabella per i file di CloudTrail registro a livello di organizzazione in Athena, segui la procedura riportata di seguito[Creare una tabella per CloudTrail i log in Athena utilizzando il partizionamento manuale](create-cloudtrail-table.md), ma apporta le modifiche indicate nella procedura seguente.
**Per creare una tabella Athena per i registri a livello di organizzazione CloudTrail**
1. Nell'istruzione `CREATE TABLE`, modifica la clausola `LOCATION` per includere l'ID dell'organizzazione, come nell'esempio seguente:
```
LOCATION 's3://amzn-s3-demo-bucket/AWSLogs/organization_id/'
```
1. Nella clausola `PARTITIONED BY`, aggiungi una voce per l'ID account sotto forma di stringa, come nell'esempio seguente:
```
PARTITIONED BY (account string, region string, year string, month string, day string)
```
L'esempio seguente mostra solo il risultato combinato:
```
...
PARTITIONED BY (account string, region string, year string, month string, day string)
ROW FORMAT SERDE 'org.apache.hive.hcatalog.data.JsonSerDe'
STORED AS INPUTFORMAT 'com.amazon.emr.cloudtrail.CloudTrailInputFormat'
OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION 's3://amzn-s3-demo-bucket/AWSLogs/organization_id/Account_ID/CloudTrail/'
```
1. Nella clausola `ADD PARTITION` dell'istruzione `ALTER TABLE`, includi l'ID dell'account, come nell'esempio seguente:
```
ALTER TABLE table_name ADD
PARTITION (account='111122223333',
region='us-east-1',
year='2022',
month='08',
day='08')
```
1. Nella clausola `LOCATION` dell'istruzione `ALTER TABLE`, includi l'ID dell'organizzazione, l'ID dell'account e la partizione che desideri aggiungere, come nell'esempio seguente:
```
LOCATION 's3://amzn-s3-demo-bucket/AWSLogs/organization_id/Account_ID/CloudTrail/us-east-1/2022/08/08/'
```
L'istruzione di esempio `ALTER TABLE` seguente mostra solo il risultato combinato:
```
ALTER TABLE table_name ADD
PARTITION (account='111122223333',
region='us-east-1',
year='2022',
month='08',
day='08')
LOCATION 's3://amzn-s3-demo-bucket/AWSLogs/organization_id/111122223333/CloudTrail/us-east-1/2022/08/08/'
```
Nota che, in un’organizzazione di grandi dimensioni, l’utilizzo di questo metodo per aggiungere e gestire manualmente una partizione per ogni ID di account dell’organizzazione può essere complicato. In uno scenario del genere, prendi in considerazione l'utilizzo di CloudTrail Lake anziché Athena. CloudTrail Lake in uno scenario del genere offre i seguenti vantaggi:
+ Aggrega automaticamente i log di un'intera organizzazione
+ Non richiede la configurazione o la manutenzione di partizioni o di una tabella Athena
+ Le interrogazioni vengono eseguite direttamente nella console CloudTrail
+ Utilizza un linguaggio di query compatibile con SQL
Per ulteriori informazioni, consulta [Utilizzo di AWS CloudTrail Lake](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-lake.html) nella *Guida per l’utente di AWS CloudTrail *.
# Crea la tabella per i CloudTrail log in Athena usando la proiezione delle partizioni
Poiché CloudTrail i log hanno una struttura nota il cui schema di partizione è possibile specificare in anticipo, è possibile ridurre il tempo di esecuzione delle query e automatizzare la gestione delle partizioni utilizzando la funzionalità di proiezione delle partizioni Athena. La proiezione delle partizioni aggiunge automaticamente nuove partizioni man mano che vengono aggiunti nuovi dati. Ciò elimina la necessità di aggiungere manualmente le partizioni utilizzando `ALTER TABLE ADD PARTITION`.
L'`CREATE TABLE`istruzione di esempio che segue utilizza automaticamente la proiezione delle partizioni sui CloudTrail registri da una data specificata a quella attuale per un singolo registro. Regione AWS Nelle `storage.location.template` clausole `LOCATION` and, sostituite i *aws-region* segnaposto *bucket**account-id*, e con valori corrispondentemente identici. Per`projection.timestamp.range`, sostituisci*2020*/*01*/*01*con la data di inizio che desideri utilizzare. Dopo aver eseguito la query con esito positivo, è possibile eseguire query sulla tabella. Non è necessario eseguire `ALTER TABLE ADD PARTITION` per caricare le partizioni.
```
CREATE EXTERNAL TABLE cloudtrail_logs_pp(
eventversion STRING,
useridentity STRUCT<
type: STRING,
principalid: STRING,
arn: STRING,
accountid: STRING,
invokedby: STRING,
accesskeyid: STRING,
username: STRING,
onbehalfof: STRUCT<
userid: STRING,
identitystorearn: STRING>,
sessioncontext: STRUCT<
attributes: STRUCT<
mfaauthenticated: STRING,
creationdate: STRING>,
sessionissuer: STRUCT<
type: STRING,
principalid: STRING,
arn: STRING,
accountid: STRING,
username: STRING>,
ec2roledelivery:string,
webidfederationdata: STRUCT<
federatedprovider: STRING,
attributes: map>
>
>,
eventtime STRING,
eventsource STRING,
eventname STRING,
awsregion STRING,
sourceipaddress STRING,
useragent STRING,
errorcode STRING,
errormessage STRING,
requestparameters STRING,
responseelements STRING,
additionaleventdata STRING,
requestid STRING,
eventid STRING,
readonly STRING,
resources ARRAY>,
eventtype STRING,
apiversion STRING,
recipientaccountid STRING,
serviceeventdetails STRING,
sharedeventid STRING,
vpcendpointid STRING,
vpcendpointaccountid STRING,
eventcategory STRING,
addendum STRUCT<
reason:STRING,
updatedfields:STRING,
originalrequestid:STRING,
originaleventid:STRING>,
sessioncredentialfromconsole STRING,
edgedevicedetails STRING,
tlsdetails STRUCT<
tlsversion:STRING,
ciphersuite:STRING,
clientprovidedhostheader:STRING>
)
PARTITIONED BY (
`timestamp` string)
ROW FORMAT SERDE 'org.apache.hive.hcatalog.data.JsonSerDe'
STORED AS INPUTFORMAT 'com.amazon.emr.cloudtrail.CloudTrailInputFormat'
OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION
's3://amzn-s3-demo-bucket/AWSLogs/account-id/CloudTrail/aws-region'
TBLPROPERTIES (
'projection.enabled'='true',
'projection.timestamp.format'='yyyy/MM/dd',
'projection.timestamp.interval'='1',
'projection.timestamp.interval.unit'='DAYS',
'projection.timestamp.range'='2020/01/01,NOW',
'projection.timestamp.type'='date',
'storage.location.template'='s3://amzn-s3-demo-bucket/AWSLogs/account-id/CloudTrail/aws-region/${timestamp}')
```
Per maggiori informazioni sulla proiezione delle partizioni, consulta [Proiezione delle partizioni con Amazon Athena](partition-projection.md).
# Esempi di interrogazioni di CloudTrail registro
L'esempio seguente mostra una parte di una query che restituisce tutte le richieste anonime (non firmate) dalla tabella creata per i registri CloudTrail degli eventi. Questa query seleziona le richieste in cui `useridentity.accountid` è anonimo e `useridentity.arn` non è specificato:
```
SELECT *
FROM cloudtrail_logs
WHERE
eventsource = 's3.amazonaws.com' AND
eventname in ('GetObject') AND
useridentity.accountid = 'anonymous' AND
useridentity.arn IS NULL AND
requestparameters LIKE '%[your bucket name ]%';
```
Per ulteriori informazioni, consulta il post sul blog AWS Big Data [Analyze security, compliance and operations activity using AWS CloudTrail and Amazon Athena](https://aws.amazon.com/blogs/big-data/aws-cloudtrail-and-amazon-athena-dive-deep-to-analyze-security-compliance-and-operational-activity/).
## Interroga i campi annidati nei log CloudTrail
Poiché i campi `userIdentity` e `resources` sono tipi di dati nidificati, l’esecuzioni di query richiede un trattamento speciale.
L'oggetto `userIdentity` è costituito da tipi nidificati `STRUCT`. È possibile eseguire query utilizzando un punto per separare i campi, come nell'esempio seguente:
```
SELECT
eventsource,
eventname,
useridentity.sessioncontext.attributes.creationdate,
useridentity.sessioncontext.sessionissuer.arn
FROM cloudtrail_logs
WHERE useridentity.sessioncontext.sessionissuer.arn IS NOT NULL
ORDER BY eventsource, eventname
LIMIT 10
```
Il campo `resources` è un array di oggetti `STRUCT`. Per questi array, utilizzare `CROSS JOIN UNNEST` per annullare l'array in modo da poter interrogare i suoi oggetti.
L'esempio seguente restituisce tutte le righe in cui la risorsa ARN termina in `example/datafile.txt`. Per la leggibilità, la funzione [replace](https://prestodb.io/docs/current/functions/string.html#replace) rimuove la sottostringa iniziale `arn:aws:s3:::` dall'ARN.
```
SELECT
awsregion,
replace(unnested.resources_entry.ARN,'arn:aws:s3:::') as s3_resource,
eventname,
eventtime,
useragent
FROM cloudtrail_logs t
CROSS JOIN UNNEST(t.resources) unnested (resources_entry)
WHERE unnested.resources_entry.ARN LIKE '%example/datafile.txt'
ORDER BY eventtime
```
Di seguito sono illustrati alcuni esempi di query per gli eventi `DeleteBucket`. La query estrae il nome del bucket e l'ID account a cui appartiene il bucket dall'oggetto `resources`.
```
SELECT
awsregion,
replace(unnested.resources_entry.ARN,'arn:aws:s3:::') as deleted_bucket,
eventtime AS time_deleted,
useridentity.username,
unnested.resources_entry.accountid as bucket_acct_id
FROM cloudtrail_logs t
CROSS JOIN UNNEST(t.resources) unnested (resources_entry)
WHERE eventname = 'DeleteBucket'
ORDER BY eventtime
```
Per ulteriori informazioni sull'annullamento della nidificazione, consulta [Filtrare le matrici](filtering-arrays.md).
## Suggerimenti per l'interrogazione dei log CloudTrail
Quando esplori i dati di CloudTrail registro, considera quanto segue:
+ Prima di eseguire query sui log, verifica che la tabella di log sia uguale a quella definita in [Creare una tabella per CloudTrail i log in Athena utilizzando il partizionamento manuale](create-cloudtrail-table.md). Se non è la prima tabella, elimina la tabella esistente utilizzando il comando: `DROP TABLE cloudtrail_logs`.
+ Dopo aver eliminato la tabella esistente, ricreala. Per ulteriori informazioni, consulta [Creare una tabella per CloudTrail i log in Athena utilizzando il partizionamento manuale](create-cloudtrail-table.md).
Verifica che i campi della query Athena siano elencati correttamente. Per informazioni sull'elenco completo dei campi in un CloudTrail record, consulta il [contenuto del CloudTrail record](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-record-contents.html).
Se la query include campi nei formati JSON, ad esempio `STRUCT`, estrarre i dati da JSON. Per ulteriori informazioni, consulta [Estrarre dati JSON da stringhe](extracting-data-from-JSON.md).
Alcuni suggerimenti per eseguire interrogazioni sulla tabella: CloudTrail
+ Inizia osservando quali utenti hanno eseguito specifiche operazioni API e gli indirizzi IP di origine.
+ Utilizza la seguente query SQL di base come modello. Incolla la query nella console Athena ed eseguila.
```
SELECT
useridentity.arn,
eventname,
sourceipaddress,
eventtime
FROM cloudtrail_logs
LIMIT 100;
```
+ Modifica la query per esplorare ulteriormente i dati.
+ Per migliorare le prestazioni, includi la clausola `LIMIT` per ottenere uno specifico sottoinsieme di righe.
# Eseguire query sui log Amazon EMR
Amazon EMR e le applicazioni Big Data che vengono eseguite su Amazon EMR generano file di log. I file di log vengono scritti sul [nodo primario](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-master-core-task-nodes.html), ed è anche possibile configurare Amazon EMR per consentire la loro archiviazione automatica in Amazon S3. È possibile utilizzare Amazon Athena per eseguire query su questi log per identificare eventi e tendenze per applicazioni e cluster. Per ulteriori informazioni sui tipi di file di log in Amazon EMR e sul loro salvataggio in Amazon S3, consulta [Visualizzazione di file di log](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-manage-view-web-log-files.html) nella *Guida alla gestione di Amazon EMR*.
**Topics**
+ [Creare ed eseguire query su una tabella di base basata sui file di log di Amazon EMR](emr-create-table.md)
+ [Creare ed eseguire query su una tabella partizionata in base ai log di Amazon EMR](emr-create-table-partitioned.md)
# Creare ed eseguire query su una tabella di base basata sui file di log di Amazon EMR
Nell'esempio seguente viene creata una tabella di base `myemrlogs`, basata sui file di log salvati in `s3://aws-logs-123456789012-us-west-2/elasticmapreduce/j-2ABCDE34F5GH6/elasticmapreduce/`. La posizione Amazon S3 utilizzata negli esempi seguenti riflette lo schema della posizione di registro predefinita per un cluster EMR creato dall'account Amazon Web Services nella regione. *123456789012* *us-west-2* Se utilizzi una posizione personalizzata, il modello è s3://amzn-s3-demo-bucket/. *ClusterID*
Per informazioni sulla creazione di una tabella partizionata per migliorare potenzialmente le prestazioni delle query e ridurre il trasferimento dei dati, consulta [Creare ed eseguire query su una tabella partizionata in base ai log di Amazon EMR](emr-create-table-partitioned.md).
```
CREATE EXTERNAL TABLE `myemrlogs`(
`data` string COMMENT 'from deserializer')
ROW FORMAT DELIMITED
FIELDS TERMINATED BY '|'
LINES TERMINATED BY '\n'
STORED AS INPUTFORMAT
'org.apache.hadoop.mapred.TextInputFormat'
OUTPUTFORMAT
'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION
's3://aws-logs-123456789012-us-west-2/elasticmapreduce/j-2ABCDE34F5GH6'
```
## Query di esempio
Le query di esempio seguenti possono essere eseguite sulla tabella `myemrlogs` creata dall'esempio precedente.
**Example Esecuzione di query su log di fase per occorrenze di ERROR, WARN, INFO, EXCEPTION, FATAL o DEBUG**
```
SELECT data,
"$PATH"
FROM "default"."myemrlogs"
WHERE regexp_like("$PATH",'s-86URH188Z6B1')
AND regexp_like(data, 'ERROR|WARN|INFO|EXCEPTION|FATAL|DEBUG') limit 100;
```
**Example Esecuzione di query su log di istanze specifiche, i-00b3c0a839ece0a9c, per ERROR, WARN, INFO, EXCEPTION, FATAL o DEBUG**
```
SELECT "data",
"$PATH" AS filepath
FROM "default"."myemrlogs"
WHERE regexp_like("$PATH",'i-00b3c0a839ece0a9c')
AND regexp_like("$PATH",'state')
AND regexp_like(data, 'ERROR|WARN|INFO|EXCEPTION|FATAL|DEBUG') limit 100;
```
**Example Esecuzione di query su log di applicazioni Presto per ERROR, WARN, INFO, EXCEPTION, FATAL o DEBUG**
```
SELECT "data",
"$PATH" AS filepath
FROM "default"."myemrlogs"
WHERE regexp_like("$PATH",'presto')
AND regexp_like(data, 'ERROR|WARN|INFO|EXCEPTION|FATAL|DEBUG') limit 100;
```
**Example Esecuzione di query su log di applicazioni Namenode per ERROR, WARN, INFO, EXCEPTION, FATAL o DEBUG**
```
SELECT "data",
"$PATH" AS filepath
FROM "default"."myemrlogs"
WHERE regexp_like("$PATH",'namenode')
AND regexp_like(data, 'ERROR|WARN|INFO|EXCEPTION|FATAL|DEBUG') limit 100;
```
**Example Esecuzione di query su tutti i log per data e ora per ERROR, WARN, INFO, EXCEPTION, FATAL o DEBUG**
```
SELECT distinct("$PATH") AS filepath
FROM "default"."myemrlogs"
WHERE regexp_like("$PATH",'2019-07-23-10')
AND regexp_like(data, 'ERROR|WARN|INFO|EXCEPTION|FATAL|DEBUG') limit 100;
```
# Creare ed eseguire query su una tabella partizionata in base ai log di Amazon EMR
Questi esempi utilizzano la stessa posizione dei log per creare una tabella Athena, ma la tabella viene partizionata e viene quindi creata una partizione per ogni posizione. Per ulteriori informazioni, consulta [Come partizionare i dati](partitions.md).
La query seguente crea la tabella partizionata denominata `mypartitionedemrlogs`:
```
CREATE EXTERNAL TABLE `mypartitionedemrlogs`(
`data` string COMMENT 'from deserializer')
partitioned by (logtype string)
ROW FORMAT DELIMITED
FIELDS TERMINATED BY '|'
LINES TERMINATED BY '\n'
STORED AS INPUTFORMAT
'org.apache.hadoop.mapred.TextInputFormat'
OUTPUTFORMAT
'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION 's3://aws-logs-123456789012-us-west-2/elasticmapreduce/j-2ABCDE34F5GH6'
```
Le istruzioni di query seguenti creano quindi partizioni di tabella basate su sottodirectory per diversi tipi di log che Amazon EMR crea in Amazon S3:
```
ALTER TABLE mypartitionedemrlogs ADD
PARTITION (logtype='containers')
LOCATION 's3://aws-logs-123456789012-us-west-2/elasticmapreduce/j-2ABCDE34F5GH6/containers/'
```
```
ALTER TABLE mypartitionedemrlogs ADD
PARTITION (logtype='hadoop-mapreduce')
LOCATION 's3://aws-logs-123456789012-us-west-2/elasticmapreduce/j-2ABCDE34F5GH6/hadoop-mapreduce/'
```
```
ALTER TABLE mypartitionedemrlogs ADD
PARTITION (logtype='hadoop-state-pusher')
LOCATION 's3://aws-logs-123456789012-us-west-2/elasticmapreduce/j-2ABCDE34F5GH6/hadoop-state-pusher/'
```
```
ALTER TABLE mypartitionedemrlogs ADD
PARTITION (logtype='node')
LOCATION 's3://aws-logs-123456789012-us-west-2/elasticmapreduce/j-2ABCDE34F5GH6/node/'
```
```
ALTER TABLE mypartitionedemrlogs ADD
PARTITION (logtype='steps')
LOCATION 's3://aws-logs-123456789012-us-west-2/elasticmapreduce/j-2ABCDE34F5GH6/steps/'
```
Dopo aver creato le partizioni, puoi eseguire una query `SHOW PARTITIONS` nella tabella per confermare:
```
SHOW PARTITIONS mypartitionedemrlogs;
```
## Query di esempio
Negli esempi seguenti vengono illustrate le query per voci di log specifiche che utilizzano la tabella e le partizioni create dagli esempi precedenti.
**Example Esecuzione di query sui log di applicazioni application\$11561661818238\$10002 nella partizione dei contenitori per ERROR o WARN**
```
SELECT data,
"$PATH"
FROM "default"."mypartitionedemrlogs"
WHERE logtype='containers'
AND regexp_like("$PATH",'application_1561661818238_0002')
AND regexp_like(data, 'ERROR|WARN') limit 100;
```
**Example Esecuzione di query sulla partizione Hadoop-Mapreduce per l'attività job\$11561661818238\$10004 e Failed Reduces**
```
SELECT data,
"$PATH"
FROM "default"."mypartitionedemrlogs"
WHERE logtype='hadoop-mapreduce'
AND regexp_like(data,'job_1561661818238_0004|Failed Reduces') limit 100;
```
**Example Esecuzione di query sui log Hive nella partizione dei nodi per l'ID query 056e0609-33e1-4611-956c-7a31b42d2663**
```
SELECT data,
"$PATH"
FROM "default"."mypartitionedemrlogs"
WHERE logtype='node'
AND regexp_like("$PATH",'hive')
AND regexp_like(data,'056e0609-33e1-4611-956c-7a31b42d2663') limit 100;
```
**Example Esecuzione di query sui log ResourceManager nella partizione dei nodi per l'applicazione 1567660019320\$10001\$101\$1000001**
```
SELECT data,
"$PATH"
FROM "default"."mypartitionedemrlogs"
WHERE logtype='node'
AND regexp_like(data,'resourcemanager')
AND regexp_like(data,'1567660019320_0001_01_000001') limit 100
```
# Registri AWS Global Accelerator del flusso di query
Puoi utilizzarli AWS Global Accelerator per creare acceleratori che indirizzano il traffico di rete verso endpoint ottimali sulla rete globale. AWS [Per ulteriori informazioni su Global Accelerator, consulta What is. AWS Global Accelerator](https://docs.aws.amazon.com/global-accelerator/latest/dg/what-is-global-accelerator.html)
I log di flusso Global Accelerator ti consentono di acquisire informazioni sul traffico degli indirizzi IP in entrata e in uscita dalle interfacce di rete negli acceleratori. I dati dei log di flusso vengono pubblicati in Amazon S3, dove è possibile recuperare e visualizzare i dati. Per ulteriori informazioni, consulta [Log di flusso in AWS Global Accelerator](https://docs.aws.amazon.com/global-accelerator/latest/dg/monitoring-global-accelerator.flow-logs.html).
Puoi utilizzare Athena per eseguire query sui log di flusso Global Accelerator creando una tabella che ne specifica la posizione in Amazon S3.
**Per creare la tabella per i log di flusso di Global Accelerator**
1. Copiare e incollare la seguente istruzione DDL nella console Athena. Questa query specifica *ROW FORMAT DELIMITED* e omette di specificare a [SerDe](serde-reference.md), il che significa che la query utilizza il. [`LazySimpleSerDe`](lazy-simple-serde.md) In questa query, i campi terminano con uno spazio.
```
CREATE EXTERNAL TABLE IF NOT EXISTS aga_flow_logs (
version string,
account string,
acceleratorid string,
clientip string,
clientport int,
gip string,
gipport int,
endpointip string,
endpointport int,
protocol string,
ipaddresstype string,
numpackets bigint,
numbytes int,
starttime int,
endtime int,
action string,
logstatus string,
agasourceip string,
agasourceport int,
endpointregion string,
agaregion string,
direction string,
vpc_id string,
reject_reason string
)
PARTITIONED BY (dt string)
ROW FORMAT DELIMITED
FIELDS TERMINATED BY ' '
LOCATION 's3://amzn-s3-demo-bucket/prefix/AWSLogs/account_id/globalaccelerator/region/'
TBLPROPERTIES ("skip.header.line.count"="1");
```
1. Modificare il valore `LOCATION` in modo che punti al bucket Amazon S3 che contiene i dati di log.
```
's3://amzn-s3-demo-bucket/prefix/AWSLogs/account_id/globalaccelerator/region_code/'
```
1. Eseguire la query nella console Athena. Una volta completata la query, Athena registra la tabella `aga_flow_logs`, rendendo i dati in essa contenuti disponibili per l'esecuzione di query.
1. Creare partizioni per leggere i dati, come nella seguente query di esempio. La query crea una singola partizione per una data specificata. Sostituire i segnaposto per data e posizione.
```
ALTER TABLE aga_flow_logs
ADD PARTITION (dt='YYYY-MM-dd')
LOCATION 's3://amzn-s3-demo-bucket/prefix/AWSLogs/account_id/globalaccelerator/region_code/YYYY/MM/dd';
```
## Query di esempio per i log di flusso AWS Global Accelerator
**Example Elencare le richieste che passano attraverso una edge location specifica**
La query di esempio seguente elenca le richieste passate attraverso la edge location LHR. Utilizza l'operatore `LIMIT` per limitare il numero di log di cui eseguire la query alla volta.
```
SELECT
clientip,
agaregion,
protocol,
action
FROM
aga_flow_logs
WHERE
agaregion LIKE 'LHR%'
LIMIT
100;
```
**Example Elencare gli indirizzi IP dell'endpoint che ricevono la maggior parte delle richieste HTTPS**
Utilizza la query seguente per verificare quali indirizzi IP dell'endpoint ricevono il numero più elevato di richieste HTTPS. La query conta il numero di pacchetti ricevuti sulla porta HTTPS 443, li raggruppa in base all'indirizzo IP di destinazione e restituisce i primi 10 indirizzi IP.
```
SELECT
SUM(numpackets) AS packetcount,
endpointip
FROM
aga_flow_logs
WHERE
endpointport = 443
GROUP BY
endpointip
ORDER BY
packetcount DESC
LIMIT
10;
```
# Interroga GuardDuty i risultati di Amazon
[Amazon GuardDuty](https://aws.amazon.com/guardduty/) è un servizio di monitoraggio della sicurezza che aiuta a identificare attività impreviste e potenzialmente non autorizzate o dannose nel tuo AWS ambiente. Quando rileva attività impreviste e potenzialmente dannose, GuardDuty genera [risultati](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_findings.html) di sicurezza che puoi esportare in Amazon S3 per l'archiviazione e l'analisi. Dopo aver esportato i risultati in Amazon S3, è possibile utilizzare Athena per eseguire le query. Questo articolo mostra come creare una tabella in Athena per i GuardDuty risultati e interrogarli.
Per ulteriori informazioni su Amazon GuardDuty, consulta la [Amazon GuardDuty User Guide](https://docs.aws.amazon.com/guardduty/latest/ug/).
## Prerequisiti
+ Abilita la GuardDuty funzionalità per esportare i risultati in Amazon S3. Per i passaggi, consulta [Esportazione dei risultati](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_exportfindings.html) nella Amazon GuardDuty User Guide.
## Crea una tabella in Athena per i risultati GuardDuty
Per interrogare GuardDuty i tuoi risultati con Athena, devi creare una tabella per essi.
**Per creare una tabella in Athena per i risultati GuardDuty**
1. Apri la console Athena all'indirizzo [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Incollare la seguente istruzione DDL nella console Athena. Modifica i valori in `LOCATION 's3://amzn-s3-demo-bucket/AWSLogs/account-id/GuardDuty/'` modo che rimandino ai tuoi GuardDuty risultati in Amazon S3.
```
CREATE EXTERNAL TABLE `gd_logs` (
`schemaversion` string,
`accountid` string,
`region` string,
`partition` string,
`id` string,
`arn` string,
`type` string,
`resource` string,
`service` string,
`severity` string,
`createdat` string,
`updatedat` string,
`title` string,
`description` string)
ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe'
LOCATION 's3://amzn-s3-demo-bucket/AWSLogs/account-id/GuardDuty/'
TBLPROPERTIES ('has_encrypted_data'='true')
```
**Nota**
SerDe Si aspetta che ogni documento JSON si trovi su una singola riga di testo senza caratteri di terminazione di riga che separano i campi del record. Se il testo JSON è in un bel formato di stampa, potresti ricevere un messaggio di errore come HIVE\$1CURSOR\$1ERROR: Row is not a valid JSON Object o HIVE\$1CURSOR\$1ERROR:: Unexpected end-of-input: expected: expected close marker for OBJECT quando tenti di interrogare la tabella dopo averla JsonParseException creata. Per ulteriori informazioni, consulta [JSON Data Files](https://github.com/rcongiu/Hive-JSON-Serde#json-data-files) nella documentazione di SerDe OpenX su. GitHub
1. Eseguire la query nella console Athena per registrare la tabella `gd_logs`. Al termine della query, i risultati sono pronti per le query da Athena.
## Query di esempio
Gli esempi seguenti mostrano come interrogare GuardDuty i risultati di Athena.
**Example Estrazione dei dati DNS**
La seguente query restituisce informazioni sulle EC2 istanze Amazon che potrebbero esfiltrare dati tramite query DNS.
```
SELECT
title,
severity,
type,
id AS FindingID,
accountid,
region,
createdat,
updatedat,
json_extract_scalar(service, '$.count') AS Count,
json_extract_scalar(resource, '$.instancedetails.instanceid') AS InstanceID,
json_extract_scalar(service, '$.action.actiontype') AS DNS_ActionType,
json_extract_scalar(service, '$.action.dnsrequestaction.domain') AS DomainName,
json_extract_scalar(service, '$.action.dnsrequestaction.protocol') AS protocol,
json_extract_scalar(service, '$.action.dnsrequestaction.blocked') AS blocked
FROM gd_logs
WHERE type = 'Trojan:EC2/DNSDataExfiltration'
ORDER BY severity DESC
```
**Example - Accesso utente IAM non autorizzato**
La query seguente restituisce tutti i tipi di esiti `UnauthorizedAccess:IAMUser` per un'entità principale IAM da tutte le Regioni.
```
SELECT title,
severity,
type,
id,
accountid,
region,
createdat,
updatedat,
json_extract_scalar(service, '$.count') AS Count,
json_extract_scalar(resource, '$.accesskeydetails.username') AS IAMPrincipal,
json_extract_scalar(service,'$.action.awsapicallaction.api') AS APIActionCalled
FROM gd_logs
WHERE type LIKE '%UnauthorizedAccess:IAMUser%'
ORDER BY severity desc;
```
## GuardDuty Suggerimenti per interrogare i risultati
Quando si crea la query, tenere a mente i seguenti punti.
+ Per estrarre dati dai campi JSON nidificati, utilizzare le funzioni `json_extract` o `json_extract_scalar` di Presto. Per ulteriori informazioni, consulta [Estrarre dati JSON da stringhe](extracting-data-from-JSON.md).
+ Assicurarsi che tutti i caratteri nei campi JSON siano in minuscolo.
+ Per informazioni sul download dei risultati delle query, consulta [Download dei file dei risultati delle query mediante la console Athena](saving-query-results.md).
# AWS Network Firewall Registri delle interrogazioni
AWS Network Firewall è un servizio gestito che puoi utilizzare per implementare protezioni di rete essenziali per le tue istanze di Amazon Virtual Private Cloud. AWS Network Firewall collabora con te AWS Firewall Manager in modo da poter creare politiche basate su AWS Network Firewall regole e poi applicarle centralmente a tutti i tuoi VPCs account. Per ulteriori informazioni su AWS Network Firewall, consulta [AWS Network Firewall](https://aws.amazon.com/network-firewall/).
È possibile configurare AWS Network Firewall la registrazione del traffico da inoltrare al motore stateful rules del firewall. I log forniscono informazioni dettagliate sul traffico di rete, tra cui l'ora in cui il motore con stato ha ricevuto un pacchetto, informazioni dettagliate sul pacchetto e qualsiasi operazione di regola con stato eseguita rispetto al pacchetto. I log vengono pubblicati nella destinazione di log configurata, dove è possibile recuperarli e visualizzarli. Per ulteriori informazioni, consulta [Registrazione del traffico di rete da AWS Network Firewall](https://docs.aws.amazon.com/network-firewall/latest/developerguide/firewall-logging.html)nella *Guida per gli sviluppatori di AWS Network Firewall *.
**Topics**
+ [Creare ed eseguire query in una tabella per i log di avvisi](querying-network-firewall-logs-sample-alert-logs-table.md)
+ [Creare ed eseguire query in una tabella per i log di netflow](querying-network-firewall-logs-sample-netflow-logs-table.md)
# Creare ed eseguire query in una tabella per i log di avvisi
1. Modificare la seguente istruzione DDL di esempio in modo che sia conforme alla struttura del log di avvisi. Potrebbe essere necessario aggiornare l'istruzione per includere le colonne per la versione più recente dei log. Per ulteriori informazioni, consulta [Contenuti di un log firewall](https://docs.aws.amazon.com/network-firewall/latest/developerguide/firewall-logging.html#firewall-logging-contents) nella *Guida per gli sviluppatori di AWS Network Firewall *.
```
CREATE EXTERNAL TABLE network_firewall_alert_logs (
firewall_name string,
availability_zone string,
event_timestamp string,
event struct<
timestamp:string,
flow_id:bigint,
event_type:string,
src_ip:string,
src_port:int,
dest_ip:string,
dest_port:int,
proto:string,
app_proto:string,
sni:string,
tls_inspected:boolean,
tls_error:struct<
error_message:string>,
revocation_check:struct<
leaf_cert_fpr:string,
status:string,
action:string>,
alert:struct<
alert_id:string,
alert_type:string,
action:string,
signature_id:int,
rev:int,
signature:string,
category:string,
severity:int,
rule_name:string,
alert_name:string,
alert_severity:string,
alert_description:string,
file_name:string,
file_hash:string,
packet_capture:string,
reference_links:array
>,
src_country:string,
dest_country:string,
src_hostname:string,
dest_hostname:string,
user_agent:string,
url:string
>
)
ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe'
LOCATION 's3://amzn-s3-demo-bucket/path_to_alert_logs_folder/';
```
1. Modificare la frase `LOCATION` per specificare la cartella per i log in Amazon S3.
1. Eseguire la query `CREATE TABLE` nell’editor di query Athena. Una volta completata la query, Athena registra la tabella `network_firewall_alert_logs`, rendendo i dati in essa contenuti pronti per le query.
## Query di esempio
L’esempio di query del log degli avvisi in questa sezione filtra gli eventi in cui è stata eseguita l’ispezione TLS che presentano avvisi con un livello di gravità pari o superiore a 2.
La query utilizza alias per creare intestazioni di colonna di output che mostrano a cosa appartiene la colonna `struct`. Ad esempio, l’intestazione di colonna del campo `event.alert.category` è `event_alert_category` invece di una semplice `category`. Per personalizzare ulteriormente i nomi delle colonne, è possibile modificare gli alias in base alle proprie preferenze. Ad esempio, è possibile utilizzare caratteri di sottolineatura o altri separatori per delimitare i nomi `struct` e i nomi dei campi.
Ricordarsi di modificare i nomi e i riferimenti `struct` delle colonne in base alla definizione della tabella e ai campi che si desidera inserire nel risultato della query.
```
SELECT
firewall_name,
availability_zone,
event_timestamp,
event.timestamp AS event_timestamp,
event.flow_id AS event_flow_id,
event.event_type AS event_type,
event.src_ip AS event_src_ip,
event.src_port AS event_src_port,
event.dest_ip AS event_dest_ip,
event.dest_port AS event_dest_port,
event.proto AS event_protol,
event.app_proto AS event_app_proto,
event.sni AS event_sni,
event.tls_inspected AS event_tls_inspected,
event.tls_error.error_message AS event_tls_error_message,
event.revocation_check.leaf_cert_fpr AS event_revocation_leaf_cert,
event.revocation_check.status AS event_revocation_check_status,
event.revocation_check.action AS event_revocation_check_action,
event.alert.alert_id AS event_alert_alert_id,
event.alert.alert_type AS event_alert_alert_type,
event.alert.action AS event_alert_action,
event.alert.signature_id AS event_alert_signature_id,
event.alert.rev AS event_alert_rev,
event.alert.signature AS event_alert_signature,
event.alert.category AS event_alert_category,
event.alert.severity AS event_alert_severity,
event.alert.rule_name AS event_alert_rule_name,
event.alert.alert_name AS event_alert_alert_name,
event.alert.alert_severity AS event_alert_alert_severity,
event.alert.alert_description AS event_alert_alert_description,
event.alert.file_name AS event_alert_file_name,
event.alert.file_hash AS event_alert_file_hash,
event.alert.packet_capture AS event_alert_packet_capture,
event.alert.reference_links AS event_alert_reference_links,
event.src_country AS event_src_country,
event.dest_country AS event_dest_country,
event.src_hostname AS event_src_hostname,
event.dest_hostname AS event_dest_hostname,
event.user_agent AS event_user_agent,
event.url AS event_url
FROM
network_firewall_alert_logs
WHERE
event.alert.severity >= 2
AND event.tls_inspected = true
LIMIT 10;
```
# Creare ed eseguire query in una tabella per i log di netflow
1. Modificare la seguente istruzione DDL di esempio per renderla conforme alla struttura dei log di netflow. Potrebbe essere necessario aggiornare l'istruzione per includere le colonne per la versione più recente dei log. Per ulteriori informazioni, consulta [Contenuti di un log firewall](https://docs.aws.amazon.com/network-firewall/latest/developerguide/firewall-logging.html#firewall-logging-contents) nella *Guida per gli sviluppatori di AWS Network Firewall *.
```
CREATE EXTERNAL TABLE network_firewall_netflow_logs (
firewall_name string,
availability_zone string,
event_timestamp string,
event struct<
timestamp:string,
flow_id:bigint,
event_type:string,
src_ip:string,
src_port:int,
dest_ip:string,
dest_port:int,
proto:string,
app_proto:string,
tls_inspected:boolean,
netflow:struct<
pkts:int,
bytes:bigint,
start:string,
`end`:string,
age:int,
min_ttl:int,
max_ttl:int,
tcp_flags:struct<
syn:boolean,
fin:boolean,
rst:boolean,
psh:boolean,
ack:boolean,
urg:boolean
>
>
>
)
ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe'
LOCATION 's3://amzn-s3-demo-bucket/path_to_netflow_logs_folder/';
```
1. Modificare la frase `LOCATION` per specificare la cartella per i log in Amazon S3.
1. Eseguire la query `CREATE TABLE` nell’editor di query della console Athena. Una volta completata la query, Athena registra la tabella `network_firewall_netflow_logs`, rendendo i dati in essa contenuti pronti per le query.
## Query di esempio
La query di log netflow di esempio in questa sezione filtra gli eventi in cui è stata eseguita l’ispezione TLS.
La query utilizza alias per creare intestazioni di colonna di output che mostrano l’appartenenza della colonna `struct`. Ad esempio, l’intestazione di colonna del campo `event.netflow.bytes` è `event_netflow_bytes` invece di una semplice `bytes`. Per personalizzare ulteriormente i nomi delle colonne, è possibile modificare gli alias in base alle proprie preferenze. Ad esempio, è possibile utilizzare caratteri di sottolineatura o altri separatori per delimitare i nomi `struct` e i nomi dei campi.
Ricordarsi di modificare i nomi e i riferimenti `struct` delle colonne in base alla definizione della tabella e ai campi che si desidera inserire nel risultato della query.
```
SELECT
event.src_ip AS event_src_ip,
event.dest_ip AS event_dest_ip,
event.proto AS event_proto,
event.app_proto AS event_app_proto,
event.tls_inspected AS event_tls_inspected,
event.netflow.pkts AS event_netflow_pkts,
event.netflow.bytes AS event_netflow_bytes,
event.netflow.tcp_flags.syn AS event_netflow_tcp_flags_syn
FROM network_firewall_netflow_logs
WHERE event.tls_inspected = true
```
# Eseguire query sui log di Network Load Balancer
Utilizzare Athena per analizzare ed elaborare i log di Network Load Balancer. Questi log ricevono informazioni dettagliate sulle richieste Transport Layer Security (TLS) inviate al Network Load Balancer. Puoi utilizzare questi log per analizzare i modelli di traffico e risolvere i problemi che potresti incontrare.
Prima di analizzare i log di accesso di Network Load Balancer, abilitarli e configurali affinché siano salvati nel bucket Amazon S3 di destinazione. Per ulteriori informazioni e per informazioni su ogni voce del log di accesso a Network Load Balancer, consulta [Log di accesso al Network Load Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-access-logs.html).
**Per creare la tabella per i log di Network Load Balancer**
1. Copiare e incollare la seguente istruzione DDL nella console Athena. Controlla la [sintassi ](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-access-logs.html#access-log-file-format)dei record di log di Network Load Balancer. Aggiornare l’istruzione come richiesto per includere le colonne e l’espressione regolare corrispondenti ai propri record di log.
```
CREATE EXTERNAL TABLE IF NOT EXISTS nlb_tls_logs (
type string,
version string,
time string,
elb string,
listener_id string,
client_ip string,
client_port int,
target_ip string,
target_port int,
tcp_connection_time_ms double,
tls_handshake_time_ms double,
received_bytes bigint,
sent_bytes bigint,
incoming_tls_alert int,
cert_arn string,
certificate_serial string,
tls_cipher_suite string,
tls_protocol_version string,
tls_named_group string,
domain_name string,
alpn_fe_protocol string,
alpn_be_protocol string,
alpn_client_preference_list string,
tls_connection_creation_time string
)
ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.RegexSerDe'
WITH SERDEPROPERTIES (
'serialization.format' = '1',
'input.regex' =
'([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*):([0-9]*) ([^ ]*):([0-9]*) ([-.0-9]*) ([-.0-9]*) ([-0-9]*) ([-0-9]*) ([-0-9]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ?([^ ]*)?( .*)?'
)
LOCATION 's3://amzn-s3-demo-bucket/AWSLogs/AWS_account_ID/elasticloadbalancing/region';
```
1. Modifica il bucket Amazon S3 `LOCATION` per specificare la destinazione dei tuoi log di Network Load Balancer.
1. Eseguire la query nella console Athena. Una volta completata la query, Athena registra la tabella `nlb_tls_logs`, rendendo i dati in essa contenuti pronti per le query.
## Query di esempio
Per vedere quante volte viene utilizzato un certificato, utilizzare una query simile a questo esempio:
```
SELECT count(*) AS
ct,
cert_arn
FROM "nlb_tls_logs"
GROUP BY cert_arn;
```
La query seguente mostra come molti utenti utilizzano una versione di TLS precedente alla 1.3:
```
SELECT tls_protocol_version,
COUNT(tls_protocol_version) AS
num_connections,
client_ip
FROM "nlb_tls_logs"
WHERE tls_protocol_version < 'tlsv13'
GROUP BY tls_protocol_version, client_ip;
```
Utilizzare la seguente query per identificare le connessioni che richiedono un tempo di handshake TLS lungo:
```
SELECT *
FROM "nlb_tls_logs"
ORDER BY tls_handshake_time_ms DESC
LIMIT 10;
```
Utilizzare la seguente query per identificare e contare quali versioni del protocollo TLS e suite di cifratura sono state negoziate negli ultimi 30 giorni.
```
SELECT tls_cipher_suite,
tls_protocol_version,
COUNT(*) AS ct
FROM "nlb_tls_logs"
WHERE from_iso8601_timestamp(time) > current_timestamp - interval '30' day
AND NOT tls_protocol_version = '-'
GROUP BY tls_cipher_suite, tls_protocol_version
ORDER BY ct DESC;
```
# Esguire query sui log di Amazon Route 53 Resolver
Puoi creare tabelle Athena per i log delle query di Amazon Route 53 Resolver ed eseguire query da Athena.
I log delle query del Route 53 Resolver consentono la registrazione delle query DNS eseguite da risorse all'interno di risorse VPC on-premise che utilizzano endpoint Resolver in ingresso, query che utilizzano un endpoint Resolver in uscita per la risoluzione DNS ricorsiva e query che utilizzano regole del firewall DNS di Route 53 Resolver Route per bloccare, consentire o monitorare un elenco di domini. Per ulteriori informazioni, consulta [Log delle query Resolver](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/resolver-query-logs.html) nella *Guida per sviluppatori di Amazon Route 53*. Per informazioni su ciascuno dei campi nei log, consulta [Valori visualizzati nei log di query di Resolver](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/resolver-query-logs-format.html) nella *Guida per sviluppatori di Amazon Route 53*.
**Topics**
+ [Creare la tabella per i log di query di Resolver](querying-r53-resolver-logs-creating-the-table.md)
+ [Utilizzo della proiezione di partizioni](querying-r53-resolver-logs-partitioning-example.md)
+ [Query di esempio](querying-r53-resolver-logs-example-queries.md)
# Creare la tabella per i log di query di Resolver
È possibile utilizzare l'editor di query nella console Athena per creare e interrogare una tabella per i log delle query di Route 53 Resolver.
**Per creare ed eseguire query su una tabella Athena per i log delle query di Route 53 Resolver**
1. Apri la console Athena all'indirizzo [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Nell'editor di query Athena, inserire la seguente istruzione `CREATE TABLE`. Sostituire i valori della clausola `LOCATION` con quelli corrispondenti alla posizione dei log di Resolver nel bucket Amazon S3.
```
CREATE EXTERNAL TABLE r53_rlogs (
version string,
account_id string,
region string,
vpc_id string,
query_timestamp string,
query_name string,
query_type string,
query_class
string,
rcode string,
answers array<
struct<
Rdata: string,
Type: string,
Class: string>
>,
srcaddr string,
srcport int,
transport string,
srcids struct<
instance: string,
resolver_endpoint: string
>,
firewall_rule_action string,
firewall_rule_group_id string,
firewall_domain_list_id string
)
ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe'
LOCATION 's3://amzn-s3-demo-bucket/AWSLogs/aws_account_id/vpcdnsquerylogs/{vpc-id}/'
```
Poiché i dati del registro delle query di Resolver sono in formato JSON, l'istruzione CREATE TABLE utilizza una [ SerDelibreria JSON](json-serde.md) per analizzare i dati.
**Nota**
SerDe Si aspetta che ogni documento JSON si trovi su una singola riga di testo senza caratteri di terminazione di riga che separano i campi del record. Se il testo JSON è in un bel formato di stampa, potresti ricevere un messaggio di errore come HIVE\$1CURSOR\$1ERROR: Row is not a valid JSON Object o HIVE\$1CURSOR\$1ERROR:: Unexpected end-of-input: expected: expected close marker for OBJECT quando tenti di interrogare la tabella dopo averla JsonParseException creata. Per ulteriori informazioni, consulta [JSON Data Files](https://github.com/rcongiu/Hive-JSON-Serde#json-data-files) nella documentazione di SerDe OpenX su. GitHub
1. Scegli **Esegui query**. L'istruzione crea una tabella Athena denominata `r53_rlogs` le cui colonne rappresentano ciascuno dei campi nei dati dei log di Resolver.
1. Nell'editor di query della console Athena, eseguire la seguente query per verificare che la tabella sia stata creata.
```
SELECT * FROM "r53_rlogs" LIMIT 10
```
# Utilizzo della proiezione di partizioni
L'esempio seguente mostra una dichiarazione `CREATE TABLE` per i log delle query di Resolver che utilizza la proiezione delle partizioni ed è partizionata per vpc e per data. Per maggiori informazioni sulla proiezione delle partizioni, consulta [Proiezione delle partizioni con Amazon Athena](partition-projection.md).
```
CREATE EXTERNAL TABLE r53_rlogs (
version string,
account_id string,
region string,
vpc_id string,
query_timestamp string,
query_name string,
query_type string,
query_class string,
rcode string,
answers array<
struct<
Rdata: string,
Type: string,
Class: string>
>,
srcaddr string,
srcport int,
transport string,
srcids struct<
instance: string,
resolver_endpoint: string
>,
firewall_rule_action string,
firewall_rule_group_id string,
firewall_domain_list_id string
)
PARTITIONED BY (
`date` string,
`vpc` string
)
ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe'
STORED AS INPUTFORMAT 'org.apache.hadoop.mapred.TextInputFormat'
OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION 's3://amzn-s3-demo-bucket/route53-query-logging/AWSLogs/aws_account_id/vpcdnsquerylogs/'
TBLPROPERTIES(
'projection.enabled' = 'true',
'projection.vpc.type' = 'enum',
'projection.vpc.values' = 'vpc-6446ae02',
'projection.date.type' = 'date',
'projection.date.range' = '2023/06/26,NOW',
'projection.date.format' = 'yyyy/MM/dd',
'projection.date.interval' = '1',
'projection.date.interval.unit' = 'DAYS',
'storage.location.template' = 's3://amzn-s3-demo-bucket/route53-query-logging/AWSLogs/aws_account_id/vpcdnsquerylogs/${vpc}/${date}/'
)
```
# Query di esempio
Gli esempi seguenti mostrano alcune query che è possibile eseguire da Athena nei log delle query di Resolver.
## Esempio 1: log di query in ordine query\$1timestamp decrescente
La query seguente visualizza i risultati del log in ordine `query_timestamp` decrescente.
```
SELECT * FROM "r53_rlogs"
ORDER BY query_timestamp DESC
```
## Esempio 2: log di query all'interno dell'ora di inizio e di fine specificata
Le query riportate di seguito registrano log tra mezzanotte e le 8 del 24 settembre 2020. Sostituisci l'ora di inizio e di fine secondo le tue esigenze.
```
SELECT query_timestamp, srcids.instance, srcaddr, srcport, query_name, rcode
FROM "r53_rlogs"
WHERE (parse_datetime(query_timestamp,'yyyy-MM-dd''T''HH:mm:ss''Z')
BETWEEN parse_datetime('2020-09-24-00:00:00','yyyy-MM-dd-HH:mm:ss')
AND parse_datetime('2020-09-24-00:08:00','yyyy-MM-dd-HH:mm:ss'))
ORDER BY query_timestamp DESC
```
## Esempio 3: log di query basati su un modello di nome query DNS specificato
La query seguente seleziona i registri il cui nome della query include la stringa "example.com".
```
SELECT query_timestamp, srcids.instance, srcaddr, srcport, query_name, rcode, answers
FROM "r53_rlogs"
WHERE query_name LIKE '%example.com%'
ORDER BY query_timestamp DESC
```
## Esempio 4: richieste di log di query senza risposta
La query seguente seleziona le voci di log in cui la richiesta non ha ricevuto risposta.
```
SELECT query_timestamp, srcids.instance, srcaddr, srcport, query_name, rcode, answers
FROM "r53_rlogs"
WHERE cardinality(answers) = 0
```
## Esempio 5: log di query con una risposta specifica
La query seguente mostra i log in cui il valore `answer.Rdata` ha l'indirizzo IP specificato.
```
SELECT query_timestamp, srcids.instance, srcaddr, srcport, query_name, rcode, answer.Rdata
FROM "r53_rlogs"
CROSS JOIN UNNEST(r53_rlogs.answers) as st(answer)
WHERE answer.Rdata='203.0.113.16';
```
# Eseguire query sui log di eventi in Amazon SES
Puoi utilizzare Amazon Athena per eseguire query sui registri eventi di [Servizio di e-mail semplice Amazon (Amazon SES)](https://aws.amazon.com/ses/).
Amazon SES è una piattaforma e-mail che offre un metodo comodo e conveniente per inviare e ricevere e-mail usando domini e indirizzi e-mail personali. Puoi monitorare le attività di invio di Amazon SES a un livello granulare utilizzando eventi, parametri e statistiche.
In base alle caratteristiche che definisci, puoi pubblicare eventi Amazon SES su Amazon CloudWatch, [Amazon](https://aws.amazon.com/cloudwatch/) [Data Firehose](https://aws.amazon.com/kinesis/data-firehose/) o Amazon [Simple Notification Service](https://aws.amazon.com/sns/). Dopo aver archiviato le informazioni in Amazon S3, è possibile eseguire query su Amazon Athena.
Per un esempio di `CREATE TABLE` istruzione Athena per i log di Amazon SES, che include i passaggi su come creare viste e appiattire gli array annidati nei dati dei log degli eventi di Amazon SES, consulta «Fase 3: Utilizzo di Amazon Athena per interrogare i log degli eventi SES» nel post del AWS blog [Analyzing](https://aws.amazon.com/blogs/messaging-and-targeting/analyzing-amazon-ses-event-data-with-aws-analytics-services/) Amazon SES Event Data with Analytics Services. AWS
# Eseguire query sui log di flusso Amazon VPC
I flussi di log Amazon Virtual Private Cloud acquisiscono informazioni sul traffico IP da e verso le interfacce di rete in un VPC. Utilizza i log per analizzare i modelli di traffico di rete e identificare le minacce e i rischi nella rete VPC.
Per eseguire query nel flusso di log di Amazon VPC, sono disponibili due opzioni:
****
+ Console **Amazon VPC: utilizza la funzionalità di integrazione Athena nella console** Amazon VPC per generare un modello CloudFormation che crei un database Athena, un gruppo di lavoro e una tabella di log di flusso con partizionamento per te. Il modello crea inoltre un set di [query di flusso di log predefinite](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs-athena.html#predefined-queries) che può essere utilizzato per ottenere informazioni dettagliate sul traffico in transito attraverso il VPC.
Per ulteriori informazioni su questo approccio, consulta [Eseguire una query dei flussi di log tramite Amazon Athena](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs-athena.html) nella *Guida per l'utente di Amazon VPC*.
+ **Console Amazon Athena**: crea le tabelle e le query direttamente nella console Athena. Per maggiori informazioni, continua a leggere questa pagina.
Prima di iniziare a eseguire query sui log in Athena, [abilita i log di flusso VPC](https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/flow-logs.html) e configurali in modo che possano essere salvati nel bucket Amazon S3. Dopo aver creato i log, lasciali in esecuzione per qualche minuto per raccogliere alcuni dati. I log vengono creati in un formato di compressione GZIP su cui Athena consente di eseguire query direttamente.
Durante la creazione di un log di flusso, puoi utilizzare un formato personalizzato quando vuoi specificare quali campi restituire nel log di flusso e l'ordine in cui visualizzarli. Per ulteriori informazioni sui record dei log di flusso, consulta [Record log di flusso](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html#flow-log-records) nella *Guida per l'utente di Amazon VPC*.
## Considerazioni e limitazioni
Quando si creano tabelle nei flussi di log di Athena per Amazon VPC, tenere in considerazione i seguenti punti:
+ Per impostazione predefinita, in Athena, Parquet accederà alle colonne in base al nome. Per ulteriori informazioni, consulta [Gestire gli aggiornamenti degli schemi](handling-schema-updates-chapter.md).
+ Utilizzare i nomi nei record del flusso di log per i nomi delle colonne in Athena. I nomi delle colonne nello schema Athena devono corrispondere esattamente ai nomi dei campi nel flusso di log Amazon VPC, con le seguenti differenze:
+ Sostituire i trattini nei nomi dei campi di log di Amazon VPC con i caratteri di sottolineatura nei nomi delle colonne Athena. Per informazioni sui caratteri consentiti per i nomi di database, tabelle e colonne in Athena, consultare [Nomi di tabelle, database e colonne](tables-databases-columns-names.md).
+ Escludere i nomi dei registri del flusso di log che rappresentano in Athena [parole chiave riservate](reserved-words.md), racchiudendoli tra apici retroversi (`).
+ I log di flusso VPC sono specifici. Account AWS Quando pubblichi i tuoi file di log su Amazon S3, il percorso creato da Amazon VPC in Amazon S3 include l'ID dell' Account AWS che è stato utilizzato per crearli. Per ulteriori informazioni, consulta la sezione relativa alla [pubblicazione di registri di flusso in Amazon S3](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs-s3.html) nella *Guida per l'utente di Amazon VPC*.
**Topics**
+ [Considerazioni e limitazioni](#vpc-flow-logs-common-considerations)
+ [Creare una tabella per il flusso di log di Amazon VPC ed eseguire query nella stessa](vpc-flow-logs-create-table-statement.md)
+ [Creare tabelle per il flusso di log in formato Apache Parquet](vpc-flow-logs-parquet.md)
+ [Creare ed eseguire query su una tabella per il flusso di log di Amazon VPC tramite la proiezione delle partizioni](vpc-flow-logs-partition-projection.md)
+ [Creare tabelle per il flusso di log in formato Apache Parquet usando la proiezione di partizione](vpc-flow-logs-partition-projection-parquet-example.md)
+ [Risorse aggiuntive](query-examples-vpc-logs-additional-resources.md)
# Creare una tabella per il flusso di log di Amazon VPC ed eseguire query nella stessa
La procedura seguente consente di creare una tabella Amazon VPC per il flusso di log di Amazon VPC. Quando crei un log di flusso con un formato personalizzato, crea una tabella con campi che corrispondano a quelli specificati durante la creazione del log di flusso, nello stesso ordine in cui li hai specificati.
**Per creare una tabella Athena per il flusso di log di Amazon VPC**
1. Inserire un'istruzione DDL come la seguente nell'editor di query della console Athena, seguendo le linee guida riportate nella sezione [Considerazioni e limitazioni](vpc-flow-logs.md#vpc-flow-logs-common-considerations). L'istruzione di esempio crea una tabella con le colonne per il flusso di log di Amazon VPC, versioni da 2 a 5, come documentato in [Registri del flusso di log](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html#flow-log-records). Se si utilizza un set di colonne o un ordine di colonne diverso, modificare questa istruzione di conseguenza.
```
CREATE EXTERNAL TABLE IF NOT EXISTS `vpc_flow_logs` (
version int,
account_id string,
interface_id string,
srcaddr string,
dstaddr string,
srcport int,
dstport int,
protocol bigint,
packets bigint,
bytes bigint,
start bigint,
`end` bigint,
action string,
log_status string,
vpc_id string,
subnet_id string,
instance_id string,
tcp_flags int,
type string,
pkt_srcaddr string,
pkt_dstaddr string,
region string,
az_id string,
sublocation_type string,
sublocation_id string,
pkt_src_aws_service string,
pkt_dst_aws_service string,
flow_direction string,
traffic_path int
)
PARTITIONED BY (`date` date)
ROW FORMAT DELIMITED
FIELDS TERMINATED BY ' '
LOCATION 's3://amzn-s3-demo-bucket/prefix/AWSLogs/{account_id}/vpcflowlogs/{region_code}/'
TBLPROPERTIES ("skip.header.line.count"="1");
```
Notare i seguenti punti:
+ La query specifica `ROW FORMAT DELIMITED` e omette di specificare un. SerDe Ciò significa che la query utilizza il metodo [Lazy SerDe Simple per file CSV, TSV e delimitati in modo personalizzato](lazy-simple-serde.md). In questa query, i campi terminano con uno spazio.
+ La clausola `PARTITIONED BY` utilizza il tipo `date`. In questo modo è possibile utilizzare operatori matematici nelle query per selezionare ciò che è più vecchio o più recente rispetto a una determinata data.
**Nota**
Poiché `date` è una parola chiave riservata nelle istruzioni DDL, questa viene preceduta da caratteri di apice inverso. Per ulteriori informazioni, consulta [Impostare il carattere escape di parole chiave riservate nelle query](reserved-words.md).
+ Per un log di flusso VPC con un formato personalizzato diverso, modifica i campi in modo che corrispondano a quelli specificati durante la creazione del log di flusso.
1. Modificare `LOCATION 's3://amzn-s3-demo-bucket/prefix/AWSLogs/{account_id}/vpcflowlogs/{region_code}/'` perché punti al bucket Amazon S3 che contiene i dati di log.
1. Eseguire la query nella console Athena. Una volta completata la query, Athena registra la tabella `vpc_flow_logs`, rendendo i dati in essa contenuti pronti per l'esecuzione di query.
1. Creare partizioni per poter leggere i dati, come nella seguente query di esempio. Questa query crea una singola partizione per una data specificata. Sostituire i segnaposto per data e posizione in base alle esigenze.
**Nota**
Questa query crea unicamente una singola partizione, per la data specificata. Per automatizzare il processo, utilizzare uno script che esegue questa query e crea partizioni in questo modo per `year/month/day` oppure utilizzare un'istruzione `CREATE TABLE` che specifica la [proiezione delle partizioni](vpc-flow-logs-partition-projection.md).
```
ALTER TABLE vpc_flow_logs
ADD PARTITION (`date`='YYYY-MM-dd')
LOCATION 's3://amzn-s3-demo-bucket/prefix/AWSLogs/{account_id}/vpcflowlogs/{region_code}/YYYY/MM/dd';
```
## Query di esempio per la tabella vpc\$1flow\$1logs
Utilizzare l'editor di query nella console Athena per eseguire istruzioni SQL sulla tabella creata. È possibile salvare le query, visualizzare le query precedenti o scaricare i risultati delle query in formato CSV. Negli esempi seguenti, sostituire `vpc_flow_logs` con il nome della tabella. Modificare i valori delle colonne e altre variabili in base alle proprie esigenze.
La query di esempio seguente elenca un massimo di 100 log di flusso per la data specificata.
```
SELECT *
FROM vpc_flow_logs
WHERE date = DATE('2020-05-04')
LIMIT 100;
```
La query seguente elenca tutte le connessioni TCP rifiutate e utilizza la colonna di partizione della data appena creata, `date`, per estrarne il giorno della settimana in cui si verificano questi eventi.
```
SELECT day_of_week(date) AS
day,
date,
interface_id,
srcaddr,
action,
protocol
FROM vpc_flow_logs
WHERE action = 'REJECT' AND protocol = 6
LIMIT 100;
```
Per vedere quale server riceve il numero più elevato di richieste HTTPS, utilizzare la seguente query. Conta il numero di pacchetti ricevuti sulla porta HTTPS 443, li raggruppa in base all'indirizzo IP di destinazione e restituisce i primi 10.
```
SELECT SUM(packets) AS
packetcount,
dstaddr
FROM vpc_flow_logs
WHERE dstport = 443 AND date > current_date - interval '7' day
GROUP BY dstaddr
ORDER BY packetcount DESC
LIMIT 10;
```
# Creare tabelle per il flusso di log in formato Apache Parquet
La procedura seguente consente di creare una tabella Amazon VPC per il flusso di log di Amazon VPC in formato Apache Parquet.
**Per creare una tabella Athena per il flusso di log di Amazon VPC in formato Parquet**
1. Inserire un'istruzione DDL come la seguente nell'editor di query della console Athena, seguendo le linee guida riportate nella sezione [Considerazioni e limitazioni](vpc-flow-logs.md#vpc-flow-logs-common-considerations). L'istruzione di esempio crea una tabella con le colonne per il flusso di log di Amazon VPC, versioni da 2 a 5, come documentato in [Registri del flusso di log](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs.html#flow-log-records) in formato Parquet, partizionato con Hive ogni ora. Se non disponi di partizioni orarie, rimuovi `hour` dalla clausola `PARTITIONED BY`.
```
CREATE EXTERNAL TABLE IF NOT EXISTS vpc_flow_logs_parquet (
version int,
account_id string,
interface_id string,
srcaddr string,
dstaddr string,
srcport int,
dstport int,
protocol bigint,
packets bigint,
bytes bigint,
start bigint,
`end` bigint,
action string,
log_status string,
vpc_id string,
subnet_id string,
instance_id string,
tcp_flags int,
type string,
pkt_srcaddr string,
pkt_dstaddr string,
region string,
az_id string,
sublocation_type string,
sublocation_id string,
pkt_src_aws_service string,
pkt_dst_aws_service string,
flow_direction string,
traffic_path int
)
PARTITIONED BY (
`aws-account-id` string,
`aws-service` string,
`aws-region` string,
`year` string,
`month` string,
`day` string,
`hour` string
)
ROW FORMAT SERDE
'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe'
STORED AS INPUTFORMAT
'org.apache.hadoop.hive.ql.io.parquet.MapredParquetInputFormat'
OUTPUTFORMAT
'org.apache.hadoop.hive.ql.io.parquet.MapredParquetOutputFormat'
LOCATION
's3://amzn-s3-demo-bucket/prefix/AWSLogs/'
TBLPROPERTIES (
'EXTERNAL'='true',
'skip.header.line.count'='1'
)
```
1. Modificare `LOCATION 's3://amzn-s3-demo-bucket/prefix/AWSLogs/'` perché punti al bucket Amazon S3 che contiene i dati di log.
1. Eseguire la query nella console Athena.
1. Se i dati sono in formato compatibile con Hive, esegui il seguente comando nella console Athena per aggiornare e caricare le partizioni Hive nel metastore. Una volta completata la query, è possibile eseguire query sui dati nella tabella `vpc_flow_logs_parquet`.
```
MSCK REPAIR TABLE vpc_flow_logs_parquet
```
Se non utilizzi dati compatibili con Hive, esegui [ALTER TABLE ADD PARTITION](alter-table-add-partition.md) per caricare le partizioni.
Per ulteriori informazioni sull'utilizzo di Athena per eseguire query sul log di flusso di Amazon VPC in formato Parquet, consulta il post [Optimize performance and reduce costs for network analytics with VPC Flow Logs in Apache Parquet format](https://aws.amazon.com/blogs/big-data/optimize-performance-and-reduce-costs-for-network-analytics-with-vpc-flow-logs-in-apache-parquet-format/) nell'*AWS Big Data Blog*.
# Creare ed eseguire query su una tabella per il flusso di log di Amazon VPC tramite la proiezione delle partizioni
Utilizzare una istruzione `CREATE TABLE` come la seguente per creare una tabella, partizionarla e popolare automaticamente le partizioni utilizzando la [proiezione delle partizioni](partition-projection.md). Sostituire il nome della tabella `test_table_vpclogs` nell'esempio con il nome della propria tabella. Modificare la clausola `LOCATION` per specificare il bucket Amazon S3 che contiene i dati di log di Amazon VPC.
La seguente istruzione `CREATE TABLE` è per il flusso di log VPC fornito in formato di partizionamento in stile non Hive. L'esempio consente l'aggregazione di più account. Se stai centralizzando i log di flusso VPC da più account in un bucket Amazon S3, l'ID dell'account deve essere inserito nel percorso Amazon S3.
```
CREATE EXTERNAL TABLE IF NOT EXISTS test_table_vpclogs (
version int,
account_id string,
interface_id string,
srcaddr string,
dstaddr string,
srcport int,
dstport int,
protocol bigint,
packets bigint,
bytes bigint,
start bigint,
`end` bigint,
action string,
log_status string,
vpc_id string,
subnet_id string,
instance_id string,
tcp_flags int,
type string,
pkt_srcaddr string,
pkt_dstaddr string,
az_id string,
sublocation_type string,
sublocation_id string,
pkt_src_aws_service string,
pkt_dst_aws_service string,
flow_direction string,
traffic_path int
)
PARTITIONED BY (accid string, region string, day string)
ROW FORMAT DELIMITED
FIELDS TERMINATED BY ' '
LOCATION '$LOCATION_OF_LOGS'
TBLPROPERTIES
(
"skip.header.line.count"="1",
"projection.enabled" = "true",
"projection.accid.type" = "enum",
"projection.accid.values" = "$ACCID_1,$ACCID_2",
"projection.region.type" = "enum",
"projection.region.values" = "$REGION_1,$REGION_2,$REGION_3",
"projection.day.type" = "date",
"projection.day.range" = "$START_RANGE,NOW",
"projection.day.format" = "yyyy/MM/dd",
"storage.location.template" = "s3://amzn-s3-demo-bucket/AWSLogs/${accid}/vpcflowlogs/${region}/${day}"
)
```
## Query di esempio per test\$1table\$1vpclogs
Nelle seguenti query di esempio viene interrogata la `test_table_vpclogs` creata dall'istruzione `CREATE TABLE` precedente. Sostituire `test_table_vpclogs` nelle query con il nome della propria tabella. Modificare i valori delle colonne e altre variabili in base alle proprie esigenze.
Per restituire le prime 100 voci di log di accesso in ordine cronologico per un determinato periodo di tempo, eseguire una query come la seguente.
```
SELECT *
FROM test_table_vpclogs
WHERE day >= '2021/02/01' AND day < '2021/02/28'
ORDER BY day ASC
LIMIT 100
```
Per visualizzare quale server riceve i dieci pacchetti HTTP principali per un determinato periodo di tempo, eseguire una query come la seguente. La query conta il numero di pacchetti ricevuti sulla porta HTTPS 443, li raggruppa in base all'indirizzo IP di destinazione e restituisce le prime 10 voci principali dalla settimana precedente.
```
SELECT SUM(packets) AS packetcount,
dstaddr
FROM test_table_vpclogs
WHERE dstport = 443
AND day >= '2021/03/01'
AND day < '2021/03/31'
GROUP BY dstaddr
ORDER BY packetcount DESC
LIMIT 10
```
Per restituire i registri creati durante un determinato periodo di tempo, eseguire una query come la seguente.
```
SELECT interface_id,
srcaddr,
action,
protocol,
to_iso8601(from_unixtime(start)) AS start_time,
to_iso8601(from_unixtime("end")) AS end_time
FROM test_table_vpclogs
WHERE DAY >= '2021/04/01'
AND DAY < '2021/04/30'
```
Per restituire i registri di accesso per un indirizzo IP di origine tra i periodi di tempo specificati, eseguire una query come la seguente.
```
SELECT *
FROM test_table_vpclogs
WHERE srcaddr = '10.117.1.22'
AND day >= '2021/02/01'
AND day < '2021/02/28'
```
Per elencare le connessioni TCP rifiutate, eseguire una query come la seguente.
```
SELECT day,
interface_id,
srcaddr,
action,
protocol
FROM test_table_vpclogs
WHERE action = 'REJECT' AND protocol = 6 AND day >= '2021/02/01' AND day < '2021/02/28'
LIMIT 10
```
Per restituire i registri di accesso per l'intervallo di indirizzi IP che inizia con `10.117`, eseguire una query come la seguente.
```
SELECT *
FROM test_table_vpclogs
WHERE split_part(srcaddr,'.', 1)='10'
AND split_part(srcaddr,'.', 2) ='117'
```
Per restituire i registri di accesso per un indirizzo IP di destinazione tra i periodi di tempo specificati, eseguire una query come la seguente.
```
SELECT *
FROM test_table_vpclogs
WHERE dstaddr = '10.0.1.14'
AND day >= '2021/01/01'
AND day < '2021/01/31'
```
# Creare tabelle per il flusso di log in formato Apache Parquet usando la proiezione di partizione
La seguente istruzione di proiezione della partizione `CREATE TABLE` per i log di flusso VPC è in formato Apache Parquet, non è compatibile con Hive e partizionata per ora e per data anziché per giorno. Sostituire il nome della tabella `test_table_vpclogs_parquet` nell'esempio con il nome della propria tabella. Modificare la clausola `LOCATION` per specificare il bucket Amazon S3 che contiene i dati di log di Amazon VPC.
```
CREATE EXTERNAL TABLE IF NOT EXISTS test_table_vpclogs_parquet (
version int,
account_id string,
interface_id string,
srcaddr string,
dstaddr string,
srcport int,
dstport int,
protocol bigint,
packets bigint,
bytes bigint,
start bigint,
`end` bigint,
action string,
log_status string,
vpc_id string,
subnet_id string,
instance_id string,
tcp_flags int,
type string,
pkt_srcaddr string,
pkt_dstaddr string,
az_id string,
sublocation_type string,
sublocation_id string,
pkt_src_aws_service string,
pkt_dst_aws_service string,
flow_direction string,
traffic_path int
)
PARTITIONED BY (region string, date string, hour string)
ROW FORMAT SERDE
'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe'
STORED AS INPUTFORMAT
'org.apache.hadoop.hive.ql.io.parquet.MapredParquetInputFormat'
OUTPUTFORMAT
'org.apache.hadoop.hive.ql.io.parquet.MapredParquetOutputFormat'
LOCATION 's3://amzn-s3-demo-bucket/prefix/AWSLogs/{account_id}/vpcflowlogs/'
TBLPROPERTIES (
"EXTERNAL"="true",
"skip.header.line.count" = "1",
"projection.enabled" = "true",
"projection.region.type" = "enum",
"projection.region.values" = "us-east-1,us-west-2,ap-south-1,eu-west-1",
"projection.date.type" = "date",
"projection.date.range" = "2021/01/01,NOW",
"projection.date.format" = "yyyy/MM/dd",
"projection.hour.type" = "integer",
"projection.hour.range" = "00,23",
"projection.hour.digits" = "2",
"storage.location.template" = "s3://amzn-s3-demo-bucket/prefix/AWSLogs/${account_id}/vpcflowlogs/${region}/${date}/${hour}"
)
```
# Risorse aggiuntive
Per ulteriori informazioni sull'utilizzo di Athena per analizzare i log di flusso del VPC, consulta i seguenti articoli del blog sui big data AWS :
+ [Analizza i log di flusso VPC con l'integrazione con Amazon Athena point-and-click](https://aws.amazon.com/blogs/networking-and-content-delivery/analyze-vpc-flow-logs-with-point-and-click-amazon-athena-integration/)
+ [Analisi dei log di flusso VPC con Amazon Athena e Quick](https://aws.amazon.com/blogs/big-data/analyzing-vpc-flow-logs-using-amazon-athena-and-amazon-quicksight/)
+ [Optimize performance and reduce costs for network analytics with VPC Flow Logs in Apache Parquet format](https://aws.amazon.com/blogs/big-data/optimize-performance-and-reduce-costs-for-network-analytics-with-vpc-flow-logs-in-apache-parquet-format/) (Ottimizzazione delle prestazioni e riduzione dei costi per l'analisi di rete con i log di flusso VPC in formato Apache Parquet)
# AWS WAF Registri delle interrogazioni
AWS WAF è un firewall per applicazioni Web che consente di monitorare e controllare le richieste HTTP e HTTPS che le applicazioni Web protette ricevono dai client. È possibile definire come gestire le richieste Web configurando le regole all'interno di una lista di controllo degli accessi AWS WAF Web (ACL). Si protegge quindi un'applicazione Web associandovi un'ACL Web. Esempi di risorse per applicazioni Web con cui puoi proteggerti AWS WAF includono CloudFront distribuzioni Amazon, Amazon API Gateway APIs REST e Application Load Balancers. *Per ulteriori informazioni in merito AWS WAF, consulta la guida per [AWS WAF](https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html)gli AWS WAF sviluppatori.*
AWS WAF i log includono informazioni sul traffico analizzato dall'ACL Web, ad esempio l'ora in cui è AWS WAF stata ricevuta la richiesta dalla AWS risorsa, informazioni dettagliate sulla richiesta e l'azione relativa alla regola a cui corrisponde ogni richiesta.
È possibile configurare un ACL AWS WAF Web per pubblicare i log su una delle diverse destinazioni, dove è possibile interrogarli e visualizzarli. *Per ulteriori informazioni sulla configurazione della registrazione Web ACL e sul contenuto dei AWS WAF log, consulta la sezione Registrazione del traffico ACL [AWS WAF Web nella guida per gli sviluppatori](https://docs.aws.amazon.com/waf/latest/developerguide/logging.html).AWS WAF *
Per informazioni su come utilizzare Athena per analizzare AWS WAF i log per ottenere informazioni sul rilevamento delle minacce e sui potenziali attacchi alla sicurezza, consulta il post del blog AWS Networking & Content Delivery [Come usare le query Amazon Athena per analizzare AWS WAF i log e fornire la visibilità necessaria per](https://aws.amazon.com/blogs/networking-and-content-delivery/how-to-use-amazon-athena-queries-to-analyze-aws-waf-logs-and-provide-the-visibility-needed-for-threat-detection/) il rilevamento delle minacce.
Per un esempio di come aggregare AWS WAF i log in un repository centrale di data lake e interrogarli con Athena, consulta il post del blog AWS Big Data [Analyzing logs AWS WAF with Service OpenSearch , Amazon Athena](https://aws.amazon.com/blogs/big-data/analyzing-aws-waf-logs-with-amazon-es-amazon-athena-and-amazon-quicksight/) e Quick.
Questo argomento fornisce esempi di istruzioni `CREATE TABLE` per la proiezione delle partizioni, il partizionamento manuale e uno che non utilizza alcun partizionamento.
**Nota**
Le istruzioni `CREATE TABLE` in questo argomento possono essere utilizzate per i registri AWS WAF v1 e v2. In v1, il campo `webaclid` contiene un ID. In v2, il campo `webaclid` contiene un ARN completo. Le istruzioni `CREATE TABLE` trattano questo contenuto in modo agnostico usando il tipo di dati `string`.
**Topics**
+ [Crea una tabella per i log AWS WAF S3 in Athena usando la proiezione delle partizioni](create-waf-table-partition-projection.md)
+ [Crea una tabella per i log AWS WAF S3 in Athena usando la partizione manuale](create-waf-table-manual-partition.md)
+ [Crea una tabella per i log senza partizionamento AWS WAF](create-waf-table.md)
+ [Interrogazioni di esempio per i log AWS WAF](query-examples-waf-logs.md)
# Crea una tabella per i log AWS WAF S3 in Athena usando la proiezione delle partizioni
[Poiché AWS WAF i log hanno una struttura nota il cui schema di partizione è possibile specificare in anticipo, è possibile ridurre il tempo di esecuzione delle query e automatizzare la gestione delle partizioni utilizzando la funzionalità di proiezione delle partizioni Athena.](partition-projection.md) La proiezione delle partizioni aggiunge automaticamente nuove partizioni man mano che vengono aggiunti nuovi dati. Ciò elimina la necessità di aggiungere manualmente le partizioni utilizzando `ALTER TABLE ADD PARTITION`.
L'`CREATE TABLE`istruzione di esempio seguente utilizza automaticamente la proiezione delle partizioni nei AWS WAF log da una data specificata fino ad oggi per quattro diverse regioni. AWS La clausola `PARTITION BY` in questo esempio esegue la partizione per regione e per data, ma è possibile modificarla in base alle proprie esigenze. Modifica i campi secondo necessità in base all'output del log. Nelle `storage.location.template` clausole `LOCATION` and, sostituisci i *AWS\$1ACCOUNT\$1NUMBER* segnaposto *amzn-s3-demo-bucket* and con valori che identificano la posizione del bucket Amazon S3 dei log. AWS WAF Per`projection.day.range`, sostituisci*2021*/*01*/*01*con la data di inizio che desideri utilizzare. Dopo aver eseguito la query con esito positivo, è possibile eseguire query sulla tabella. Non è necessario eseguire `ALTER TABLE ADD PARTITION` per caricare le partizioni.
```
CREATE EXTERNAL TABLE `waf_logs_partition_projection`(
`timestamp` bigint,
`formatversion` int,
`webaclid` string,
`terminatingruleid` string,
`terminatingruletype` string,
`action` string,
`terminatingrulematchdetails` array>>,
`httpsourcename` string,
`httpsourceid` string,
`rulegrouplist` array>>>,nonterminatingmatchingrules:array>>,challengeresponse:struct,captcharesponse:struct>>,excludedrules:string>>,
`ratebasedrulelist` array>,
`nonterminatingmatchingrules` array>>,challengeresponse:struct,captcharesponse:struct>>,
`requestheadersinserted` array>,
`responsecodesent` string,
`httprequest` struct>,uri:string,args:string,httpversion:string,httpmethod:string,requestid:string,fragment:string,scheme:string,host:string>,
`labels` array>,
`captcharesponse` struct,
`challengeresponse` struct,
`ja3fingerprint` string,
`ja4fingerprint` string,
`oversizefields` string,
`requestbodysize` int,
`requestbodysizeinspectedbywaf` int)
PARTITIONED BY (
`log_time` string)
ROW FORMAT SERDE
'org.openx.data.jsonserde.JsonSerDe'
STORED AS INPUTFORMAT
'org.apache.hadoop.mapred.TextInputFormat'
OUTPUTFORMAT
'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION
's3://amzn-s3-demo-bucket/AWSLogs/AWS_ACCOUNT_NUMBER/WAFLogs/cloudfront/testui/'
TBLPROPERTIES (
'projection.enabled'='true',
'projection.log_time.format'='yyyy/MM/dd/HH/mm',
'projection.log_time.interval'='1',
'projection.log_time.interval.unit'='minutes',
'projection.log_time.range'='2025/01/01/00/00,NOW',
'projection.log_time.type'='date',
'storage.location.template'='s3://amzn-s3-demo-bucket/AWSLogs/AWS_ACCOUNT_NUMBER/WAFLogs/cloudfront/testui/${log_time}')
```
**Nota**
Il formato del percorso nella `LOCATION` clausola dell'esempio è standard ma può variare in base alla AWS WAF configurazione implementata. Ad esempio, il percorso dei AWS WAF log di esempio seguente riguarda una CloudFront distribuzione:
```
s3://amzn-s3-demo-bucket/AWSLogs/AWS_ACCOUNT_NUMBER/WAFLogs/cloudfront/cloudfronyt/2025/01/01/00/00/
```
[Se riscontri problemi durante la creazione o l'interrogazione della tabella AWS WAF dei log, conferma la posizione dei dati di registro o del contatto. Supporto](https://console.aws.amazon.com/support/home/)
Per maggiori informazioni sulla proiezione delle partizioni, consulta [Proiezione delle partizioni con Amazon Athena](partition-projection.md).
# Crea una tabella per i log AWS WAF S3 in Athena usando la partizione manuale
Questa sezione descrive come creare una tabella per i AWS WAF log utilizzando la partizione manuale.
Nelle `storage.location.template` clausole `LOCATION` and, sostituisci i *AWS\$1ACCOUNT\$1NUMBER* segnaposto *amzn-s3-demo-bucket* and con valori che identificano la posizione del bucket Amazon S3 dei log. AWS WAF
```
CREATE EXTERNAL TABLE `waf_logs_manual_partition`(
`timestamp` bigint,
`formatversion` int,
`webaclid` string,
`terminatingruleid` string,
`terminatingruletype` string,
`action` string,
`terminatingrulematchdetails` array>>,
`httpsourcename` string,
`httpsourceid` string,
`rulegrouplist` array>>>,nonterminatingmatchingrules:array>>,challengeresponse:struct,captcharesponse:struct>>,excludedrules:string>>,
`ratebasedrulelist` array>,
`nonterminatingmatchingrules` array>>,challengeresponse:struct,captcharesponse:struct>>,
`requestheadersinserted` array>,
`responsecodesent` string,
`httprequest` struct>,uri:string,args:string,httpversion:string,httpmethod:string,requestid:string,fragment:string,scheme:string,host:string>,
`labels` array>,
`captcharesponse` struct,
`challengeresponse` struct,
`ja3fingerprint` string,
`ja4fingerprint` string,
`oversizefields` string,
`requestbodysize` int,
`requestbodysizeinspectedbywaf` int)
PARTITIONED BY ( `year` string, `month` string, `day` string, `hour` string, `min` string)
ROW FORMAT SERDE
'org.openx.data.jsonserde.JsonSerDe'
STORED AS INPUTFORMAT
'org.apache.hadoop.mapred.TextInputFormat'
OUTPUTFORMAT
'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION
's3://amzn-s3-demo-bucket/AWSLogs/AWS_ACCOUNT_NUMBER/WAFLogs/cloudfront/webacl/'
```
# Crea una tabella per i log senza partizionamento AWS WAF
Questa sezione descrive come creare una tabella per i AWS WAF log senza partizionamento o proiezione delle partizioni.
**Nota**
Per motivi di prestazioni e costi, non è consigliabile utilizzare uno schema non partizionato per le query. Per ulteriori informazioni, consulta i [10 migliori consigli per l'ottimizzazione delle prestazioni per Amazon](https://aws.amazon.com/blogs/big-data/top-10-performance-tuning-tips-for-amazon-athena/) Athena AWS nel blog Big Data.
**Per creare la tabella AWS WAF**
1. Copiare e incollare la seguente istruzione DDL nella console Athena. Modifica i campi secondo necessità in base all'output del log. Modifica il parametro `LOCATION` per il bucket Amazon S3 in cui sono archiviati i registri.
Questa query utilizza il metodo [OpenX JSON SerDe](openx-json-serde.md).
**Nota**
SerDe Si aspetta che ogni documento JSON si trovi su una singola riga di testo senza caratteri di terminazione di riga che separano i campi del record. Se il testo JSON è in un bel formato di stampa, potresti ricevere un messaggio di errore come HIVE\$1CURSOR\$1ERROR: Row is not a valid JSON Object o HIVE\$1CURSOR\$1ERROR:: Unexpected end-of-input: expected: expected close marker for OBJECT quando tenti di interrogare la tabella dopo averla JsonParseException creata. Per ulteriori informazioni, consulta [JSON Data Files](https://github.com/rcongiu/Hive-JSON-Serde#json-data-files) nella documentazione di SerDe OpenX su. GitHub
```
CREATE EXTERNAL TABLE `waf_logs`(
`timestamp` bigint,
`formatversion` int,
`webaclid` string,
`terminatingruleid` string,
`terminatingruletype` string,
`action` string,
`terminatingrulematchdetails` array <
struct <
conditiontype: string,
sensitivitylevel: string,
location: string,
matcheddata: array < string >
>
>,
`httpsourcename` string,
`httpsourceid` string,
`rulegrouplist` array <
struct <
rulegroupid: string,
terminatingrule: struct <
ruleid: string,
action: string,
rulematchdetails: array <
struct <
conditiontype: string,
sensitivitylevel: string,
location: string,
matcheddata: array < string >
>
>
>,
nonterminatingmatchingrules: array <
struct <
ruleid: string,
action: string,
overriddenaction: string,
rulematchdetails: array <
struct <
conditiontype: string,
sensitivitylevel: string,
location: string,
matcheddata: array < string >
>
>,
challengeresponse: struct <
responsecode: string,
solvetimestamp: string
>,
captcharesponse: struct <
responsecode: string,
solvetimestamp: string
>
>
>,
excludedrules: string
>
>,
`ratebasedrulelist` array <
struct <
ratebasedruleid: string,
limitkey: string,
maxrateallowed: int
>
>,
`nonterminatingmatchingrules` array <
struct <
ruleid: string,
action: string,
rulematchdetails: array <
struct <
conditiontype: string,
sensitivitylevel: string,
location: string,
matcheddata: array < string >
>
>,
challengeresponse: struct <
responsecode: string,
solvetimestamp: string
>,
captcharesponse: struct <
responsecode: string,
solvetimestamp: string
>
>
>,
`requestheadersinserted` array <
struct <
name: string,
value: string
>
>,
`responsecodesent` string,
`httprequest` struct <
clientip: string,
country: string,
headers: array <
struct <
name: string,
value: string
>
>,
uri: string,
args: string,
httpversion: string,
httpmethod: string,
requestid: string
>,
`labels` array <
struct <
name: string
>
>,
`captcharesponse` struct <
responsecode: string,
solvetimestamp: string,
failureReason: string
>,
`challengeresponse` struct <
responsecode: string,
solvetimestamp: string,
failureReason: string
>,
`ja3Fingerprint` string,
`oversizefields` string,
`requestbodysize` int,
`requestbodysizeinspectedbywaf` int
)
ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe'
STORED AS INPUTFORMAT 'org.apache.hadoop.mapred.TextInputFormat'
OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION 's3://amzn-s3-demo-bucket/prefix/'
```
1. Esegui l'istruzione `CREATE EXTERNAL TABLE` nell'editor di query della console Athena. Questo registra la tabella `waf_logs` e rende i dati in essa contenuti disponibili per le query da Athena.
# Interrogazioni di esempio per i log AWS WAF
Molte delle seguenti query di esempio utilizzano la tabella di proiezione delle partizioni creata nella sezione precedente di questo documento. Modificare il nome della tabella, i valori delle colonne e altre variabili negli esempi in base alle proprie esigenze. Per migliorare le prestazioni delle query e ridurre i costi, aggiungere la colonna della partizione nella condizione del filtro.
**Topics**
+ [Conta i referrer, gli indirizzi IP o le regole corrispondenti](query-examples-waf-logs-count.md)
+ [Data e ora interrogare utilizzando data e ora](query-examples-waf-logs-date-time.md)
+ [Interrogazione per richieste o indirizzi bloccati](query-examples-waf-logs-blocked-requests.md)
# Conta i referrer, gli indirizzi IP o le regole corrispondenti
Gli esempi di questa sezione richiedono il conteggio degli elementi di registro di interesse.
+ [Count the number of referrers that contain a specified term](#waf-example-count-referrers-with-specified-term)
+ [Count all matched IP addresses in the last 10 days that have matched excluded rules](#waf-example-count-matched-ip-addresses)
+ [Group all counted managed rules by the number of times matched](#waf-example-group-managed-rules-by-times-matched)
+ [Group all counted custom rules by number of times matched](#waf-example-group-custom-rules-by-times-matched)
**Example : Conta il numero di riferimenti contenenti un termine specificato**
La query seguente conta il numero di riferimenti che contengono il termine "amazon" per l'intervallo di date specificato.
```
WITH test_dataset AS
(SELECT header FROM waf_logs
CROSS JOIN UNNEST(httprequest.headers) AS t(header) WHERE "date" >= '2021/03/01'
AND "date" < '2021/03/31')
SELECT COUNT(*) referer_count
FROM test_dataset
WHERE LOWER(header.name)='referer' AND header.value LIKE '%amazon%'
```
**Example : Conta tutti gli indirizzi IP corrispondenti negli ultimi 10 giorni che hanno soddisfatto le regole escluse**
La query seguente conteggia il numero di volte in cui l'indirizzo IP corrisponde alla regola esclusa nel gruppo di regole.
```
WITH test_dataset AS
(SELECT * FROM waf_logs
CROSS JOIN UNNEST(rulegrouplist) AS t(allrulegroups))
SELECT
COUNT(*) AS count,
"httprequest"."clientip",
"allrulegroups"."excludedrules",
"allrulegroups"."ruleGroupId"
FROM test_dataset
WHERE allrulegroups.excludedrules IS NOT NULL AND from_unixtime(timestamp/1000) > now() - interval '10' day
GROUP BY "httprequest"."clientip", "allrulegroups"."ruleGroupId", "allrulegroups"."excludedrules"
ORDER BY count DESC
```
**Example : Raggruppa tutte le regole gestite conteggiate in base al numero di corrispondenze**
Se hai impostato le azioni delle regole del gruppo di regole su Count nella configurazione Web ACL prima del 27 ottobre 2022, AWS WAF hai salvato le sostituzioni nell'ACL Web JSON come. `excludedRules` Ora, l'impostazione JSON per sovrascrivere una regola su Count è nelle impostazioni `ruleActionOverrides`. Per ulteriori informazioni, consulta [Sostituzione delle azioni nei gruppi di regole](https://docs.aws.amazon.com/waf/latest/developerguide/web-acl-rule-group-override-options.html) nella *Guida per gli sviluppatori di AWS WAF *. Per estrarre le regole gestite in modalità Count dalla nuova struttura di log, esegui una query su `nonTerminatingMatchingRules` nella sezione `ruleGroupList` anziché nel campo `excludedRules`, come nell'esempio seguente.
```
SELECT
count(*) AS count,
httpsourceid,
httprequest.clientip,
t.rulegroupid,
t.nonTerminatingMatchingRules
FROM "waf_logs"
CROSS JOIN UNNEST(rulegrouplist) AS t(t)
WHERE action <> 'BLOCK' AND cardinality(t.nonTerminatingMatchingRules) > 0
GROUP BY t.nonTerminatingMatchingRules, action, httpsourceid, httprequest.clientip, t.rulegroupid
ORDER BY "count" DESC
Limit 50
```
**Example : Raggruppa tutte le regole personalizzate contate in base al numero di corrispondenze**
La seguente query raggruppa tutte le regole personalizzate contate in base al numero di volte in cui sono state confrontate.
```
SELECT
count(*) AS count,
httpsourceid,
httprequest.clientip,
t.ruleid,
t.action
FROM "waf_logs"
CROSS JOIN UNNEST(nonterminatingmatchingrules) AS t(t)
WHERE action <> 'BLOCK' AND cardinality(nonTerminatingMatchingRules) > 0
GROUP BY t.ruleid, t.action, httpsourceid, httprequest.clientip
ORDER BY "count" DESC
Limit 50
```
Per informazioni sui percorsi dei log per le regole personalizzate e i gruppi di regole gestiti, consulta [Controllo e regolazione](https://docs.aws.amazon.com/waf/latest/developerguide/web-acl-testing-activities.html) nella *Guida per gli sviluppatori di AWS WAF *.
# Data e ora interrogare utilizzando data e ora
Gli esempi di questa sezione illustrano le query che utilizzano i valori di data e ora.
+ [Return the timestamp field in human-readable ISO 8601 format](#waf-example-return-human-readable-timestamp)
+ [Return records from the last 24 hours](#waf-example-return-records-last-24-hours)
+ [Return records for a specified date range and IP address](#waf-example-return-records-date-range-and-ip)
+ [For a specified date range, count the number of IP addresses in five minute intervals](#waf-example-count-ip-addresses-in-date-range)
+ [Count the number of X-Forwarded-For IP in the last 10 days](#waf-example-count-x-forwarded-for-ip)
**Example : Restituisci il campo timestamp in formato ISO 8601 leggibile dall'uomo**
La seguente query utilizza le funzioni `from_unixtime` e `to_iso8601` per restituire il campo `timestamp` in formato ISO 8601 leggibile dalle persone (ad esempio, `2019-12-13T23:40:12.000Z` invece di `1576280412771`). La query restituisce anche il nome dell'origine HTTP, l'ID di origine e la richiesta.
```
SELECT to_iso8601(from_unixtime(timestamp / 1000)) as time_ISO_8601,
httpsourcename,
httpsourceid,
httprequest
FROM waf_logs
LIMIT 10;
```
**Example : Restituisci record delle ultime 24 ore**
La query seguente utilizza un filtro nella clausola `WHERE` per restituire il nome dell'origine HTTP, l'ID origine HTTP e i campi di richiesta HTTP per i registri delle ultime 24 ore.
```
SELECT to_iso8601(from_unixtime(timestamp/1000)) AS time_ISO_8601,
httpsourcename,
httpsourceid,
httprequest
FROM waf_logs
WHERE from_unixtime(timestamp/1000) > now() - interval '1' day
LIMIT 10;
```
**Example : Restituisci i record per un intervallo di date e un indirizzo IP specificati**
Nella query seguente sono elencati i registri in un intervallo di date specificato per un indirizzo IP client specificato.
```
SELECT *
FROM waf_logs
WHERE httprequest.clientip='53.21.198.66' AND "date" >= '2021/03/01' AND "date" < '2021/03/31'
```
**Example : per un intervallo di date specificato, conta il numero di indirizzi IP in intervalli di cinque minuti**
La query seguente conta, per un determinato intervallo di date, il numero di indirizzi IP in intervalli di cinque minuti.
```
WITH test_dataset AS
(SELECT
format_datetime(from_unixtime((timestamp/1000) - ((minute(from_unixtime(timestamp / 1000))%5) * 60)),'yyyy-MM-dd HH:mm') AS five_minutes_ts,
"httprequest"."clientip"
FROM waf_logs
WHERE "date" >= '2021/03/01' AND "date" < '2021/03/31')
SELECT five_minutes_ts,"clientip",count(*) ip_count
FROM test_dataset
GROUP BY five_minutes_ts,"clientip"
```
**Example — Conta il numero di X-Forwarded-For IP negli ultimi 10 giorni**
La seguente query filtra le intestazioni delle richieste e conta il numero di X-Forwarded-For IP negli ultimi 10 giorni.
```
WITH test_dataset AS
(SELECT header
FROM waf_logs
CROSS JOIN UNNEST (httprequest.headers) AS t(header)
WHERE from_unixtime("timestamp"/1000) > now() - interval '10' DAY)
SELECT header.value AS ip,
count(*) AS COUNT
FROM test_dataset
WHERE header.name='X-Forwarded-For'
GROUP BY header.value
ORDER BY COUNT DESC
```
Per ulteriori informazioni sulle funzioni data e ora, consulta [Funzioni e operatori di data e ora](https://trino.io/docs/current/functions/datetime.html) nella documentazione Trino.
# Interrogazione per richieste o indirizzi bloccati
Gli esempi di questa sezione eseguono query per richieste o indirizzi bloccati.
+ [Extract the top 100 IP addresses blocked by a specified rule type](#waf-example-extract-top-100-blocked-ip-by-rule)
+ [Count the number of times a request from a specified country has been blocked](#waf-example-count-request-blocks-from-country)
+ [Count the number of times a request has been blocked, grouping by specific attributes](#waf-example-count-request-blocks-by-attribute)
+ [Count the number of times a specific terminating rule ID has been matched](#waf-example-count-terminating-rule-id-matches)
+ [Retrieve the top 100 IP addresses blocked during a specified date range](#waf-example-top-100-ip-addresses-blocked-for-date-range)
**Example : Estrai i primi 100 indirizzi IP bloccati da un tipo di regola specificato**
La query seguente estrae e conta i primi 100 indirizzi IP bloccati dalla regola di terminazione `RATE_BASED` durante l'intervallo di date specificato.
```
SELECT COUNT(httpRequest.clientIp) as count,
httpRequest.clientIp
FROM waf_logs
WHERE terminatingruletype='RATE_BASED' AND action='BLOCK' and "date" >= '2021/03/01'
AND "date" < '2021/03/31'
GROUP BY httpRequest.clientIp
ORDER BY count DESC
LIMIT 100
```
**Example : Conta il numero di volte in cui una richiesta proveniente da un Paese specificato è stata bloccata**
La seguente query conteggia il numero di volte in cui la richiesta è arrivata da un indirizzo IP che appartiene all'Irlanda (IE) ed è stato bloccato dalla regola di terminazione `RATE_BASED`.
```
SELECT
COUNT(httpRequest.country) as count,
httpRequest.country
FROM waf_logs
WHERE
terminatingruletype='RATE_BASED' AND
httpRequest.country='IE'
GROUP BY httpRequest.country
ORDER BY count
LIMIT 100;
```
**Example : Conta il numero di volte in cui una richiesta è stata bloccata, raggruppando per attributi specifici**
La seguente query conta il numero di volte in cui la richiesta è stata bloccata, con risultati raggruppati per WebACL RuleId, ClientIP e URI di richiesta HTTP.
```
SELECT
COUNT(*) AS count,
webaclid,
terminatingruleid,
httprequest.clientip,
httprequest.uri
FROM waf_logs
WHERE action='BLOCK'
GROUP BY webaclid, terminatingruleid, httprequest.clientip, httprequest.uri
ORDER BY count DESC
LIMIT 100;
```
**Example : Conta il numero di volte in cui è stata trovata una corrispondenza con un determinato ID di regola di terminazione**
La seguente query conteggia il numero di volte in cui un determinato ID regola di terminazione è stato corrisposto (`WHERE terminatingruleid='e9dd190d-7a43-4c06-bcea-409613d9506e'`). La query raggrupperà i risultati per WebACL, Operazione, ClientIP e URI della richiesta HTTP.
```
SELECT
COUNT(*) AS count,
webaclid,
action,
httprequest.clientip,
httprequest.uri
FROM waf_logs
WHERE terminatingruleid='e9dd190d-7a43-4c06-bcea-409613d9506e'
GROUP BY webaclid, action, httprequest.clientip, httprequest.uri
ORDER BY count DESC
LIMIT 100;
```
**Example : Recupera i primi 100 indirizzi IP bloccati durante un intervallo di date specificato**
Nella query seguente vengono estratti i primi 100 indirizzi IP bloccati per un intervallo di date specificato. La query elenca anche il numero di volte in cui gli indirizzi IP sono stati bloccati.
```
SELECT "httprequest"."clientip", "count"(*) "ipcount", "httprequest"."country"
FROM waf_logs
WHERE "action" = 'BLOCK' and "date" >= '2021/03/01'
AND "date" < '2021/03/31'
GROUP BY "httprequest"."clientip", "httprequest"."country"
ORDER BY "ipcount" DESC limit 100
```
Per ulteriori informazioni sulle query dei log di Amazon S3, consulta i seguenti argomenti:
+ [Come posso analizzare i log di accesso del server Amazon S3 utilizzando Athena?](https://aws.amazon.com/premiumsupport/knowledge-center/analyze-logs-athena/) nel Portale del sapere AWS
+ [Esecuzione di query sui log di accesso Amazon S3 per le richieste utilizzando Amazon Athena](https://docs.aws.amazon.com/AmazonS3/latest/dev/using-s3-access-logs-to-identify-requests.html#querying-s3-access-logs-for-requests) nella Guida per l'utente di Amazon Simple Storage Service
+ [Utilizzo di AWS CloudTrail per identificare le richieste Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/cloudtrail-request-identification.html) nella Guida per l'utente di Amazon Simple Storage Service
# Eseguire query sui log del server web archiviati in Amazon S3
È possibile utilizzare Athena per interrogare i log dei server Web archiviati in Amazon S3. Gli argomenti di questa sezione mostrano come creare tabelle in Athena per eseguire query sui log del server Web in formati diversi.
**Topics**
+ [Eseguire query sui log Apache archiviati in Amazon S3](querying-apache-logs.md)
+ [Eseguire query sui log Internet Information Server (IIS) archiviati in Amazon S3](querying-iis-logs.md)
# Eseguire query sui log Apache archiviati in Amazon S3
Puoi utilizzarlo Amazon Athena per interrogare i [file di log del server HTTP Apache](https://httpd.apache.org/docs/2.4/logs.html) archiviati nel tuo account Amazon S3. Questo argomento illustra come utilizzare schemi di tabelle per eseguire query sui file [Log di accesso](https://httpd.apache.org/docs/2.4/logs.html#accesslog) Apache nel formato di log comune.
I campi nel formato di log comune includono l'indirizzo IP del client, l'ID del client, l'ID utente, la marca temporale della richiesta ricevuta, il testo della richiesta client, il codice di stato del server e la dimensione dell'oggetto restituito al client.
I dati dell'esempio seguente mostrano il formato comune di log per Apache.
```
198.51.100.7 - Li [10/Oct/2019:13:55:36 -0700] "GET /logo.gif HTTP/1.0" 200 232
198.51.100.14 - Jorge [24/Nov/2019:10:49:52 -0700] "GET /index.html HTTP/1.1" 200 2165
198.51.100.22 - Mateo [27/Dec/2019:11:38:12 -0700] "GET /about.html HTTP/1.1" 200 1287
198.51.100.9 - Nikki [11/Jan/2020:11:40:11 -0700] "GET /image.png HTTP/1.1" 404 230
198.51.100.2 - Ana [15/Feb/2019:10:12:22 -0700] "GET /favicon.ico HTTP/1.1" 404 30
198.51.100.13 - Saanvi [14/Mar/2019:11:40:33 -0700] "GET /intro.html HTTP/1.1" 200 1608
198.51.100.11 - Xiulan [22/Apr/2019:10:51:34 -0700] "GET /group/index.html HTTP/1.1" 200 1344
```
## Creare una tabella in Athena per i log Apache
Prima di poter eseguire query sui log Apache archiviati in Amazon S3, è necessario creare uno schema di tabella per Athena in modo che possa leggere i dati di log. Per creare una tabella Athena per i log Apache, è possibile utilizzare [Grok SerDe](grok-serde.md). *Per ulteriori informazioni sull'uso di Grok SerDe, consulta [Writing grok custom classifiers](https://docs.aws.amazon.com/glue/latest/dg/custom-classifier.html#custom-classifier-grok) nella Developer Guide.AWS Glue *
**Per creare una tabella in Athena per i log del server Web Apache**
1. Apri la console Athena all'indirizzo [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Copiare e incollare la seguente istruzione DDL nella console Athena Query Editor. Modificare i valori in `LOCATION 's3://amzn-s3-demo-bucket/apache-log-folder/'` per puntare ai log Apache in Amazon S3.
```
CREATE EXTERNAL TABLE apache_logs (
client_ip string,
client_id string,
user_id string,
request_received_time string,
client_request string,
server_status string,
returned_obj_size string
)
ROW FORMAT SERDE
'com.amazonaws.glue.serde.GrokSerDe'
WITH SERDEPROPERTIES (
'input.format'='^%{IPV4:client_ip} %{DATA:client_id} %{USERNAME:user_id} %{GREEDYDATA:request_received_time} %{QUOTEDSTRING:client_request} %{DATA:server_status} %{DATA: returned_obj_size}$'
)
STORED AS INPUTFORMAT
'org.apache.hadoop.mapred.TextInputFormat'
OUTPUTFORMAT
'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION
's3://amzn-s3-demo-bucket/apache-log-folder/';
```
1. Eseguire la query nella console Athena per registrare la tabella `apache_logs`. Al termine della query, i registri sono pronti per le query da Athena.
### Query di esempio
**Example — Filtrare per errori 404**
La query di esempio seguente seleziona l'ora di ricezione della richiesta, il testo della richiesta client e il codice di stato del server dalla tabella `apache_logs`. La clausola `WHERE` filtra per codice di stato HTTP `404` (pagina non trovata).
```
SELECT request_received_time, client_request, server_status
FROM apache_logs
WHERE server_status = '404'
```
L'immagine seguente mostra i risultati della query nell'editor di query Athena.
![\[Esecuzione di query su un log Apache da Athena per le voci HTTP 404.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/querying-apache-logs-1.png)
**Example — Filtrare per richieste riuscite**
La query di esempio seguente seleziona l'ID utente, l'ora di ricezione della richiesta, il testo della richiesta client e il codice di stato del server dalla tabella `apache_logs`. I filtri della clausola `WHERE` per il codice di stato HTTP `200` (riuscito).
```
SELECT user_id, request_received_time, client_request, server_status
FROM apache_logs
WHERE server_status = '200'
```
L'immagine seguente mostra i risultati della query nell'editor di query Athena.
![\[Esecuzione di query su un log Apache da Athena per le voci HTTP 200.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/querying-apache-logs-2.png)
**Example — Filtrare per timestamp**
L'esempio seguente cerca i record il cui tempo di ricezione della richiesta è maggiore del timestamp specificato.
```
SELECT * FROM apache_logs WHERE request_received_time > 10/Oct/2023:00:00:00
```
# Eseguire query sui log Internet Information Server (IIS) archiviati in Amazon S3
Puoi usare Amazon Athena per eseguire query sui log del server Web Microsoft Internet Information Server (IIS) archiviati nell'account Amazon S3. Mentre IIS utilizza una [varietà](https://docs.microsoft.com/en-us/previous-versions/iis/6.0-sdk/ms525807(v%3Dvs.90)) dei formati dei file di log, questo argomento illustra come creare schemi di tabella per eseguire una query sui log con formato W3C extended e IIS da Athena.
Poiché i formati di file di registro W3C esteso e IIS utilizzano delimitatori di caratteri singoli (rispettivamente spazi e virgole) e non hanno valori racchiusi tra virgolette, è possibile utilizzarli per creare tabelle Athena per [LazySimpleSerDe](lazy-simple-serde.md)tali formati.
**Topics**
+ [Eseguire query sul formato dei file di log W3C extended](querying-iis-logs-w3c-extended-log-file-format.md)
+ [Eseguire query sul formato del file di log IIS](querying-iis-logs-iis-log-file-format.md)
+ [Eseguire query sul formato del file di log NCSA](querying-iis-logs-ncsa-log-file-format.md)
# Eseguire query sul formato dei file di log W3C extended
Il formato dei dati del file di log [W3C extended](https://docs.microsoft.com/en-us/windows/win32/http/w3c-logging) presenta campi separati da spazi. I campi visualizzati nei log W3C extended sono determinati da un amministratore del server Web che sceglie quali campi di log includere. Nell'esempio seguente i dati di log contengono i campi `date, time`, `c-ip`, `s-ip`, `cs-method`, `cs-uri-stem`, `sc-status`, `sc-bytes`, `cs-bytes`, `time-taken` e `cs-version`.
```
2020-01-19 22:48:39 203.0.113.5 198.51.100.2 GET /default.html 200 540 524 157 HTTP/1.0
2020-01-19 22:49:40 203.0.113.10 198.51.100.12 GET /index.html 200 420 324 164 HTTP/1.0
2020-01-19 22:50:12 203.0.113.12 198.51.100.4 GET /image.gif 200 324 320 358 HTTP/1.0
2020-01-19 22:51:44 203.0.113.15 198.51.100.16 GET /faq.html 200 330 324 288 HTTP/1.0
```
## Creare una tabella in Athena per i log W3C extended
Prima di poter eseguire una query sui W3C extended, è necessario creare uno schema di tabella in modo che Athena possa leggere i dati del log.
**Per creare una tabella in Athena per i log W3C extended**
1. Apri la console Athena all'indirizzo [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Incollare un'istruzione DDL come la seguente nella console Athena, osservando i seguenti punti:
1. Aggiungere o rimuovere le colonne dell'esempio in modo che corrispondano ai campi dei log per cui si desidera eseguire la query.
1. I nomi delle colonna nel formato di file di log W3C Extended contengono trattini (`-`). Tuttavia, in conformità con le [convenzioni di denominazione di Athena](tables-databases-columns-names.md), l'esempio di istruzione `CREATE TABLE` li sostituisce con trattini bassi (`_`).
1. Per specificare uno spazio come separatore, utilizzare `FIELDS TERMINATED BY ' '`.
1. Modificare i valori in `LOCATION 's3://amzn-s3-demo-bucket/w3c-log-folder/'` per puntare ai log W3C extended in Amazon S3.
```
CREATE EXTERNAL TABLE `iis_w3c_logs`(
date_col string,
time_col string,
c_ip string,
s_ip string,
cs_method string,
cs_uri_stem string,
sc_status string,
sc_bytes string,
cs_bytes string,
time_taken string,
cs_version string
)
ROW FORMAT DELIMITED
FIELDS TERMINATED BY ' '
STORED AS INPUTFORMAT
'org.apache.hadoop.mapred.TextInputFormat'
OUTPUTFORMAT
'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION 's3://amzn-s3-demo-bucket/w3c-log-folder/'
```
1. Eseguire la query nella console Athena per registrare la tabella `iis_w3c_logs`. Al termine della query, i registri sono pronti per le query da Athena.
## Esempio di query di selezione dei log W3C Extended
Il seguente esempio di query seleziona la data, l'ora, la destinazione della richiesta e il tempo impiegato dalla tabella `iis_w3c_logs`. La clausola `WHERE` filtra per casi in cui il metodo HTTP è `GET` e il codice di stato HTTP è `200` (riuscito).
```
SELECT date_col, time_col, cs_uri_stem, time_taken
FROM iis_w3c_logs
WHERE cs_method = 'GET' AND sc_status = '200'
```
L'immagine seguente mostra i risultati della query nell'editor di query Athena.
![\[Esempio di risultati delle query in Athena dei file di log W3C Extended archiviati in Amazon S3.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/querying-iis-logs-1.png)
## Combinare i campi data e ora
I campi `date` e `time` delimitati da spazio sono voci separate nei dati di origine del log, ma è possibile combinarle in una marca temporale se lo si desidera. Usa le funzioni [concat()](https://prestodb.io/docs/current/functions/string.html#concat) e [date\$1parse()](https://prestodb.io/docs/current/functions/datetime.html#date_parse) in una query [SELECT](select.md) o [CREATE TABLE AS SELECT](create-table-as.md) per concatenare e convertire le colonne di data e ora in formato marca temporale. Nell'esempio seguente viene utilizzata una query CTAS per creare una nuova tabella con una colonna `derived_timestamp`.
```
CREATE TABLE iis_w3c_logs_w_timestamp AS
SELECT
date_parse(concat(date_col,' ', time_col),'%Y-%m-%d %H:%i:%s') as derived_timestamp,
c_ip,
s_ip,
cs_method,
cs_uri_stem,
sc_status,
sc_bytes,
cs_bytes,
time_taken,
cs_version
FROM iis_w3c_logs
```
Dopo aver creato la tabella, è possibile eseguire query direttamente sulla nuova colonna della marca temporale, come nell'esempio seguente.
```
SELECT derived_timestamp, cs_uri_stem, time_taken
FROM iis_w3c_logs_w_timestamp
WHERE cs_method = 'GET' AND sc_status = '200'
```
L'immagine seguente mostra i risultati della query.
![\[Risultati delle query del file di log W3C Extended su una tabella con una colonna di marca temporale derivata.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/querying-iis-logs-1a.png)
# Eseguire query sul formato del file di log IIS
A differenza del formato W3C Extended, il [formato del file di log IIS](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2003/cc728311(v%3dws.10)) ha un insieme fisso di campi e include una virgola come separatore. LazySimpleSerDe Tratta la virgola come delimitatore e lo spazio dopo la virgola come inizio del campo successivo.
L'esempio seguente mostra dati di esempio nel formato del file di log IIS.
```
203.0.113.15, -, 2020-02-24, 22:48:38, W3SVC2, SERVER5, 198.51.100.4, 254, 501, 488, 200, 0, GET, /index.htm, -,
203.0.113.4, -, 2020-02-24, 22:48:39, W3SVC2, SERVER6, 198.51.100.6, 147, 411, 388, 200, 0, GET, /about.html, -,
203.0.113.11, -, 2020-02-24, 22:48:40, W3SVC2, SERVER7, 198.51.100.18, 170, 531, 468, 200, 0, GET, /image.png, -,
203.0.113.8, -, 2020-02-24, 22:48:41, W3SVC2, SERVER8, 198.51.100.14, 125, 711, 868, 200, 0, GET, /intro.htm, -,
```
## Creare una tabella in Athena per i file di log IIS
Per eseguire le query sui log del formato del file di log IIS in Amazon S3, devi prima creare uno schema di tabella in modo che Athena possa leggere i dati del log.
**Per creare una tabella in Athena per i registri del formato del file di log IIS**
1. Apri la console Athena all'indirizzo [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Incollare la seguente istruzione DDL nella console Athena, osservando i seguenti punti:
1. Per specificare il separatore decimale, utilizzare `FIELDS TERMINATED BY ','`.
1. Modifica i valori in LOCATION 's3://amzn-s3-demo-bucket/ *iis-log-file-folder* /' in modo che puntino ai tuoi file di log in formato di log IIS in Amazon S3.
```
CREATE EXTERNAL TABLE `iis_format_logs`(
client_ip_address string,
user_name string,
request_date string,
request_time string,
service_and_instance string,
server_name string,
server_ip_address string,
time_taken_millisec string,
client_bytes_sent string,
server_bytes_sent string,
service_status_code string,
windows_status_code string,
request_type string,
target_of_operation string,
script_parameters string
)
ROW FORMAT DELIMITED
FIELDS TERMINATED BY ','
STORED AS INPUTFORMAT
'org.apache.hadoop.mapred.TextInputFormat'
OUTPUTFORMAT
'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION
's3://amzn-s3-demo-bucket/iis-log-file-folder/'
```
1. Eseguire la query nella console Athena per registrare la tabella `iis_format_logs`. Al termine della query, i registri sono pronti per le query da Athena.
## Esempio di query di selezione nel formato di log IIS
Il seguente esempio di query seleziona la data della richiesta, l'ora della richiesta, la destinazione della richiesta e il tempo impiegato in millisecondi dalla tabella `iis_format_logs`. La clausola `WHERE` filtra per casi in cui il tipo di richiesta è `GET` e il codice di stato HTTP è `200` (riuscito). Nella query, si noti che gli spazi iniziali in `' GET'` e `' 200'` sono necessari per far sì che la query abbia esito positivo.
```
SELECT request_date, request_time, target_of_operation, time_taken_millisec
FROM iis_format_logs
WHERE request_type = ' GET' AND service_status_code = ' 200'
```
L'immagine seguente mostra i risultati della query dei dati di esempio.
![\[Esempio di risultati delle query in Athena dei file di log nel formato del file di log W3C Extended archiviati in Amazon S3.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/querying-iis-logs-2.png)
# Eseguire query sul formato del file di log NCSA
IIS utilizza anche il formato [NCSA Logging](https://docs.microsoft.com/en-us/windows/win32/http/ncsa-logging), che ha un numero fisso di campi in formato testo ASCII separati da spazi. La struttura è simile al formato di log comune utilizzato per i log di accesso Apache. I campi nel formato di log comune NCSA includono l'indirizzo IP del client, l'ID del client (non usato di norma), l'ID utente/dominio, la marca temporale della richiesta ricevuta, il testo della richiesta client, il codice di stato del server e la dimensione dell'oggetto restituito al client.
L'esempio seguente mostra i dati nel formato di log comune NCSA come documentato per IIS.
```
198.51.100.7 - ExampleCorp\Li [10/Oct/2019:13:55:36 -0700] "GET /logo.gif HTTP/1.0" 200 232
198.51.100.14 - AnyCompany\Jorge [24/Nov/2019:10:49:52 -0700] "GET /index.html HTTP/1.1" 200 2165
198.51.100.22 - ExampleCorp\Mateo [27/Dec/2019:11:38:12 -0700] "GET /about.html HTTP/1.1" 200 1287
198.51.100.9 - AnyCompany\Nikki [11/Jan/2020:11:40:11 -0700] "GET /image.png HTTP/1.1" 404 230
198.51.100.2 - ExampleCorp\Ana [15/Feb/2019:10:12:22 -0700] "GET /favicon.ico HTTP/1.1" 404 30
198.51.100.13 - AnyCompany\Saanvi [14/Mar/2019:11:40:33 -0700] "GET /intro.html HTTP/1.1" 200 1608
198.51.100.11 - ExampleCorp\Xiulan [22/Apr/2019:10:51:34 -0700] "GET /group/index.html HTTP/1.1" 200 1344
```
## Creare una tabella in Athena per i log IIS NCSA
Per l'istruzione `CREATE TABLE`, è possibile utilizzare [Grok SerDe](grok-serde.md) e un modello Grok simile a quello per i [log dei server Web Apache](querying-apache-logs.md). A differenza dei log di Apache, il modello Grok utilizza `%{DATA:user_id}` per il terzo campo invece di `%{USERNAME:user_id}` per tenere conto della presenza della barra rovesciata in `domain\user_id`. *Per ulteriori informazioni sull'uso di Grok SerDe, consulta [Writing grok custom classifiers](https://docs.aws.amazon.com/glue/latest/dg/custom-classifier.html#custom-classifier-grok) nella Developer Guide.AWS Glue *
**Per creare una tabella in Athena per i log del server Web IIS NCSA**
1. Apri la console Athena all'indirizzo [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Copiare e incollare la seguente istruzione DDL nella console Athena Query Editor. Modificare i valori in `LOCATION 's3://amzn-s3-demo-bucket/iis-ncsa-logs/'` per puntare ai log IIS NCSA in Amazon S3.
```
CREATE EXTERNAL TABLE iis_ncsa_logs(
client_ip string,
client_id string,
user_id string,
request_received_time string,
client_request string,
server_status string,
returned_obj_size string
)
ROW FORMAT SERDE
'com.amazonaws.glue.serde.GrokSerDe'
WITH SERDEPROPERTIES (
'input.format'='^%{IPV4:client_ip} %{DATA:client_id} %{DATA:user_id} %{GREEDYDATA:request_received_time} %{QUOTEDSTRING:client_request} %{DATA:server_status} %{DATA: returned_obj_size}$'
)
STORED AS INPUTFORMAT
'org.apache.hadoop.mapred.TextInputFormat'
OUTPUTFORMAT
'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION
's3://amzn-s3-demo-bucket/iis-ncsa-logs/';
```
1. Eseguire la query nella console Athena per registrare la tabella `iis_ncsa_logs`. Al termine della query, i registri sono pronti per le query da Athena.
## Esempio di query di selezione per i log IIS NCSA
**Example — Filtrare per errori 404**
La query di esempio seguente seleziona l'ora di ricezione della richiesta, il testo della richiesta client e il codice di stato del server dalla tabella `iis_ncsa_logs`. La clausola `WHERE` filtra per codice di stato HTTP `404` (pagina non trovata).
```
SELECT request_received_time, client_request, server_status
FROM iis_ncsa_logs
WHERE server_status = '404'
```
L'immagine seguente mostra i risultati della query nell'editor di query Athena.
![\[Esecuzione di query su un log IIS NCSA da Athena per le voci HTTP 404.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/querying-iis-logs-3.png)
**Example — Filtrare per richieste riuscite da un determinato dominio**
La query di esempio seguente seleziona l'ID utente, l'ora di ricezione della richiesta, il testo della richiesta client e il codice di stato del server dalla tabella `iis_ncsa_logs`. La clausola `WHERE` filtra per richieste con codice di stato HTTP `200` (riuscito) dagli utenti nel dominio `AnyCompany`.
```
SELECT user_id, request_received_time, client_request, server_status
FROM iis_ncsa_logs
WHERE server_status = '200' AND user_id LIKE 'AnyCompany%'
```
L'immagine seguente mostra i risultati della query nell'editor di query Athena.
![\[Esecuzione di query su un log IIS NCSA da Athena per le voci HTTP 200.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/querying-iis-logs-4.png)