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à.
# AWS Glue Data Catalog Utilizzalo per connetterti ai tuoi dati
Athena li utilizza AWS Glue Data Catalog per archiviare metadati come nomi di tabelle e colonne per i dati archiviati in Amazon S3. Dopo aver effettuato la connessione, i database e le visualizzazioni appaiono nell’editor della query di Athena.
Quando si utilizza Athena con AWS Glue Data Catalog, è possibile utilizzare AWS Glue per creare database e tabelle (schema) da interrogare in Athena oppure è possibile utilizzare Athena per creare schemi e quindi utilizzarli nei servizi correlati. AWS Glue
Per definire le informazioni sullo schema per AWS Glue, puoi utilizzare un modulo nella console Athena, utilizzare l'editor di query in Athena o creare un AWS Glue crawler nella console. AWS Glue AWS Glue i crawler deducono automaticamente lo schema del database e della tabella dai dati in Amazon S3. L’utilizzo di un modulo offre una maggiore personalizzazione. Scrivere le proprie istruzioni `CREATE TABLE` richiede uno sforzo maggiore, ma offre il massimo controllo. Per ulteriori informazioni, consulta [CREATE TABLE](create-table.md).
## Risorse aggiuntive
+ *Per ulteriori informazioni su AWS Glue Data Catalog, consulta [Data Catalog and crawler](https://docs.aws.amazon.com/glue/latest/dg/catalog-and-crawler.html) nella Developer Guide. AWS GlueAWS Glue *
+ Per un articolo illustrativo che mostra come utilizzare AWS Glue e Athena per elaborare i dati XML, [consulta Elaborare e analizzare file XML altamente annidati e di grandi dimensioni utilizzando AWS Glue Amazon Athena](https://aws.amazon.com/blogs/big-data/process-and-analyze-highly-nested-and-large-xml-files-using-aws-glue-and-amazon-athena/) nel Big Data Blog. AWS
+ Si applicano costi separati a. AWS Glue Per ulteriori informazioni, consultare [Prezzi di AWS Glue](https://aws.amazon.com/glue/pricing).
**Topics**
+ [Risorse aggiuntive](#glue-additional-resources)
+ [Registrare e utilizzare cataloghi dati in Athena](gdc-register.md)
+ [Registrare un catalogo dati da un altro account](data-sources-glue-cross-account.md)
+ [Controlla l’accesso ai cataloghi di dati con le policy IAM](datacatalogs-iam-policy.md)
+ [Usa un modulo nella console Athena per aggiungere una tabella AWS Glue](data-sources-glue-manual-table.md)
+ [Utilizzare un crawler per aggiungere una tabella](schema-crawlers.md)
+ [Ottimizza le query con l'indicizzazione e il AWS Glue filtraggio delle partizioni](glue-best-practices-partition-index.md)
+ [Utilizzare il AWS CLI per ricreare un AWS Glue database e le relative tabelle](glue-recreate-db-and-tables-cli.md)
+ [Creare tabelle per processi ETL](schema-classifier.md)
+ [Lavora con dati CSV in AWS Glue](schema-csv.md)
+ [Lavora con dati geospaziali in AWS Glue](schema-geospatial.md)
# Registrare e utilizzare cataloghi dati in Athena
Athena supporta il montaggio e il collegamento a più cataloghi di dati.
+ Puoi montare i dati di Amazon Redshift in AWS Glue Data Catalog e interrogarli da Athena senza dover copiare o spostare i dati. Per ulteriori informazioni, consultare [Portare dati Amazon Redshift in AWS Glue Data Catalog](https://docs.aws.amazon.com/lake-formation/latest/dg/managing-namespaces-datacatalog.html).
+ Collegali AWS Glue Data Catalog a fonti di dati esterne utilizzando AWS Glue connessioni e crea cataloghi federati per gestire centralmente le autorizzazioni ai dati con un controllo degli accessi granulare tramite Lake Formation. Per ulteriori informazioni, consulta [Registra la tua connessione come Catalogo Dati Glue](register-connection-as-gdc.md).
+ Creare cataloghi dai bucket di Tabelle Amazon S3 e usare Lake Formation per gestire centralmente le autorizzazioni di accesso e limitare l’accesso degli utenti agli oggetti all’interno del bucket di tabella. Per maggiori informazioni, consulta [Lavorare con Tabella Amazon S3 bucket di tabella](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-tables.html) nella Guida per l’utente Amazon S3.
**Nota**
Per qualsiasi catalogo Glue, è possibile registrare solo un catalogo a più livelli come `123412341234:my_catalog/my_child`. Non è possibile registrare un catalogo a livello singolo come `123412341234:linkcontainer` o `my_catalog`. È possibile eseguire query sui cataloghi a livello singolo solo utilizzando il catalogo dati Glue direttamente nella query Athena. Per ulteriori informazioni, consulta [Consulta AWS Glue i cataloghi di dati in Athena](gdc-register-query-the-data-source.md).
**Topics**
+ [Registrare i cataloghi di dati Redshift in Athena](gdc-register-rs.md)
+ [Registrare cataloghi federati in Athena](gdc-register-federated.md)
+ [Registrare cataloghi di bucket di tabelle S3 e consultare le tabelle di Athena](gdc-register-s3-table-bucket-cat.md)
+ [Consulta AWS Glue i cataloghi di dati in Athena](gdc-register-query-the-data-source.md)
# Registrare i cataloghi di dati Redshift in Athena
Athena è in grado di leggere e scrivere dati archiviati in cluster Redshift o namespace serverless registrati in AWS Glue Data Catalog. Ciò funziona in tandem con AWS Lake Formation, che fornisce sicurezza e governance centralizzate, garantendo che l'accesso ai dati sia gestito in modo coerente su diversi motori di query e mantenendo controlli di accesso granulari per i dati Redshift condivisi.
## Considerazioni e limitazioni
+ **Viste materializzate**: le viste materializzate di Amazon Redshift possono essere interrogate da Athena, ma la creazione di viste materializzate utilizzando Athena o Spark non è supportata.
+ Le operazioni DDL, inclusa l'impostazione della AWS Glue Data Catalog configurazione e le operazioni sulle tabelle di storage gestite di Amazon Redshift, non sono supportate.
## Prerequisiti
Prima di poter interrogare un catalogo di AWS Glue dati da Athena, completa le seguenti attività:
1. Creare e registrare un cluster Amazon Redshift o un namespace serverless su AWS Glue Data Catalog. Per ulteriori informazioni, consultare [Registrazione di un cluster su AWS Glue Data Catalog](https://docs.aws.amazon.com/redshift/latest/mgmt/register-cluster.html) o [Registrazione dei namespace su AWS Glue Data Catalog](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless_datasharing-register-namespace.html) nella Guida alla gestione di Amazon Redshift.
1. Crea un catalogo di dati AWS Lake Formation dal namespace registrato. Per ulteriori informazioni, consulta [Creazione di cataloghi federati Amazon Redshift](https://docs.aws.amazon.com/lake-formation/latest/dg/create-ns-catalog.html) nella Developer Guide. AWS Lake Formation
1. (Facoltativo) Utilizzare Lake Formation per impostare controlli di accesso dettagliati sul catalogo. Per ulteriori informazioni, consulta la sezione [Inserimento dei dati AWS Glue Data Catalog nella Developer](https://docs.aws.amazon.com/lake-formation/latest/dg/bring-your-data-overview.html) Guide. AWS Lake Formation
## Registrare un catalogo dati Redshift con la console Athena
Per registrare un catalogo dati Redshift con la console Athena, procedere come segue.
1. Apri la console Athena all'indirizzo [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/).
1. Nel pannello di navigazione scegliere **Origini dati e cataloghi**.
1. Nella pagina **Origini dati e cataloghi**, scegliere **Crea origine dati**.
1. Per **Scegli un'origine dati**, selezionare **Amazon S3 - AWS Glue Data Catalog**.
1. Nella sezione **AWS Glue Data Catalog**, per **Account di origine dati**, scegliere **AWS Glue Data Catalog in questo account**.
1. Per **Creare una tabella o registrare un catalogo**, scegli **Registra un nuovo AWS Glue catalogo**.
1. Nella sezione **Dettagli origine dati**, per **Nome origine dati)**, inserire il nome che si desidera utilizzare per specificare l’origine dati nelle query SQL o utilizzare il nome predefinito che viene generato.
1. Per **Catalogo**, scegli **Sfoglia** per cercare un elenco di AWS Glue cataloghi nello stesso account. Se non si vede alcun catalogo esistente, crearne uno nella [console AWS Glue](https://console.aws.amazon.com/glue/).
1. **Nella finestra di dialogo **Sfoglia AWS Glue cataloghi**, selezionate il catalogo che desiderate utilizzare, quindi scegliete Scegli.**
1. (Facoltativo) Per i **tag**, inserite key/value le coppie che desiderate associare all'origine dati.
1. Scegli **Next (Successivo)**.
1. Nella pagina **Rivedi e crea**, esaminare le informazioni inserite, quindi scegliere **Crea origine dei dati**.
# Registrare cataloghi federati in Athena
Dopo aver creato connessioni a origini dati federate, è possibile registrarle come cataloghi di dati federati per semplificare l’individuazione dei dati e gestire l’accesso ai dati con autorizzazioni granulari utilizzando Lake Formation. Per ulteriori informazioni, consulta [Registra la tua connessione come Catalogo Dati Glue](register-connection-as-gdc.md).
## Considerazioni e limitazioni
+ Le operazioni DDL non sono supportate nei cataloghi federati.
+ È possibile registrare i seguenti connettori con cui integrarli AWS Glue per un controllo granulare degli accessi:
+ [Archiviazione Azure Data Lake](connectors-adls-gen2.md)
+ [Azure Synapse](connectors-azure-synapse.md)
+ [BigQuery](connectors-bigquery.md)
+ [CMDB](connectors-cmdb.md)
+ [Db2](connectors-ibm-db2.md)
+ [Db2 iSeries](connectors-ibm-db2-as400.md)
+ [DocumentDB](connectors-docdb.md)
+ [DynamoDB](connectors-dynamodb.md)
+ [Archiviazione su cloud di Google](connectors-gcs.md)
+ [HBase](connectors-hbase.md)
+ [MySQL](connectors-mysql.md)
+ [OpenSearch](connectors-opensearch.md)
+ [Oracle](connectors-oracle.md)
+ [PostgreSQL](connectors-postgresql.md)
+ [Redshift](connectors-redshift.md)
+ [SAP HANA](connectors-sap-hana.md)
+ [Snowflake](connectors-snowflake.md)
+ [SQL Server](connectors-microsoft-sql-server.md)
+ [Timestream](connectors-timestream.md)
+ [TPC-DS](connectors-tpcds.md)
+ Quando si crea un collegamento a una risorsa per la federazione di connessioni Glue, il nome del [link a risorsa](https://docs.aws.amazon.com/lake-formation/latest/dg/create-resource-link-database.html) deve essere lo stesso del nome del database del produttore.
+ Al momento, vengono riconosciuti solo i nomi minuscoli di tabelle e colonne, anche se nell’origine dati non viene fatta distinzione tra maiuscole e minuscole.
# Registrare cataloghi di bucket di tabelle S3 e consultare le tabelle di Athena
I bucket di tabelle Amazon S3 sono un tipo di bucket in Amazon S3 progettato appositamente per archiviare dati tabulari nelle tabelle Apache Iceberg. I bucket di tabella automatizzano le attività di gestione delle tabelle come la compattazione, la gestione delle istantanee e la rimozione di oggetti inutili per ottimizzare continuamente le prestazioni delle query e ridurre al minimo i costi. Sia per chi è agli inizi sia per chi ha migliaia di tabelle nel proprio ambiente Iceberg, i bucket di tabella semplificano i data lake a qualsiasi dimensione. Per ulteriori informazioni sui bucket, consultare [Bucket di tabella](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-tables-buckets.html).
## Considerazioni e limitazioni
+ Tutte le operazioni DDL supportate per le tabelle Iceberg sono supportate anche per le tabelle S3 con le seguenti eccezioni:
+ `ALTER TABLE RENAME`, `CREATE VIEW` e `ALTER DATABASE` non sono supportate.
+ `OPTIMIZE` e `VACUUM`: è possibile controllare compattazione e la gestione delle istantanee in S3. Per ulteriori informazioni, consultare [Documentazione per la manutenzione di Tabelle S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-tables-maintenance.html).
+ Le query DDL sulle tabelle S3 registrate come origini dati Athena non sono supportate.
+ Il riutilizzo dei risultati delle query non è supportato.
+ Nei gruppi di lavoro con SSE-KMS, crittografia CSE-KMS abilitata, non è possibile eseguire operazioni di scrittura come`INSERT`, `UPDATE`, `DELETE` o `MERGE` su tabelle S3.
+ Nei gruppi di lavoro con l’opzione S3 Requester Pays abilitata, non è possibile eseguire operazioni DML su tabelle S3.
## Eseguire query su tabelle S3 da Athena
**Completare questi passaggi preliminari prima di eseguire query su Tabelle S3 in Athena**
1. Creare un bucket per tabelle S3 Per ulteriori informazioni, consultare [Creazione di un bucket per tabelle](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-tables-buckets-create.html) nella Guida per l’utente di Amazon Simple Storage Service.
1. Assicurati che l'integrazione dei tuoi secchielli da tavolo con abbia successo. AWS Glue Data Catalog Per le autorizzazioni e i passaggi di configurazione richiesti, consulta [Prerequisiti per l'integrazione di S3 Tables](https://docs.aws.amazon.com/glue/latest/dg/s3tables-catalog-prerequisites.html) e [Enabling S3 Tables integration con Glue Data Catalog](https://docs.aws.amazon.com/glue/latest/dg/enable-s3-tables-catalog-integration.html) nella Developer Guide. AWS Glue
1. Per il principale che usi per eseguire le query con Athena, concedi le autorizzazioni sul catalogo S3 Table utilizzando uno dei seguenti approcci:
**Opzione 1: utilizza le autorizzazioni IAM**
Quando si utilizza il controllo degli accessi IAM, il principale necessita delle autorizzazioni sia per le risorse che per AWS Glue Data Catalog le risorse di Amazon S3 Tables.
L'elenco seguente contiene tutte le `s3tables` autorizzazioni necessarie per eseguire qualsiasi operazione DDL o DML supportata sulle tabelle S3 in Athena:
+ `s3tables:GetTableBucket`
+ `s3tables:GetNamespace`
+ `s3tables:GetTable`
+ `s3tables:GetTableData`
+ `s3tables:PutTableData`
+ `s3tables:ListNamespaces`
+ `s3tables:ListTables`
+ `s3tables:DeleteNamespace`
+ `s3tables:DeleteTable`
+ `s3tables:CreateNamespace`
+ `s3tables:CreateTable`
+ `s3tables:UpdateTableMetadataLocation`
Applica queste autorizzazioni a specifiche risorse S3 table bucket e S3 Table o usale `*` come risorsa per concedere l'accesso a tutti i table bucket e le tabelle del tuo account. Queste autorizzazioni possono essere combinate con la politica [https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonAthenaFullAccess.html](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonAthenaFullAccess.html)gestita per abilitare funzionalità complete.
**Opzione 2: utilizzare le autorizzazioni di Lake Formation**
In alternativa, per abilitare un controllo granulare degli accessi, puoi concedere le autorizzazioni di Lake Formation sul catalogo S3 Table, tramite la console Lake Formation o. AWS CLI Ciò richiede la registrazione dei bucket di tabella S3 come posizione dati di Lake Formation. Per ulteriori informazioni, consulta la sezione [Creazione di un catalogo Amazon S3 Tables AWS Glue Data Catalog nella](https://docs.aws.amazon.com/lake-formation/latest/dg/create-s3-tables-catalog.html) Lake Formation Developer Guide.
------
#### [ Console di gestione AWS ]
1. Apri la AWS Lake Formation console all'indirizzo [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/) e accedi come amministratore del data lake. Per ulteriori informazioni su come creare un amministratore di data lake, consulta [Creare un amministratore di data lake](https://docs.aws.amazon.com/lake-formation/latest/dg/initial-lf-config.html#create-data-lake-admin).
1. Nel riquadro di navigazione scegli **Autorizzazioni dati**, quindi seleziona **Concedi**.
1. Nella pagina **Concedi autorizzazioni**, in **Principali**, scegliere il principale che si desidera utilizzare per inviare la query da Athena.
1. In **LF-Tags o risorse del catalogo**, scegli **Risorse Catalogo dati denominato**.
1. Per **Cataloghi**, scegli un catalogo di dati di Glue creato dall'integrazione del proprio bucket di tabelle. Ad esempio, ** :s3tablescatalog/. *amzn-s3-demo-bucket*
1. Per le **Autorizzazioni del catalogo**, scegliere **Super**.
1. Scegliere **Concedi**.
------
#### [ AWS CLI ]
Eseguire il comando seguente con il ruolo di amministratore del data lake di Lake Formation per concedere l’accesso al principale utilizzato per inviare la query da Athena.
```
aws lakeformation grant-permissions \
--region \
--cli-input-json \
'{
"Principal": {
"DataLakePrincipalIdentifier": ":role/ExampleRole>"
},
"Resource": {
"Catalog": {
"Id":":s3tablescatalog/amzn-s3-demo-bucket"
}
},
"Permissions": ["ALL"]
}'
```
------
**Inviare query per Tabelle S3**
1. Inviare una query `CREATE DATABASE` da Athena con l’utente/ruolo di cui sopra. In questo esempio, `s3tablescatalog` è il Catalogo dati Glue principale creato dall’integrazione e ` s3tablescatalog/amzn-s3-demo-bucket` è il Catalogo dati Glue secondario creato per ogni bucket di tabelle S3. Esistono due modi per eseguire una query.
------
#### [ Option 1 ]
Specificare il file secondario Glue Data Catalog (`s3tablescatalog/amzn-s3-demo-bucket`) direttamente dalla console o AWS CLI.
**Usando Console di gestione AWS**
1. Apri la console Athena all'indirizzo [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/).
1. Nella barra di navigazione a sinistra, per **Nome dell'origine dati**, scegli **AwsDataCatalog**.
1. Per **Catalog**, scegli ***amzn-s3-demo-bucket*s3tablescatalog/**.
1. Nell’editor di query, inserire una query come `CREATE DATABASE test_namespace`.
**Usando AWS CLI**
Eseguire il seguente comando seguente.
```
aws athena start-query-execution \
--query-string 'CREATE DATABASE `test_namespace`' \
--query-execution-context '{"Catalog": "s3tablescatalog/amzn-s3-demo-bucket"}' \
--work-group "primary"
```
------
#### [ Option 2 ]
Creare il catalogo dati Athena dal Catalogo dati Glue secondario nella console Athena e specificarlo come catalogo nella query. Per ulteriori informazioni, consulta [Registrare i cataloghi di bucket di tabelle S3 come origini dati Athena](#gdc-register-s3-table-console-steps).
------
1. Con il database creato nel passaggio precedente, utilizzare `CREATE TABLE` per creare una tabella. L’esempio seguente crea una tabella nel database *`test_namespace`* creato in precedenza nel catalogo Glue `s3tablescatalog/amzn-s3-demo-bucket`.
------
#### [ Console di gestione AWS ]
1. Nella barra di navigazione a sinistra, per **Nome dell'origine dati**, scegli **AwsDataCatalog**.
1. Per **Catalog**, scegli ***amzn-s3-demo-bucket*s3tablescatalog/**.
1. Per **Database**, scegli **test\$1namespace**.
1. Nell’editor di query, eseguire la seguente query.
```
CREATE TABLE daily_sales (
sale_date date,
product_category
string, sales_amount double)
PARTITIONED BY (month(sale_date))
TBLPROPERTIES ('table_type' = 'iceberg')
```
------
#### [ AWS CLI ]
Eseguire il seguente comando seguente.
```
aws athena start-query-execution \
--query-string "CREATE TABLE daily_sales (
sale_date date,
product_category
string, sales_amount double)
PARTITIONED BY (month(sale_date))
TBLPROPERTIES ('table_type' = 'iceberg')" \
--query-execution-context '{"Catalog": "s3tablescatalog/amzn-s3-demo-bucket", "Database":"test_namespace"}' \
--work-group "primary"
```
------
1. Inserire i dati nella tabella creata nel passaggio precedente.
------
#### [ Console di gestione AWS ]
1. Nella barra di navigazione a sinistra, per Nome dell'origine **dati**, scegli. **AwsDataCatalog**
1. Per **Catalog**, scegli ***amzn-s3-demo-bucket*s3tablescatalog/**.
1. Per **Database**, scegli **test\$1namespace**.
1. Nell’editor di query, eseguire la seguente query.
```
INSERT INTO daily_sales
VALUES
(DATE '2024-01-15', 'Laptop', 900.00),
(DATE '2024-01-15', 'Monitor', 250.00),
(DATE '2024-01-16', 'Laptop', 1350.00),
(DATE '2024-02-01', 'Monitor', 300.00);
```
------
#### [ AWS CLI ]
Eseguire il seguente comando.
```
aws athena start-query-execution \
--query-string "INSERT INTO \"s3tablescatalog/amzn-s3-demo-bucket\".test_namespace.daily_sales
VALUES
(DATE '2024-01-15', 'Laptop', 900.00),
(DATE '2024-01-15', 'Monitor', 250.00),
(DATE '2024-01-16', 'Laptop', 1350.00),
(DATE '2024-02-01', 'Monitor', 300.00)"\
--work-group "primary"
```
------
1. Dopo aver inserito i dati nella tabella, è possibile eseguirci una query.
------
#### [ Console di gestione AWS ]
1. Nella barra di navigazione a sinistra, per Nome dell'origine **dati**, scegli. **AwsDataCatalog**
1. Per **Catalog**, scegli ***amzn-s3-demo-bucket*s3tablescatalog/**.
1. Per **Database**, scegli **test\$1namespace**.
1. Nell’editor di query, eseguire la seguente query.
```
SELECT
product_category,
COUNT(*) AS units_sold,
SUM(sales_amount) AS total_revenue,
AVG(sales_amount) AS average_price
FROM
daily_sales
WHERE
sale_date BETWEEN DATE '2024-02-01'
AND DATE '2024-02-29'
GROUP BY
product_category
ORDER BY
total_revenue DESC
```
------
#### [ AWS CLI ]
Eseguire il seguente comando seguente.
```
aws athena start-query-execution \
--query-string "SELECT product_category,
COUNT(*) AS units_sold,
SUM(sales_amount) AS total_revenue,
AVG(sales_amount) AS average_price
FROM \"s3tablescatalog/amzn-s3-demo-bucket\".test_namespace.daily_sales
WHERE sale_date BETWEEN DATE '2024-02-01' AND DATE '2024-02-29'
GROUP BY product_category
ORDER BY total_revenue DESC"\
--work-group "primary"
```
------
## Creare tabelle S3 in Athena
Athena supporta la creazione di tabelle nei namespace di tabelle S3 esistenti o nei namespace creati in Athena con istruzioni `CREATE DATABASE`. Per creare una tabella S3 da Athena, la sintassi è la stessa di quando si [crea una normale tabella Iceberg](querying-iceberg-creating-tables.md), tranne che non si specifica il `LOCATION`, come mostrato nell’esempio seguente.
```
CREATE TABLE
[db_name.]table_name (col_name data_type [COMMENT col_comment] [, ...] )
[PARTITIONED BY (col_name | transform, ... )]
[TBLPROPERTIES ([, property_name=property_value] )]
```
È possibile creare anche tabelle S3 utilizzando le istruzioni CREATE TABLE AS SELECT (CTAS). Per ulteriori informazioni, consulta [CTAS per tabelle S3](#ctas-s3-tables).
## Registrare i cataloghi di bucket di tabelle S3 come origini dati Athena
Per registrare i cataloghi di bucket di tabelle S3 con la console Athena, completare i seguenti passaggi.
1. Apri la console Athena all'indirizzo [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/).
1. Nel pannello di navigazione scegliere **Origini dati e cataloghi**.
1. Nella pagina **Origini dati e cataloghi**, scegliere **Crea origine dati**.
1. Per **Scegli un'origine dati**, selezionare **Amazon S3 - AWS Glue Data Catalog**.
1. Nella sezione **AWS Glue Data Catalog**, per **Account di origine dati**, scegliere **AWS Glue Data Catalog in questo account**.
1. **Per **Crea una tabella o registra un catalogo, scegli Registra un nuovo catalogo**. AWS Glue **
1. Nella sezione **Dettagli origine dati**, per **Nome origine dati)**, inserire il nome che si desidera utilizzare per specificare l’origine dati nelle query SQL o utilizzare il nome predefinito che viene generato.
1. Per **Catalogo**, scegli **Sfoglia** per cercare un elenco di AWS Glue cataloghi nello stesso account. Se non si vede alcun catalogo esistente, crearne uno nella [console AWS Glue](https://console.aws.amazon.com/glue/).
1. **Nella finestra di dialogo **Sfoglia AWS Glue cataloghi**, selezionate il catalogo che desiderate utilizzare, quindi scegliete Scegli.**
1. (Facoltativo) Per i **tag**, inserite key/value le coppie che desiderate associare all'origine dati.
1. Scegli **Next (Successivo)**.
1. Nella pagina **Rivedi e crea**, esaminare le informazioni inserite, quindi scegliere **Crea origine dati**.
## CTAS per tabelle S3
Amazon Athena ora supporta le operazioni CREATE TABLE AS SELECT (CTAS) per le tabelle S3. Questa funzionalità consente di creare nuove tabelle S3 in base ai risultati di una query SELECT.
Quando si crea una query CTAS per una tabella S3, ci sono alcune importanti differenze rispetto alle tabelle Athena standard:
+ È necessario omettere la proprietà posizione perché le tabelle S3 gestiscono automaticamente le proprie posizioni di archiviazione.
+ La proprietà `table_type` è impostata su `ICEBERG`, quindi non è necessario specificarla esplicitamente nella query.
+ Se non si specifica un formato, il sistema utilizza automaticamente `PARQUET` come formato predefinito per i dati.
+ Tutte le altre proprietà seguono la stessa sintassi delle normali tabelle Iceberg.
Prima di creare tabelle S3 utilizzando CTAS, assicurati di avere le autorizzazioni necessarie configurate in IAM o. AWS Lake Formation In particolare, sono necessarie le autorizzazioni per creare tabelle nel catalogo Tabelle S3. Senza queste autorizzazioni, le operazioni CTAS falliranno.
**Nota**
Se una query CTAS fallisce, potrebbe essere necessario eliminare la tabella utilizzando l’[API Tabelle S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-tables-delete.html) prima di tentare di rieseguire la query. Non è possibile usare le istruzioni Athena `DROP TABLE` per rimuovere la tabella che è stata parzialmente creata dalla query.
**Esempio**
```
CREATE TABLE "s3tablescatalog/amzn-s3-demo-bucket"."namespace"."s3-table-name"
WITH (
format = 'PARQUET'
)
AS SELECT *
FROM source_table;
```
# Consulta AWS Glue i cataloghi di dati in Athena
Per eseguire una query sui cataloghi dati da Athena, effettuare una delle seguenti operazioni.
+ Registrare il catalogo in Athena come origine dati, quindi usare il nome dell’origine dati per eseguire query nel catalogo. In questo tipo di utilizzo, le seguenti query sono equivalenti.
```
SELECT * FROM my_data_source.my_database.my_table
```
+ Se si stanno eseguendo query in un catalogo che non è stato registrato come origine dati Athena, è possibile fornire il percorso completo del catalogo nelle query `SELECT`, come nel seguente esempio.
```
SELECT * FROM "my_catalog/my_subcatalog".my_database.my_table
```
+ Puoi farlo anche tramite. Console di gestione AWS
1. Apri la console Athena all'indirizzo [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/)
1. Nell'editor di query, per **Origine dati**, scegli **AwsDataCatalog**.
1. Per **Catalogo**, scegliere il nome del catalogo che si desidera utilizzare.
1. Per **Database**, scegliere il database che contiene la tabella su cui si desidera eseguire una query.
1. Inserire una query come `SELECT * FROM my_table`, quindi scegliere **Esegui**.
# Registrare un catalogo dati da un altro account
Puoi utilizzare la funzionalità di AWS Glue catalogo multiaccount di Athena per registrare un AWS Glue catalogo da un account diverso dal tuo. Dopo aver configurato le autorizzazioni IAM richieste per AWS Glue e registrato il catalogo come risorsa Athena `DataCatalog`, puoi utilizzare Athena per eseguire query tra account. Per informazioni sulla configurazione delle autorizzazioni richieste, consulta [Configurare l'accesso tra account ai cataloghi di AWS Glue dati](security-iam-cross-account-glue-catalog-access.md).
La procedura seguente mostra come utilizzare Athena per configurare un AWS Glue Data Catalog account Amazon Web Services diverso dal tuo come origine dati.
## Registrare dalla console
1. Segui la procedura riportata in [Configurare l'accesso tra account ai cataloghi di AWS Glue dati](security-iam-cross-account-glue-catalog-access.md) per verificare di disporre delle autorizzazioni per eseguire query sul catalogo dati nell'altro account.
1. Apri la console Athena all'indirizzo [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
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. Selezionare **Data sources and catalogs**.
1. Nell'angolo in alto a destra, scegli **Create data source** (Crea origine dei dati).
1. **Nella pagina **Scegli un'origine dati**, per **Origini dati**, scegli **S3 - AWS Glue Data Catalog**, quindi scegli Avanti.**
1. Nella pagina **Inserisci dettagli origine dati**, nella sezione **AWS Glue Data Catalog**, per **Scegli un AWS Glue Data Catalog**, seleziona **AWS Glue Data Catalog in un altro account**.
1. Per **Dataset details** (Dettagli del set di dati), fornisci le seguenti informazioni:
+ **Nome origine dati**: inserisci il nome che desideri utilizzare nelle query SQL per fare riferimento al catalogo dati nell'altro account.
+ **Descrizione** — (Facoltativo) Inserisci una descrizione del catalogo dati nell'altro account.
+ **ID catalogo** — Inserisci l'ID account Amazon Web Services a 12 cifre dell'account a cui appartiene il catalogo dati. L'ID dell'account Amazon Web Services è l'ID del catalogo.
1. (Facoltativo) Per **Tag**, inserisci le coppie chiave-valore da associare all'origine dati. Per ulteriori informazioni sui tag, consulta [Assegnare tag alle risorse di Athena](tags.md).
1. Scegli **Next (Successivo)**.
1. Nella pagina **Review and create** (Rivedi e crea), esamina le informazioni inserite, quindi scegli **Create data source** (Crea origine dei dati). La pagina **Data source details** (Dettagli sull'origine dei dati) elenca i database e i tag per il catalogo dati registrato.
1. Scegliere **Data sources and catalogs** Il catalogo dati che hai registrato è elencato nella colonna **Data source name** (Nome origine dei dati).
1. Per visualizzare o modificare le informazioni sul catalogo dati, scegli il catalogo, quindi scegli **Actions** (Operazioni), **Edit** (Modifica).
1. Per eliminare il nuovo catalogo dati, scegli il catalogo, quindi scegli **Actions** (Operazioni), **Delete** (Elimina).
## Registrare mediante operazioni API
1. Il seguente corpo della `CreateDataCatalog` richiesta registra un AWS Glue catalogo per l'accesso su più account:
```
# Example CreateDataCatalog request to register a cross-account Glue catalog:
{
"Description": "Cross-account Glue catalog",
"Name": "ownerCatalog",
"Parameters": {"catalog-id" : "" # Owner's account ID
},
"Type": "GLUE"
}
```
1. Il codice di esempio seguente utilizza un client Java per creare l'oggetto `DataCatalog`.
```
# Sample code to create the DataCatalog through Java client
CreateDataCatalogRequest request = new CreateDataCatalogRequest()
.withName("ownerCatalog")
.withType(DataCatalogType.GLUE)
.withParameters(ImmutableMap.of("catalog-id", ""));
athenaClient.createDataCatalog(request);
```
Dopo questi passaggi, il mutuatario dovrebbe vedere *`ownerCatalog`* quando chiama l'operazione API. [ListDataCatalogs](https://docs.aws.amazon.com/athena/latest/APIReference/API_ListDataCatalogs.html)
## Registrati utilizzando AWS CLI
Usa il seguente comando CLI di esempio per registrare AWS Glue Data Catalog un annuncio da un altro account
```
aws athena create-data-catalog \
--name cross_account_catalog \
--type GLUE \
--description "Cross Account Catalog" \
--parameters catalog-id=
```
Per ulteriori informazioni, consulta [Eseguire query su più account AWS Glue Data Catalog utilizzando Amazon](https://aws.amazon.com/blogs/big-data/query-cross-account-aws-glue-data-catalogs-using-amazon-athena/) Athena nel blog *AWS sui Big Data*.
# Controlla l’accesso ai cataloghi di dati con le policy IAM
Per controllare l'accesso ai cataloghi dati, usa le autorizzazioni IAM a livello di risorsa o le policy IAM basate sull'identità.
La seguente procedura è specifica di Athena.
Per informazioni specifiche su IAM, segui i collegamenti elencati alla fine di questa sezione. Per informazioni sulle policy di esempio relative al catalogo dati JSON, consulta [Policy di esempio del catalogo dati](datacatalogs-example-policies.md).
**Per utilizzare l'editor visivo nella console IAM per creare una policy del catalogo dati.**
1. Accedi Console di gestione AWS e apri la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Nel pannello di navigazione sulla sinistra, selezionare **Policies** (Policy) e fare clic su **Create Policy** (Crea policy).
1. Nella scheda **Visual editor (Editor visivo)**, selezionare **Choose a Service (Scegli un servizio)**. Quindi selezionare Athena per aggiungerlo alla policy.
1. Scegliere **Select actions (Seleziona operazioni)**, quindi scegliere le operazioni da aggiungere alla policy. L'editor visivo mostra le operazioni disponibili in Athena. Per ulteriori informazioni, consulta [Operazioni, risorse e chiavi di condizione per Amazon Athena](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonathena.html) nella *Documentazione di riferimento per l'autorizzazione ai servizi*.
1. Scegliere **add actions (aggiungi operazioni)** per immettere un'operazione oppure usare i caratteri jolly (\$1) per specificare più operazioni.
Come impostazione predefinita, la policy che si sta creando utilizza le operazioni selezionate. Se si selezionano una o più operazioni che supportano le autorizzazioni a livello di risorsa per la risorsa `datacatalog` in Athena, l'editor elenca la risorsa `datacatalog`
1. Selezionare **Resources (Risorse)** per specificare i cataloghi dati per la policy. Per le policy di esempio relative al catalogo dati JSON, consultare [Policy di esempio del catalogo dati](datacatalogs-example-policies.md).
1. Specificare la risorsa `datacatalog` come segue:
```
arn:aws:athena:::datacatalog/
```
1. Scegliere **Review policy (Rivedi policy)** e digitare i valori per **Name (Nome)** e **Description (Descrizione)** (facoltativa) per la policy che si sta creando. Esaminare il riepilogo della policy per accertarsi di disporre delle autorizzazioni desiderate.
1. Seleziona **Crea policy** per salvare la nuova policy.
1. Collegare questa policy basata sull'identità a un utente, un gruppo o un ruolo e specificare le risorse `datacatalog` a cui possono accedere.
Per ulteriori informazioni, consulta gli argomenti seguenti nella *Referenza sull'autorizzazione del servizio* e la *Guida per l'utente di IAM*:
+ [Operazioni, risorse e chiavi di condizione per Amazon Athena](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonathena.html)
+ [Creazione di policy con l'editor visivo](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html#access_policies_create-visual-editor)
+ [Aggiunta e rimozione delle policy IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html)
+ [Controllo dell'accesso alle risorse](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_controlling.html#access_controlling-resources)
Per le policy di esempio relative al catalogo dati JSON, consultare [Policy di esempio del catalogo dati](datacatalogs-example-policies.md).
*Per informazioni sulle AWS Glue autorizzazioni e sulle autorizzazioni del AWS Glue crawler, consulta [Configurazione delle autorizzazioni IAM AWS Glue e dei prerequisiti del [crawler](https://docs.aws.amazon.com/glue/latest/dg/crawler-prereqs.html) nella Guida per gli](https://docs.aws.amazon.com/glue/latest/dg/getting-started-access.html) sviluppatori.AWS Glue *
Per un elenco completo delle operazioni Amazon Athena, consulta i nomi delle operazioni API nella [documentazione di riferimento dell'API Amazon Athena](https://docs.aws.amazon.com/athena/latest/APIReference/).
# Policy di esempio del catalogo dati
Questa sezione include policy di esempio che puoi utilizzare per abilitare varie operazioni sui cataloghi dati.
Un catalogo dati è una risorsa IAM gestita da Athena. Pertanto, se la policy del catalogo dati utilizza operazioni che accettano `datacatalog` come input, devi specificare l'ARN del catalogo dati nel modo seguente:
```
"Resource": [arn:aws:athena:::datacatalog/]
```
`` è il nome del catalogo dati. Ad esempio, per un catalogo dati denominato `test_datacatalog`, specificalo come risorsa nel modo seguente:
```
"Resource": ["arn:aws:athena:us-east-1:123456789012:datacatalog/test_datacatalog"]
```
Per un elenco completo delle operazioni Amazon Athena, consulta i nomi delle operazioni API nella [documentazione di riferimento dell'API Amazon Athena](https://docs.aws.amazon.com/athena/latest/APIReference/). Per ulteriori informazioni sulle policy IAM, consulta [Creazione di policy con l'editor visivo](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html#access_policies_create-visual-editor) nella *Guida per l'utente di IAM*. Per ulteriori informazioni sulla creazione di policy IAM per i gruppi di lavoro, consulta [Controlla l’accesso ai cataloghi di dati con le policy IAM](datacatalogs-iam-policy.md).
+ [Example Policy for Full Access to All Data Catalogs](#datacatalog-policy-full-access-to-all-data-catalogs)
+ [Example Policy for Full Access to a Specified Data Catalog](#datacatalog-policy-full-access-to-a-specified-catalog)
+ [Example Policy for Querying a Specified Data Catalog](#datacatalog-policy-querying-a-specified-data-catalog)
+ [Example Policy for Management Operations on a Specified Data Catalog](#datacatalog-policy-management-operations-on-a-specified-catalog)
+ [Example Policy for Listing Data Catalogs](#datacatalog-policy-listing-data-catalogs)
+ [Example Policy for Metadata Operations on Data Catalogs](#datacatalog-policy-metadata-operations)
**Example Esempio di policy per l'accesso completo a tutti i cataloghi dati**
La policy seguente consente l'accesso completo a tutte le risorse del catalogo dati che potrebbero essere presenti nell'account. Ti consigliamo di utilizzare questa policy per gli utenti nell'account che devono amministrare e gestire cataloghi dati per tutti gli altri utenti.
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"athena:*"
],
"Resource":[
"*"
]
}
]
}
```
**Example Esempio di policy per l'accesso completo a un catalogo dati specifico**
La policy seguente consente l'accesso completo a una specifica risorsa del catalogo dati denominata `datacatalogA`. Puoi usare questa policy per gli utenti con controllo completo su un determinato catalogo dati.
****
```
{ "Version":"2012-10-17", "Statement":[ { "Effect":"Allow", "Action":[
"athena:ListDataCatalogs", "athena:ListWorkGroups", "athena:GetDatabase", "athena:ListDatabases",
"athena:ListTableMetadata", "athena:GetTableMetadata" ], "Resource":"*" }, { "Effect":"Allow",
"Action":[ "athena:StartQueryExecution", "athena:GetQueryResults", "athena:DeleteNamedQuery",
"athena:GetNamedQuery", "athena:ListQueryExecutions", "athena:StopQueryExecution",
"athena:GetQueryResultsStream", "athena:ListNamedQueries", "athena:CreateNamedQuery",
"athena:GetQueryExecution", "athena:BatchGetNamedQuery", "athena:BatchGetQueryExecution",
"athena:DeleteWorkGroup", "athena:UpdateWorkGroup", "athena:GetWorkGroup",
"athena:CreateWorkGroup" ], "Resource":[
"arn:aws:athena:us-east-1:123456789012:workgroup/*"
] }, { "Effect":"Allow", "Action":[ "athena:CreateDataCatalog", "athena:DeleteDataCatalog",
"athena:GetDataCatalog", "athena:GetDatabase", "athena:GetTableMetadata", "athena:ListDatabases",
"athena:ListTableMetadata", "athena:UpdateDataCatalog" ],
"Resource":"arn:aws:athena:us-east-1:123456789012:datacatalog/datacatalogA"
} ] }
```
**Example Esempio di policy per l'esecuzione di query su un catalogo dati specifico**
Nella policy seguente, a un utente è consentito eseguire query nel gruppo `datacatalogA` specificato. All'utente non è consentito eseguire attività di gestione per il catalogo dati, ad esempio l'aggiornamento o l'eliminazione.
****
```
{ "Version":"2012-10-17", "Statement":[ { "Effect":"Allow", "Action":[
"athena:StartQueryExecution" ], "Resource":[
"arn:aws:athena:us-east-1:123456789012:workgroup/*"
] }, { "Effect":"Allow", "Action":[ "athena:GetDataCatalog" ], "Resource":[
"arn:aws:athena:us-east-1:123456789012:datacatalog/datacatalogA"
] } ] }
```
**Example Esempio di policy per le operazioni di gestione in un catalogo dati specifico**
Nel policy seguente, un utente può creare, eliminare, ottenere i dettagli e aggiornare un catalogo dati `datacatalogA`.
****
```
{ "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [
"athena:CreateDataCatalog", "athena:GetDataCatalog", "athena:DeleteDataCatalog",
"athena:UpdateDataCatalog" ], "Resource": [
"arn:aws:athena:us-east-1:123456789012:datacatalog/datacatalogA"
] } ] }
```
**Example Esempio di policy per elencare cataloghi dati**
La policy seguente consente a tutti gli utenti per elencare tutti i cataloghi dati:
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"athena:ListDataCatalogs"
],
"Resource": "*"
}
]
}
```
**Example Esempio di policy per le operazioni relative a metadati sui cataloghi dati**
La seguente policy consente operazioni relative ai metadati sui cataloghi dati:
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"athena:GetDatabase",
"athena:GetTableMetadata",
"athena:ListDatabases",
"athena:ListTableMetadata"
],
"Resource": "*"
}
]
}
```
# Usa un modulo nella console Athena per aggiungere una tabella AWS Glue
Nella procedura seguente viene illustrato come utilizzare la console Athena per aggiungere una tabella utilizzando il modulo **Crea tabella dai dati del bucket S3**.
**Per aggiungere una tabella e immettere le informazioni sullo schema utilizzando un modulo**
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, accanto a **Tables and views** (Tabelle e visualizzazioni), scegli **Create** (Crea) e quindi scegli **S3 bucket data.** (Dati del bucket S3).
1. Nel modulo **Create Table From S3 bucket data** (Crea tabella dai dati del bucket S3), per **Table name** (Nome tabella), inserisci un nome per la tabella. 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).
1. Per **Database configuration** (Configurazione database), scegli un database esistente o creane uno nuovo.
1. Per **Posizione del set di dati di input**, specificare il percorso in Amazon S3 alla cartella contenente il set di dati che si desidera elaborare. Non includere un nome di file nel percorso. Athena esegue la scansione di tutti i file contenuti nella cartella specificata. Se i dati sono già partizionati (ad esempio,
s3://amzn-s3-demo -bucket/logs/year=2004/month=12/day=11/), enter the base path only (for example, s3://amzn-s3-demo-bucket/logs/).
1. Per **Data Format** (Formato dei dati), scegli tra le seguenti opzioni:
+ In **Table type** (Tipo di tabella), scegli **Apache Hive**, **Apache Iceberg** o **Delta Lake**. Per impostazione predefinita, Athena utilizza il tipo di tabella Apache Hive. Per informazioni sull'esecuzione di query sulle tabelle Apache Iceberg in Athena, consulta la pagina [Tabelle Apache Iceberg](querying-iceberg.md). Per informazioni sull'utilizzo delle tabelle Delta Lake in Athena, consulta la pagina [Tabelle Delta Lake di Linux Foundation](delta-lake-tables.md).
+ Per **File format** (Formato file), scegli il formato di file o log in cui si trovano i dati.
+ Per l'opzione **Text File with Custom Delimiters (File di testo con delimitatori personalizzati)**, specificare un **Field terminator (Carattere di terminazione del campo)** (ovvero, un delimitatore di colonna). Facoltativamente, puoi specificare un **Collection terminator** (carattere di terminazione della raccolta) che segna la fine di un tipo di array o un **Collection terminator** (carattere di terminazione della raccolta) che segna la fine di un tipo di dati mappa.
+ **SerDe libreria** — Una libreria SerDe (serializzatore-deserializzatore) analizza un particolare formato di dati in modo che Athena possa creare una tabella corrispondente. Per la maggior parte dei formati, viene scelta automaticamente una libreria predefinita. SerDe Per i formati seguenti, scegli una libreria in base alle tue esigenze:
+ **Apache Web Logs**: scegli la libreria **RegexSerDe**o **GrokSerDe**. Per RegexSerDe, fornisci un'espressione regolare nella casella di definizione **Regex**. Per GrokSerDe, fornite una serie di espressioni regolari denominate per la `input.format` SerDe proprietà. Le espressioni regolari denominate sono più facili da leggere e gestire rispetto alle espressioni regolari. Per ulteriori informazioni, consulta [Eseguire query sui log Apache archiviati in Amazon S3](querying-apache-logs.md).
+ **CSV**: scegli **LazySimpleSerDe**se i tuoi dati separati da virgole non contengono valori racchiusi tra virgolette o se utilizzano il formato. `java.sql.Timestamp` Scegli **Open CSVSer De** se i dati includono virgolette o utilizzano il formato numerico UNIX per (ad esempio,). `TIMESTAMP` `1564610311` Per ulteriori informazioni, consultare [Lazy SerDe Simple per file CSV, TSV e delimitati in modo personalizzato](lazy-simple-serde.md) e [Apri CSV SerDe per l'elaborazione di CSV](csv-serde.md).
+ **JSON**: scegli la libreria JSON **OpenX** **o SerDe Hive**. Entrambi i formati prevedono che ogni documento JSON si trovi su una singola riga di testo e che i campi non siano separati da caratteri di nuova riga. L'OpenX SerDe offre alcune proprietà aggiuntive. Per ulteriori informazioni su queste proprietà, consultare [OpenX JSON SerDe](openx-json-serde.md). Per informazioni su Hive SerDe, vedere. [JSON Hive SerDe](hive-json-serde.md)
Per ulteriori informazioni sull'uso delle SerDe librerie in Athena, consulta. [Scegli un file SerDe per i tuoi dati](supported-serdes.md)
1. Per **SerDe le proprietà**, aggiungi, modifica o rimuovi proprietà e valori in base alla SerDe libreria che stai utilizzando e ai tuoi requisiti.
+ Per aggiungere una SerDe proprietà, scegli **Aggiungi SerDe proprietà**.
+ Nel campo **Name** (Nome), immetti il nome della proprietà.
+ Nel campo **Value** (Valore), immetti un valore per la proprietà.
+ Per rimuovere una SerDe proprietà, scegli **Rimuovi**.
1. Per **Table properties** (Proprietà tabella), scegli o modifica le proprietà della tabella in base alle tue esigenze.
+ Per **Write compression** (Compressione per la scrittura), scegli un'opzione di compressione. La disponibilità dell'opzione di compressione in scrittura e delle altre opzioni di compressione disponibili dipende dal formato dei dati. Per ulteriori informazioni, consulta [Usa la compressione in Athena](compression-formats.md).
+ Per **Encryption** (Crittografia), seleziona **Encrypted data set** (Set di dati crittografati) se i dati sottostanti sono crittografati in Amazon S3. Questa opzione imposta la proprietà della tabella `has_encrypted_data` su true nell'istruzione `CREATE TABLE`.
1. Per **Column details** (Dettagli della colonna), inserisci i nomi e i tipi di dati delle colonne che desideri aggiungere alla tabella.
+ Per aggiungere più colonne una alla volta, scegliere **Add a column (Aggiungi una colonna)**.
+ Per aggiungere rapidamente più colonne, scegliere **Bulk add columns (Aggiungi colonne in blocco)**. Nella casella di testo, immettete un elenco di colonne separate da virgole nel formato *column\$1name* *data\$1type* [*column\$1name**data\$1type*,...], quindi **scegliete Aggiungi**.
1. (Facoltativo) Per **Partition details** (Dettagli delle partizioni), aggiungi uno o più nomi di colonna e tipi di dati. Il partizionamento tiene insieme i dati correlati in base ai valori delle colonne e consente di ridurre la quantità di dati analizzati per query. Per informazioni sulle partizioni, consulta [Come partizionare i dati](partitions.md).
1. (Facoltativo) In **Bucketing** puoi specificare una o più colonne contenenti le righe da raggruppare e inserire tali righe in più bucket. Ciò consente di eseguire query solo sul bucket che si desidera leggere quando si specifica il valore delle colonne con bucket.
+ Per **Buckets** (Bucket), seleziona una o più colonne con un numero elevato di valori univoci (ad esempio, una chiave primaria) utilizzate di frequente per filtrare i dati nelle query.
+ In **Number of buckets** (Numero di bucket), immetti un numero che consenta ai file di avere dimensioni ottimali. 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 specificare le colonne con bucket, l'istruzione `CREATE TABLE` utilizza la sintassi seguente:
```
CLUSTERED BY (bucketed_columns) INTO number_of_buckets BUCKETS
```
**Nota**
L'opzione **Bucketing** non è disponibile per i tipi di tabella **Iceberg**.
1. Nella casella **Preview table query** (Anteprima della query della tabella) viene visualizzata l'istruzione `CREATE TABLE` generata dalle informazioni immesse nel modulo. L'istruzione di anteprima non può essere modificata direttamente. Per modificare l'istruzione, modifica i campi del modulo sopra l'anteprima oppure [crea direttamente l'istruzione](creating-tables-how-to.md#to-create-a-table-using-hive-ddl) nell'editor di query anziché utilizzare il modulo.
1. Scegli **Create table** (Crea tabella) per eseguire l'istruzione generata nell'editor di query e crea la tabella.
# Utilizzare un crawler per aggiungere una tabella
AWS Glue i crawler aiutano a scoprire lo schema per i set di dati e a registrarli come tabelle nel Data Catalog. AWS Glue I crawler analizzano i dati e ne determinano lo schema. Inoltre, il crawler è in grado di rilevare e registrare le partizioni. Per ulteriori informazioni, consultare [Definizione di crawler](https://docs.aws.amazon.com/glue/latest/dg/add-crawler.html) nella *Guida per gli sviluppatori di AWS Glue *. Le tabelle dei dati correttamente sottoposte a ricerca per indicizzazione possono essere interrogate da Athena.
**Nota**
Athena non riconosce i [pattern di esclusione](https://docs.aws.amazon.com/glue/latest/dg/define-crawler.html#crawler-data-stores-exclude) specificati per un AWS Glue crawler. Ad esempio, se disponi di un bucket Amazon S3 che contiene i file `.csv` e `.json` ed escludi i file `.json` dal crawler, Athena esegue query su entrambi i gruppi di file. Per evitare ciò, posizionare i file che si desidera escludere in una posizione diversa.
## Create un crawler AWS Glue
Puoi creare un crawler partendo dalla console Athena e quindi utilizzando la console AWS Glue in un modo integrato. Quando crei il crawler, specifica una posizione dei dati in Amazon S3 per eseguire la ricerca per indicizzazione.
**Per creare un crawler AWS Glue partendo dalla console Athena**
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, accanto a **Tabelle e visualizzazioni**, scegli **Crea** e quindi scegli **Crawler AWS Glue **.
1. Sulla pagina**Aggiungi crawler** della console **AWS Glue**, segui i passaggi per creare un crawler. *Per ulteriori informazioni, consulta [Using AWS Glue Crawler](#schema-crawlers) in questa guida e [Population the nella Developer Guide. AWS Glue Data Catalog](https://docs.aws.amazon.com/glue/latest/dg/populate-catalog-methods.html)AWS Glue *
**Nota**
Athena non riconosce i [pattern di esclusione](https://docs.aws.amazon.com/glue/latest/dg/define-crawler.html#crawler-data-stores-exclude) specificati per un AWS Glue crawler. Ad esempio, se disponi di un bucket Amazon S3 che contiene i file `.csv` e `.json` ed escludi i file `.json` dal crawler, Athena esegue query su entrambi i gruppi di file. Per evitare ciò, posizionare i file che si desidera escludere in una posizione diversa.
Dopo una scansione, il AWS Glue crawler assegna automaticamente determinati metadati alla tabella per renderla compatibile con altre tecnologie esterne come Apache Hive, Presto e Spark. Occasionalmente, il crawler potrebbe assegnare le proprietà dei metadati in modo errato. Correggete manualmente le proprietà AWS Glue prima di interrogare la tabella utilizzando Athena. Per ulteriori informazioni, consulta la sezione relativa alla [visualizzazione e modifica dei dettagli tabella](https://docs.aws.amazon.com/glue/latest/dg/console-tables.html#console-tables-details) nella *Guida per sviluppatori AWS Glue *.
AWS Glue può assegnare erroneamente i metadati quando un file CSV contiene virgolette su ogni campo di dati, sbagliando la proprietà. `serializationLib` Per ulteriori informazioni, consulta [Gestire dati CSV tra virgolette](schema-csv.md#schema-csv-quotes).
# Utilizzare più origini dati con un crawler
Quando un AWS Glue crawler esegue la scansione di Amazon S3 e rileva più directory, utilizza un'euristica per determinare dove si trova la radice di una tabella nella struttura di directory e quali directory sono partizioni per la tabella. Nei casi in cui gli schemi rilevati in due o più directory siano analoghi, il crawler potrebbe trattarli come partizioni invece di tabelle separate. Un metodo per aiutare il crawler a rilevare singole tabelle è aggiungere la directory radice di ciascuna tabella come datastore per il crawler.
Le seguenti partizioni in Amazon S3 sono un esempio:
```
s3://amzn-s3-demo-bucket/folder1/table1/partition1/file.txt
s3://amzn-s3-demo-bucket/folder1/table1/partition2/file.txt
s3://amzn-s3-demo-bucket/folder1/table1/partition3/file.txt
s3://amzn-s3-demo-bucket/folder1/table2/partition4/file.txt
s3://amzn-s3-demo-bucket/folder1/table2/partition5/file.txt
```
Se lo schema di `table1` e `table2` è simile e una singola origine dati è impostata su `s3://amzn-s3-demo-bucket/folder1/` in AWS Glue, il crawler può creare una singola tabella con due colonne di partizione: una colonna di partizione che contiene `table1` e `table2` e una seconda colonna di partizione che contiene `partition1` through`partition5`.
Per fare in modo che il AWS Glue crawler crei due tabelle separate, impostate il crawler in modo che abbia due origini dati e, `s3://amzn-s3-demo-bucket/folder1/table1/` come illustrato nella procedura seguente. `s3://amzn-s3-demo-bucket/folder1/table2`
**Per aggiungere un data store S3 a un crawler esistente in AWS Glue**
1. Accedi a Console di gestione AWS e apri la console all' AWS Glue indirizzo. [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/)
1. Nel riquadro di navigazione, selezionare **Crawler**.
1. Scegli il link al tuo crawler, quindi scegli **Edit** (Modifica).
1. Per **Fase 2: Scegli origini dei dati e classificatori**, scegli **Edit** (Modifica).
1. Nella sezione **Data sources and catalogs**, scegliere **Add a data source**.
1. Nella finestra di dialogo **Add data source** (Aggiungi origine dei dati), per **S3 path** (Percorso S3), scegli **Browse** (Sfoglia).
1. Scegli il bucket che vuoi utilizzare e poi seleziona **Choose** (Scegli).
L'origine dei dati che hai aggiunto viene visualizzata nell'elenco **Data sources** (Origini dei dati).
1. Scegli **Next (Successivo)**.
1. Nella pagina **Configure security settings** (Configura impostazioni di sicurezza), crea o scegli un ruolo IAM per il crawler, quindi scegli **Next** (Avanti).
1. Assicurati che il percorso S3 termini con una barra finale, quindi scegli **Add an S3 data source** (Aggiungi un'origine dei dati S3).
1. Nella pagina **Set output and scheduling** (Imposta l'output e la pianificazione), per **Output configuration** (Configurazione dell'output), scegli il database di destinazione.
1. Scegli **Next (Successivo)**.
1. Nella pagina **Review and update** (Verifica e aggiorna), rivedi le scelte che hai fatto. Per modificare un passaggio, scegli **Edit** (Modifica).
1. Scegliere **Aggiorna**.
# Pianifica un crawler per mantenere AWS Glue Data Catalog sincronizzati Amazon S3
AWS Glue i crawler possono essere configurati per essere eseguiti secondo una pianificazione o su richiesta. Per ulteriori informazioni, consulta la sezione relativa alle [pianificazioni per processi e crawler](https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html) nella *guida per sviluppatori di AWS Glue *.
Se disponi di dati per una tabella partizionata che arrivano a un orario fisso, puoi configurare un AWS Glue crawler da eseguire nei tempi previsti per rilevare e aggiornare le partizioni della tabella. In questo modo, non sarà più necessario eseguire un comando `MSCK REPAIR`, potenzialmente lungo e costoso, né eseguire manualmente un comando `ALTER TABLE ADD PARTITION`. Per ulteriori informazioni, consulta la sezione relativa alle [partizioni tabella](https://docs.aws.amazon.com/glue/latest/dg/tables-described.html#tables-partition) nella *guida per sviluppatori AWS Glue *.
# Ottimizza le query con l'indicizzazione e il AWS Glue filtraggio delle partizioni
Quando Athena esegue una query su tabelle partizionate, recupera e filtra le partizioni della tabella disponibili nel sottoinsieme pertinente alla query. Quando vengono aggiunti nuovi dati e partizioni, è necessario più tempo per elaborare le partizioni e il runtime delle query può aumentare. Se si dispone di una tabella con un numero elevato di partizioni che cresce nel tempo, considerare l'uso di indicizzazione e filtro delle partizioni AWS Glue . L'indicizzazione delle partizioni consente ad Athena di ottimizzare l'elaborazione delle partizioni e migliorare le prestazioni delle query su tabelle altamente partizionate. L'impostazione del filtro delle partizioni nelle proprietà di una tabella è un processo a due fasi:
1. Creazione di un indice di partizione in AWS Glue.
1. Abilitazione del filtro delle partizioni per la tabella.
## Creazione di un indice di partizione
Per istruzioni su come creare un indice di partizione in AWS Glue, consulta [Lavorare con gli indici di partizione](https://docs.aws.amazon.com/glue/latest/dg/partition-indexes.html) nella Guida per gli sviluppatori. AWS Glue Per le limitazioni relative agli indici di partizione in AWS Glue, consulta la sezione [Informazioni sugli](https://docs.aws.amazon.com/glue/latest/dg/partition-indexes.html#partition-index-1) indici di partizione in quella pagina.
## Abilitazione del filtro delle partizioni
Per abilitare il filtro delle partizioni per la tabella, è necessario impostare una nuova proprietà della tabella in AWS Glue. [Per istruzioni su come impostare le proprietà della tabella in AWS Glue, consulta la pagina Configurazione della proiezione delle partizioni.](https://docs.aws.amazon.com/athena/latest/ug/partition-projection-setting-up.html) **Quando modificate i dettagli della tabella in AWS Glue, aggiungete la seguente coppia chiave-valore alla sezione Proprietà della tabella:**
+ Per **Key** (Chiave), aggiungi `partition_filtering.enabled`
+ Per **Value** (Valore), aggiungi `true`
È possibile disabilitare la proiezione delle partizioni su questa tabella in qualsiasi momento impostando `partition_filtering.enabled` su `false`.
Dopo aver completato le fasi precedenti, sarà possibile tornare alla console Athena per eseguire la query sui dati.
*Per ulteriori informazioni sull'utilizzo dell'indicizzazione e del filtraggio delle partizioni, consulta Migliorare le [prestazioni delle query di Amazon Athena utilizzando gli indici delle AWS Glue Data Catalog partizioni](https://aws.amazon.com/blogs/big-data/improve-amazon-athena-query-performance-using-aws-glue-data-catalog-partition-indexes/) nel Big Data Blog.AWS *
# Utilizzare il AWS CLI per ricreare un AWS Glue database e le relative tabelle
Non è possibile rinominare direttamente un AWS Glue database, ma è possibile copiarne la definizione, modificarla e utilizzarla per ricreare il database con un nome diverso. Analogamente, è possibile copiare le definizioni delle tabelle nel vecchio database, modificare le definizioni e utilizzare le definizioni modificate per ricreare le tabelle nel nuovo database.
**Nota**
Il metodo presentato non copia il partizionamento delle tabelle.
La procedura seguente per Windows presuppone che l'utente AWS CLI sia configurato per l'output JSON. Per modificare il formato di output predefinito in AWS CLI, esegui. `aws configure`
**Per copiare un AWS Glue database utilizzando il AWS CLI**
1. Al prompt dei comandi, esegui il AWS CLI comando seguente per recuperare la definizione del AWS Glue database che desideri copiare.
```
aws glue get-database --name database_name
```
Per ulteriori informazioni sul comando `get-database`, consulta [get-database](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glue/get-database.html).
1. Salva l'output JSON in un file con il nome del nuovo database (ad esempio, `new_database_name.json`) sul desktop.
1. Apri il file `new_database_name.json` in un editor di testo.
1. Nel file JSON, procedere come decritto di seguito:
1. Rimuovi la voce `{ "Database":` esterna e la parentesi di chiusura corrispondente `}` alla fine del file.
1. Modificare la voce `Name` con il nuovo nome del database.
1. Rimuovi il campo `CatalogId`.
1. Salvare il file.
1. Al prompt dei comandi, esegui il AWS CLI comando seguente per utilizzare il file di definizione del database modificato per creare il database con il nuovo nome.
```
aws glue create-database --database-input "file://~/Desktop\new_database_name.json"
```
Per ulteriori informazioni sul comando `create-database`, consulta [create-database](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glue/create-database.html). Per informazioni sul caricamento AWS CLI dei parametri da un file, vedere [Caricamento AWS CLI dei parametri da un file](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-parameters-file.html) nella *Guida per l'AWS Command Line Interface utente*.
1. Per verificare che il nuovo database sia stato creato in AWS Glue, esegui il seguente comando:
```
aws glue get-database --name new_database_name
```
Ora siete pronti per ottenere la definizione di una tabella da copiare nel nuovo database, modificare la definizione e utilizzare la definizione modificata per ricreare la tabella nel nuovo database. Questa procedura non modifica il nome della tabella.
**Per copiare una AWS Glue tabella utilizzando AWS CLI**
1. Al prompt dei comandi, esegui il AWS CLI comando seguente.
```
aws glue get-table --database-name database_name --name table_name
```
Per ulteriori informazioni sul comando `get-table`, consulta [get-table](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glue/get-table.html).
1. Salvate l'output JSON in un file con il nome della tabella (ad esempio, *table\$1name* .json) sul desktop di Windows.
1. Apri il file in un editor di testo.
1. Nel file JSON, rimuovi la voce `{"Table": ` esterna e la parentesi di chiusura corrispondente `}` alla fine del file.
1. Nel file JSON, rimuovi le seguenti voci e i relativi valori:
+ `DatabaseName`: questa voce non è obbligatoria perché il comando CLI `create-table` utilizza il parametro `--database-name`.
+ `CreateTime`
+ `UpdateTime`
+ `CreatedBy`
+ `IsRegisteredWithLakeFormation`
+ `CatalogId`
+ `VersionId`
1. Salvate il file di definizione della tabella.
1. Al prompt dei comandi, esegui il AWS CLI comando seguente per ricreare la tabella nel nuovo database:
```
aws glue create-table --database-name new_database_name --table-input "file://~/Desktop\table_name.json"
```
Per ulteriori informazioni sul comando `create-table`, consulta [create-table](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glue/create-table.html).
La tabella ora appare nel nuovo database di AWS Glue e può essere interrogata da Athena.
1. Ripeti i passaggi per copiare ogni tabella aggiuntiva nel nuovo database in AWS Glue.
# Creare tabelle per processi ETL
È possibile utilizzare Athena per creare tabelle AWS Glue utilizzabili per i lavori ETL. AWS Glue i lavori eseguono operazioni ETL. Un AWS Glue job esegue uno script che estrae i dati dalle fonti, li trasforma e li carica in destinazioni. Per ulteriori informazioni, consulta [Authoring Jobs in AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/author-job-glue.html) nella *AWS Glue Developer Guide*.
## Creazione di tabelle Athena per lavori ETL AWS Glue
Alle tabelle da te create in Athena devi aggiungere una proprietà di tabella, denominata `classification`, che identifica il formato dei dati. Ciò consente a AWS Glue di utilizzare le tabelle per processi ETL. I valori di classificazione possono essere `avro`, `csv`, `json`, `orc`, `parquet` o `xml`. Di seguito è riportata un'istruzione `CREATE TABLE` di esempio in Athena:
```
CREATE EXTERNAL TABLE sampleTable (
column1 INT,
column2 INT
) STORED AS PARQUET
TBLPROPERTIES (
'classification'='parquet')
```
Se la proprietà della `classification` tabella non è stata aggiunta al momento della creazione della tabella, puoi aggiungerla utilizzando la AWS Glue console.
**Per aggiungere la proprietà della tabella di classificazione utilizzando la AWS Glue console**
1. Accedi a Console di gestione AWS e apri la AWS Glue console all'indirizzo [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Nel pannello di navigazione della console, seleziona **Tables** (Tabelle).
1. Scegli il collegamento per la tabella che desideri modificare, quindi scegli **Actions** (Operazioni), **Edit table details** (Modifica tabella).
1. Scorri verso il basso fino alla sezione **Table properties** (Proprietà della tabella).
1. Scegliere **Aggiungi**.
1. In **Chiave**, inserire **classification**.
1. Per **Value** (Valore), inserisci un tipo di dati (ad esempio, **json**).
1. Scegli **Save** (Salva).
Nella sezione **Table details** (Dettagli della tabella), il tipo di dati che hai inserito appare nel campo **Classification** (Classificazione) della tabella.
Per ulteriori informazioni, consulta l'argomento relativo all'[utilizzo delle tabelle](https://docs.aws.amazon.com/glue/latest/dg/console-tables.html) nella *Guida per sviluppatori AWS Glue *.
## Utilizzare processi ETL per ottimizzare le prestazioni delle query
AWS Glue jobs possono aiutarti a trasformare i dati in un formato che ottimizza le prestazioni delle query in Athena. I formati dei dati influiscono moltissimo sulle prestazioni delle query e sui costi delle query in Athena.
AWS Glue supporta la scrittura nei formati di dati Parquet e ORC. È possibile utilizzare questa funzionalità per trasformare i dati da usare in Athena. Per ulteriori informazioni sull’utilizzo di Parquet e ORC e su altri metodi per migliorare le prestazioni in Athena, consultare [I 10 migliori consigli di ottimizzazione delle prestazioni per Amazon Athena](https://aws.amazon.com/blogs/big-data/top-10-performance-tuning-tips-for-amazon-athena/).
**Nota**
Per ridurre la probabilità che Athena non sia in grado di leggere `SMALLINT` i tipi di dati `TINYINT` e prodotti da AWS Glue un processo ETL, `SMALLINT` converti `TINYINT` e `INT` verso quando crei un processo ETL che converte i dati in ORC.
## Automatizza i lavori per ETL AWS Glue
È possibile configurare i processi AWS Glue ETL in modo che vengano eseguiti automaticamente in base ai trigger. Questa funzionalità è ideale quando i dati dall'esterno AWS vengono inviati a un bucket Amazon S3 in un formato altrimenti non ottimale per l'esecuzione di query in Athena. *Per ulteriori informazioni, consulta [AWS Glue Triggering](https://docs.aws.amazon.com/glue/latest/dg/trigger-job.html) jobs nella Developer Guide.AWS Glue *
# Lavora con dati CSV in AWS Glue
Questa pagina descrive come AWS Glue creare schemi da file CSV che contengono virgolette attorno ai valori dei dati per ogni colonna o da file CSV che includono valori di intestazione.
## Gestire dati CSV tra virgolette
Immaginiamo di avere un file CSV che dispone di campi dati racchiusi tra virgolette doppie come nell’esempio seguente:
```
"John","Doe","123-555-1231","John said \"hello\""
"Jane","Doe","123-555-9876","Jane said \"hello\""
```
Per eseguire una query in Athena su una tabella creata da un file CSV contenente valori tra virgolette, è necessario modificare le proprietà della tabella in AWS Glue modo da utilizzare Open De. CSVSer Per ulteriori informazioni su OpenCSV SerDe, vedere. [Apri CSV SerDe per l'elaborazione di CSV](csv-serde.md)
**Per modificare le proprietà delle tabelle nella console AWS Glue**
1. Nel riquadro di navigazione della AWS Glue console, scegli **Tabelle**.
1. Scegli il collegamento per la tabella che desideri modificare, quindi scegli **Actions** (Operazioni), **Edit table details** (Modifica tabella).
1. Nella pagina **Edit table** (Modifica tabella), apporta le modifiche seguenti:
+ Per **Serialization lib** (Libreria serializzazione), inserisci `org.apache.hadoop.hive.serde2.OpenCSVSerde`.
+ Per **Parametri Serde**, inserisci i seguenti valori per le chiavi `escapeChar`, `quoteChar` e `separatorChar`:
+ Per `escapeChar`, inserire una barra rovesciata (**\$1**).
+ Per `quoteChar`, inserire una virgoletta doppia (**"**).
+ Per `separatorChar`, inserire una virgola (**,**).
1. Scegli **Save** (Salva).
Per ulteriori informazioni, consulta la sezione relativa alla [visualizzazione e modifica dei dettagli tabella](https://docs.aws.amazon.com/glue/latest/dg/console-tables.html#console-tables-details) nella *Guida per sviluppatori AWS Glue *.
Puoi anche aggiornare le proprietà AWS Glue delle tabelle a livello di codice. Utilizzate l'operazione AWS Glue [UpdateTable](https://docs.aws.amazon.com/glue/latest/webapi/API_UpdateTable.html)API o il AWS CLI comando [update-table](https://docs.aws.amazon.com/cli/latest/reference/glue/update-table.html) per modificare il `SerDeInfo` blocco nella definizione della tabella, come nel seguente esempio JSON.
```
"SerDeInfo": {
"name": "",
"serializationLib": "org.apache.hadoop.hive.serde2.OpenCSVSerde",
"parameters": {
"separatorChar": ","
"quoteChar": "\""
"escapeChar": "\\"
}
},
```
## Gestione dei file CSV con intestazioni
Quando definisci una tabella in Athena con un'istruzione `CREATE TABLE`, puoi utilizzare la proprietà tabella `skip.header.line.count` per ignorare gli header nei dati CSV, come nell'esempio seguente.
```
...
STORED AS TEXTFILE
LOCATION 's3://amzn-s3-demo-bucket/csvdata_folder/';
TBLPROPERTIES ("skip.header.line.count"="1")
```
In alternativa, puoi rimuovere gli header CSV in anticipo in modo che le informazioni degli header non siano incluse nei risultati delle query di Athena di Athena. Un metodo per procedere è utilizzare i processi AWS Glue che eseguono le operazioni di estrazione, trasformazione e caricamento (ETL). È possibile scrivere script AWS Glue utilizzando un linguaggio che è un'estensione del dialetto PySpark Python. Per ulteriori informazioni, consulta [Authoring Jobs in AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/author-job-glue.html) nella *AWS Glue Developer Guide*.
L'esempio seguente mostra una funzione in AWS Glue uno script che scrive un frame dinamico utilizzando `from_options` e imposta l'opzione `writeHeader` format su false, che rimuove le informazioni di intestazione:
```
glueContext.write_dynamic_frame.from_options(frame = applymapping1, connection_type = "s3", connection_options = {"path": "s3://amzn-s3-demo-bucket/MYTABLEDATA/"}, format = "csv", format_options = {"writeHeader": False}, transformation_ctx = "datasink2")
```
# Lavora con dati geospaziali in AWS Glue
AWS Glue non supporta nativamente Woonown Text (WKT), Wooden Binary (WKB) o altri tipi di dati PostGIS. Il AWS Glue classificatore analizza i dati geospaziali e li classifica utilizzando i tipi di dati supportati per il formato, ad esempio per CSV. `varchar` Come per altre AWS Glue tabelle, potrebbe essere necessario aggiornare le proprietà delle tabelle create da dati geospaziali per consentire ad Athena di analizzare questi tipi di dati così come sono. Per ulteriori informazioni, consultare [Utilizzare un crawler per aggiungere una tabella](schema-crawlers.md) e [Lavora con dati CSV in AWS Glue](schema-csv.md). Athena potrebbe non essere in grado di analizzare alcuni tipi di dati geospaziali nelle tabelle così come sono. AWS Glue Per ulteriori informazioni sull'utilizzo dei dati geospaziali in Athena, consulta [Eseguire query su dati geospaziali.](querying-geospatial-data.md).