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à.
# Utilizzare un metastore Hive esterno
Puoi utilizzare il connettore dati Amazon Athena per un metastore Hive esterno per interrogare set di dati in Amazon S3 che utilizzano un metastore Apache Hive. Non è necessaria alcuna migrazione dei metadati AWS Glue Data Catalog verso. Nella console di gestione di Athena, configura una funzione Lambda per comunicare con il metastore Hive nel VPC privato e quindi collegala al metastore. La connessione da Lambda al metastore Hive è protetta da un canale Amazon VPC privato e non utilizza la rete Internet pubblica. Puoi fornire il tuo codice di funzione Lambda, oppure puoi utilizzare l'implementazione predefinita del connettore dati Athena per un metastore Hive esterno.
**Topics**
+ [Panoramica delle caratteristiche](#connect-to-a-data-source-hive-features)
+ [Flusso di lavoro](#connect-to-data-source-hive-workflow)
+ [Considerazioni e limitazioni](#connect-to-a-data-source-hive-considerations)
+ [Connect Athena a un metastore Apache Hive](connect-to-data-source-hive-connecting-athena-to-an-apache-hive-metastore.md)
+ [Usa il AWS Serverless Application Repository per implementare un connettore di origine dati Hive](connect-data-source-sar-hive.md)
+ [Collega Athena a un metastore Hive utilizzando un ruolo di esecuzione IAM esistente](connect-data-source-hive-existing-iam-role.md)
+ [Configurazione di Athena per l'utilizzo di un connettore Hive Metastore distribuito](connect-data-source-hive-existing-lambda.md)
+ [Omettere il nome del catalogo nelle query di un metastore Hive esterno](datastores-hive-default-catalog.md)
+ [Lavorare con le visualizzazioni Hive](hive-views.md)
+ [Usalo AWS CLI con Hive metastores](datastores-hive-cli.md)
+ [Modificare il connettore metastore Hive esterno Athena](datastores-hive-reference-implementation.md)
## Panoramica delle caratteristiche
Con il connettore dati Athena per un metastore Hive esterno, puoi svolgere le seguenti attività:
+ Utilizzare la console Athena per registrare cataloghi personalizzati ed eseguire query che li utilizzano.
+ Definire le funzioni Lambda per diversi metastore Hive esterni e unirle nelle query Athena.
+ Usa AWS Glue Data Catalog i tuoi metastore Hive esterni nella stessa query Athena.
+ Specificare un catalogo nel contesto di esecuzione della query come catalogo predefinito corrente. In questo modo viene rimosso il requisito di anteporre i nomi dei cataloghi ai nomi dei database nelle query. Invece di usare la sintassi `catalog.database.table`, è possibile usare `database.table`.
+ Utilizzare una varietà di strumenti per eseguire query che fanno riferimento a metastore Hive esterni. È possibile utilizzare la console Athena, l' AWS CLI AWS SDK, Athena e i driver Athena JDBC APIs e ODBC aggiornati. I driver aggiornati supportano i cataloghi personalizzati.
### Supporto API
Il connettore Athena Data per il metastore Hive esterno include il supporto per le operazioni API di registrazione del catalogo e le operazioni API relative ai metadati.
+ **Registrazione catalogo**: registrare cataloghi personalizzati per metastore Hive esterni e [origini dati federate](federated-queries.md).
+ **Metadati**: utilizza i metadati APIs per fornire informazioni su database e tabelle per AWS Glue qualsiasi catalogo registrato con Athena.
+ **Client Athena JAVA SDK**: utilizza la registrazione del catalogo APIs, i metadati APIs e il supporto per i cataloghi nell'operazione nel client Athena Java SDK aggiornato. `StartQueryExecution`
### Implementazione di riferimento
Athena fornisce un'implementazione di riferimento per la funzione Lambda che si connette a metastore Hive esterni. L'implementazione di riferimento è fornita GitHub come progetto open source presso il metastore [Athena Hive](https://github.com/awslabs/aws-athena-hive-metastore).
L'implementazione di riferimento è disponibile come le seguenti due AWS SAM applicazioni in (SAR). AWS Serverless Application Repository È possibile utilizzare una di queste applicazioni in SAR per creare le proprie funzioni Lambda.
+ `AthenaHiveMetastoreFunction`— File `.jar` della funzione Uber Lambda. Un JAR "uber" (noto anche come JAR grasso o JAR con dipendenze) è un`.jar` che contiene sia un programma Java che le sue dipendenze in un unico file.
+ `AthenaHiveMetastoreFunctionWithLayer` – Livello Lambda e file `.jar` della funzione Lambda.
## Flusso di lavoro
Il diagramma seguente mostra come Athena interagisce con il metastore Hive esterno.
![\[Interazione di Athena con il metastore Hive esterno.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/connect-to-data-source-hive-workflow.png)
In questo flusso di lavoro, il metastore Hive connesso al database si trova all'interno del VPC. È possibile utilizzare Hive Server2 per gestire il metastore Hive utilizzando l'interfaccia CLI di Hive.
Il flusso di lavoro per l'utilizzo di metastore Hive esterni da Athena include i passaggi seguenti.
1. Si crea una funzione Lambda che connette Athena al metastore Hive che si trova all'interno del VPC.
1. Si registra un nome di catalogo univoco per il metastore Hive e un nome di funzione corrispondente nell'account.
1. Quando si esegue una query DML o DDL Athena che utilizza il nome del catalogo, il motore di query Athena chiama il nome della funzione Lambda associato al nome del catalogo.
1. Utilizzando AWS PrivateLink, la funzione Lambda comunica con il metastore Hive esterno nel tuo VPC e riceve risposte alle richieste di metadati. Athena usa i metadati dal metastore Hive esterno proprio come usa i metadati dalla AWS Glue Data Catalog predefinita.
## Considerazioni e limitazioni
Quando si utilizza Athena Data Connector per il metastore Hive esterno, considerare i seguenti punti:
+ Puoi utilizzare CTAS per creare una tabella su un metastore Hive esterno.
+ Puoi utilizzare INSERT INTO per inserire dati in un metastore Hive esterno.
+ Il supporto DDL per il metastore Hive esterno è limitato alle seguenti istruzioni.
+ ALTER DATABASE SET DBPROPERTIES
+ ALTER TABLE ADD COLUMNS
+ ALTER TABLE ADD PARTITION
+ ALTER TABLE DROP PARTITION
+ ALTER TABLE RENAME PARTITION
+ ALTER TABLE REPLACE COLUMNS
+ ALTER TABLE SET LOCATION
+ ALTER TABLE SET TBLPROPERTIES
+ CREATE DATABASE
+ CREATE TABLE
+ CREATE TABLE AS
+ DESCRIBE TABLE
+ DROP DATABASE
+ DROP TABLE
+ SHOW COLUMNS
+ SHOW CREATE TABLE
+ SHOW PARTITIONS
+ SHOW SCHEMAS
+ SHOW TABLES
+ SHOW TBLPROPERTIES
+ Il numero massimo di cataloghi registrati che è possibile avere è 1.000.
+ L'autenticazione Kerberos per metastore Hive non è supportata.
+ Per utilizzare il driver JDBC con un metastore Hive esterno o [query federate](federated-queries.md), includi `MetadataRetrievalMethod=ProxyAPI` nella stringa di connessione JDBC. Per informazioni sul driver JDBC, consulta [Connettersi ad Amazon Athena con JDBC](connect-with-jdbc.md).
+ Le colonne nascoste di Hive `$path`, `$bucket`, `$file_size`, `$file_modified_time`, `$partition` e `$row_id` non possono essere utilizzate per filtrare con il controllo granulare degli accessi.
+ Le tabelle di sistema Hive nascoste, come `example_table$partitions` o `example_table$properties`, non sono supportate dal controllo granulare degli accessi.
### Permissions
I connettori dati precompilati e personalizzati potrebbero richiedere l'accesso alle seguenti risorse per funzionare correttamente. Controlla le informazioni relative al connettore utilizzato per assicurarti di aver configurato correttamente il VPC. Per informazioni sulle autorizzazioni IAM obbligatorie per eseguire query e creare un connettore origine dati in Athena, consulta [Consenti l’accesso a un connettore dati Athena per il metastore Hive esterno](hive-metastore-iam-access.md) e [Consentire l'accesso alla funzione Lambda a metastore Hive esterni](hive-metastore-iam-access-lambda.md).
+ **Amazon S3** — Oltre a scrivere i risultati delle query nella posizione dei risultati della query Athena in Amazon S3, i connettori di dati scrivono anche in un bucket di spill in Amazon S3. Sono richieste connettività e autorizzazioni a questa posizione Amazon S3. Per ulteriori informazioni, consulta [Posizione spill in Amazon S3](#connect-to-data-source-hive-spill-location) più avanti in questo argomento.
+ **Athena** – L'accesso è necessario per controllare lo stato della query e impedire l'overscan.
+ **AWS Glue**— L'accesso è necessario se il connettore utilizza metadati supplementari o primari. AWS Glue
+ **AWS Key Management Service**
+ **Criteri**: Hive metastore, Athena Query Federation e UDFs richiedono politiche oltre a. [AWS politica gestita: AmazonAthenaFullAccess](security-iam-awsmanpol.md#amazonathenafullaccess-managed-policy) Per ulteriori informazioni, consulta [Gestione dell'identità e dell'accesso in Athena](security-iam-athena.md).
### Posizione spill in Amazon S3
A causa del [limite](https://docs.aws.amazon.com/lambda/latest/dg/limits.html) relativo alle dimensioni delle risposte delle funzioni Lambda, le risposte superiori alla soglia si riversano in una posizione Amazon S3 specificata al momento della creazione della funzione Lambda. Athena legge direttamente queste risposte da Amazon S3.
**Nota**
Athena non rimuove i file di risposta su Amazon S3. Ti consigliamo di impostare una policy di conservazione per eliminare automaticamente i file di risposta.
# Connect Athena a un metastore Apache Hive
Per connettere Athena a un metastore Apache Hive, devi creare e configurare una funzione Lambda. Per un'implementazione di base, puoi eseguire tutte le fasi richieste a partire dalla console di gestione Athena.
**Nota**
La procedura seguente richiede l'autorizzazione per creare un ruolo IAM personalizzato per la funzione Lambda. Se non disponi dell'autorizzazione per creare un ruolo personalizzato, puoi utilizzare l'[implementazione di riferimento](connect-to-data-source-hive.md#connect-to-a-data-source-hive-features-reference-implementation) Athena per creare una funzione Lambda separatamente, quindi utilizzare la AWS Lambda console per scegliere un ruolo IAM esistente per la funzione. Per ulteriori informazioni, consulta [Collega Athena a un metastore Hive utilizzando un ruolo di esecuzione IAM esistente](connect-data-source-hive-existing-iam-role.md).
**Per connettere Athena a un metastore Hive**
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. Scegliere **Data sources and catalogs**.
1. Nell'angolo in alto a destra della console, scegli **Create data source** (Crea origine dati).
1. Nella pagina **Choose a data source** (Scegli un'origine dati), per **Data source** (Origini dati), scegli **S3 - Apache Hive metastore** (Metastore Apache Hive - S3).
1. Scegli **Next (Successivo)**.
1. Nella sezione **Data source details** (Dettagli origine dati), per **Data source name** (Nome origine dati), inserisci il nome che desideri utilizzare nelle istruzioni SQL quando esegui una query sull'origine dati da Athena. Il nome può contenere fino a 127 caratteri e deve essere univoco all'interno dell'account. Non può essere modificato dopo la creazione. I caratteri validi sono a-z, A-z, 0-9, \$1 (trattino basso), @ (chiocciola) e - (trattino). I nomi `awsdatacatalog`, `hive`, `jmx` e `system` sono riservati ad Athena e non possono essere utilizzati per i nomi delle origini dati.
1. Per la funzione **Lambda, scegli Crea funzione** **Lambda, quindi scegli Crea **una nuova** funzione** Lambda in AWS Lambda
La **AthenaHiveMetastoreFunction**pagina si apre nella console. AWS Lambda La pagina include informazioni dettagliate sul connettore.
![\[La AthenaHiveMetastoreFunctionpagina nella AWS Lambda console.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/connect-to-data-source-hive-4.png)
1. Sotto **Impostazioni applicazioni** inserisci i parametri per la funzione Lambda.
+ **LambdaFuncName**— Fornire un nome per la funzione. Ad esempio, **myHiveMetastore**.
+ **SpillLocation**— Specificare una posizione Amazon S3 in questo account per conservare i metadati di spillover se la dimensione della risposta della funzione Lambda supera i 4 MB.
+ **HMSUris**— Inserisci l'URI del tuo host metastore Hive che utilizza il protocollo Thrift sulla porta 9083. Utilizzo della sintassi `thrift://:9083`.
+ **LambdaMemory**— Specificare un valore compreso tra 128 MB e 3008 MB. Alla funzione Lambda vengono allocati cicli di CPU proporzionali alla quantità di memoria configurata. Il valore di default è 1024.
+ **LambdaTimeout**— Specificare il tempo di esecuzione della chiamata Lambda massimo consentito in secondi da 1 a 900 (900 secondi corrispondono a 15 minuti). Il valore predefinito è 300 secondi (5 minuti).
+ **VPCSecurityGroupIds**— Inserisci un elenco separato da virgole di gruppi IDs di sicurezza VPC per il metastore Hive.
+ **VPCSubnetIds**: inserisci un elenco separato da virgole di IDs sottorete VPC per il metastore Hive.
1. Seleziona **I acknowledge that this app creates custom IAM roles** (Sono consapevole che questa app crea ruoli IAM personalizzati), quindi scegli **Deploy** (Implementa).
![\[Distribuzione dell'app per la funzione Lambda dalla console AWS Lambda .\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/connect-to-data-source-hive-4a.png)
Al termine della distribuzione, la funzione viene visualizzata nell'elenco delle applicazioni Lambda. Ora che la funzione metastore Hive è stata distribuita sul tuo account, puoi configurare Athena per usarla.
1. Torna alla pagina **Enter data source details** (Inserisci i dettagli dell'origine dati) nella console Athena.
1. Nella sezione **Lambda function** (Funzione Lambda), scegli l'icona di aggiornamento accanto alla casella di ricerca della funzione Lambda. L'aggiornamento dell'elenco delle funzioni disponibili fa sì che la funzione appena creata venga visualizzata nell'elenco.
1. Scegli il nome della funzione appena creata nella console Lambda. Viene visualizzato l'ARN della funzione Lambda.
1. (Facoltativo) Per **Tags** (Tag), aggiungi coppie chiave-valore da associare a questa 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 i dettagli dell'origine dati, quindi scegli **Create data source** (Crea origine dati).
1. La sezione **Data source details** (Dettagli sull'origine dati) della pagina dell'origine dati mostra le informazioni relative al nuovo connettore.
È ora possibile utilizzare il **Data source name** (Nome origine dati) specificato per fare riferimento al metastore Hive nelle query SQL in Athena. Nelle query SQL utilizzare la sintassi di esempio seguente, sostituendo `hms-catalog-1` con il nome del catalogo specificato in precedenza.
```
SELECT * FROM hms-catalog-1.CustomerData.customers
```
1. Per informazioni sulla visualizzazione, la modifica o l'eliminazione delle origini dati create, consulta [Gestione delle origini dati](data-sources-managing.md).
# Usa il AWS Serverless Application Repository per implementare un connettore di origine dati Hive
Per distribuire un connettore origine dati Athena per Hive, puoi utilizzare [AWS Serverless Application Repository](https://aws.amazon.com/serverless/serverlessrepo/) invece di iniziare con la console Athena. Usa il AWS Serverless Application Repository per trovare il connettore che desideri utilizzare, fornisci i parametri richiesti dal connettore e quindi distribuisci il connettore al tuo account. Quindi, dopo aver distribuito il connettore, utilizza la console Athena per rendere disponibile l'origine dati ad Athena.
**Da utilizzare AWS Serverless Application Repository per distribuire un connettore di origine dati per Hive sul tuo account**
1. Accedi Console di gestione AWS e apri il **Serverless** App Repository.
1. Nel pannello di navigazione, scegli **Available applications (Applicazioni disponibili)**.
1. Seleziona l'opzione **Visualizzare le app che creano ruoli IAM personalizzati o policy delle risorse**.
1. Nella casella di ricerca immetti **Hive**. I connettori visualizzati includono i due seguenti:
+ **AthenaHiveMetastoreFunction**— File `.jar` della funzione Uber Lambda.
+ **AthenaHiveMetastoreFunctionWithLayer** – Livello Lambda e file `.jar` della funzione Lambda.
Le due applicazioni hanno la stessa funzionalità e differiscono solo nella loro implementazione. È possibile utilizzarle entrambe per creare una funzione Lambda che connette Athena al metastore Hive.
1. Scegli il nome del connettore da utilizzare. In questo tutorial si utilizza **AthenaHiveMetastoreFunction**.
![\[Scegli il nome del connettore dell'origine dati Athena per Hive.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/connect-data-source-sar-hive-1.png)
1. Sotto **Impostazioni applicazioni** inserisci i parametri per la funzione Lambda.
+ **LambdaFuncName**— Fornisci un nome per la funzione. Ad esempio, **myHiveMetastore**.
+ **SpillLocation**— Specificare una posizione Amazon S3 in questo account per conservare i metadati di spillover se la dimensione della risposta della funzione Lambda supera i 4 MB.
+ **HMSUris**— Inserisci l'URI del tuo host metastore Hive che utilizza il protocollo Thrift sulla porta 9083. Utilizzo della sintassi `thrift://:9083`.
+ **LambdaMemory**— Specificare un valore compreso tra 128 MB e 3008 MB. Alla funzione Lambda vengono allocati cicli di CPU proporzionali alla quantità di memoria configurata. Il valore di default è 1024.
+ **LambdaTimeout**— Specificare il tempo di esecuzione della chiamata Lambda massimo consentito in secondi da 1 a 900 (900 secondi corrispondono a 15 minuti). Il valore predefinito è 300 secondi (5 minuti).
+ **VPCSecurityGroupIds**— Inserisci un elenco separato da virgole di gruppi IDs di sicurezza VPC per il metastore Hive.
+ **VPCSubnetIds**: inserisci un elenco separato da virgole di IDs sottorete VPC per il metastore Hive.
1. Nella parte inferiore destra della pagina **Dettagli applicazione** seleziona **Sono consapevole che questa app crea ruoli IAM personalizzati**, quindi scegli **Distribuisci**.
A questo punto, puoi configurare Athena per utilizzare la funzione Lambda per connetterti al metastore Hive. Per le fasi, consulta [Configurazione di Athena per l'utilizzo di un connettore Hive Metastore distribuito](connect-data-source-hive-existing-lambda.md).
# Collega Athena a un metastore Hive utilizzando un ruolo di esecuzione IAM esistente
Per connettere il metastore Hive esterno ad Athena con una funzione Lambda che utilizza un ruolo IAM esistente, è possibile utilizzare l'implementazione di riferimento di Athena del connettore Athena per il metastore Hive esterno.
Le tre fasi principali sono le seguenti:
1. **[Clona e Costruisci](#connect-data-source-hive-existing-iam-role-clone-and-build-the-lambda-function)**: clona l'implementazione di riferimento Athena e crea il file JAR che contiene il codice funzione Lambda.
1. **[AWS Lambda console](#connect-data-source-hive-existing-iam-role-aws-lambda-console)**: nella AWS Lambda console, crea una funzione Lambda, assegnale un ruolo di esecuzione IAM esistente e carica il codice della funzione che hai generato.
1. **[Console Amazon Athena](connect-data-source-hive-existing-lambda.md)**: nella console Amazon Athena, crea un nome di origine dati che puoi usare per fare riferimento al tuo metastore Hive esterno nelle query Athena.
Se disponi già delle autorizzazioni per creare un ruolo IAM personalizzato, puoi utilizzare un flusso di lavoro più semplice che utilizza la console Athena e AWS Serverless Application Repository per creare e configurare una funzione Lambda. Per ulteriori informazioni, consulta [Connect Athena a un metastore Apache Hive](connect-to-data-source-hive-connecting-athena-to-an-apache-hive-metastore.md).
## Prerequisiti
+ Git deve essere installato sul sistema.
+ È necessario avere [Apache Maven](https://maven.apache.org/) installato.
+ Hai un ruolo di esecuzione IAM che puoi assegnare alla funzione Lambda. Per ulteriori informazioni, consulta [Consentire l'accesso alla funzione Lambda a metastore Hive esterni](hive-metastore-iam-access-lambda.md).
## Clona e costruisci la funzione Lambda
[Il codice della funzione per l'implementazione di riferimento di Athena è un progetto Maven situato su awslabs/. GitHub aws-athena-hive-metastore](https://github.com/awslabs/aws-athena-hive-metastore) Per informazioni dettagliate sul progetto, consulta il file README corrispondente su GitHub o l'argomento di questa documentazione. [Modificare il connettore metastore Hive esterno Athena](datastores-hive-reference-implementation.md)
**Per clonare e costruire il codice della funzione Lambda**
1. Inserire il seguente comando per clonare l'implementazione di riferimento Athena:
```
git clone https://github.com/awslabs/aws-athena-hive-metastore
```
1. Eseguire il comando seguente per creare il file `.jar` per la funzione Lambda:
```
mvn clean install
```
Dopo che il progetto è stato creato correttamente, il seguente file `.jar` viene creato nella cartella di destinazione del tuo progetto:
`hms-lambda-func-1.0-SNAPSHOT-withdep.jar`
Nella sezione successiva, usi la AWS Lambda console per caricare questo file sul tuo account Amazon Web Services.
## Crea e configura la funzione Lambda nella console AWS Lambda
In questa sezione, si utilizza la AWS Lambda console per creare una funzione che utilizza un ruolo di esecuzione IAM esistente. Dopo aver configurato un VPC per la funzione, carica il codice della funzione e configura le variabili di ambiente per la funzione.
### Creazione della funzione Lambda
In questo passaggio, crei una funzione nella AWS Lambda console che utilizza un ruolo IAM esistente.
**Per creare una funzione Lambda che utilizza un ruolo IAM esistente**
1. Accedi a Console di gestione AWS e apri la AWS Lambda console all'indirizzo [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Nel riquadro di navigazione, seleziona **Funzioni**.
1. Selezionare **Create function (Crea funzione)**.
1. Scegli **Author from scratch** (Crea da zero).
1. In **Nome funzione**, inserisci il nome della funzione Lambda (ad esempio, **EHMSBasedLambda**).
1. Per **Runtime**, scegliere **Java 8**.
1. In **Autorizzazioni** espandere **Modifica ruolo di esecuzione predefinito**.
1. In **Execution role (Ruolo di esecuzione)**, scegliere **Use an existing role (Utilizza un ruolo esistente)**.
1. Per **Ruolo esistente**, scegli il ruolo di esecuzione IAM che la tua funzione Lambda utilizzerà per Athena (questo esempio utilizza un ruolo chiamato `AthenaLambdaExecutionRole`).
1. Espandere **Advanced settings (Impostazioni avanzate)**.
1. Seleziona **Enable Network** (Abilita la rete).
1. Per **VPC**, scegli il VPC a cui la tua funzione avrà accesso.
1. Per **Sottoreti**, scegli le sottoreti VPC che utilizzerà Lambda.
1. Per **Gruppi di sicurezza**, scegli i gruppi di sicurezza VPC che utilizzerà Lambda.
1. Scegli **Crea funzione**. La AWS Lambda console apre la pagina di configurazione della funzione e inizia a creare la funzione.
### Carica il codice e configura la funzione Lambda
Quando la console informa che la funzione è stata creata correttamente, è possibile caricare il codice della funzione e configurarne le variabili di ambiente.
**Per caricare il codice della funzione Lambda e configurare le variabili di ambiente**
1. Nella console Lambda, assicurati di utilizzare la scheda **Code** (Codice) della pagina della funzione specificata.
1. Per **Code source** (Origine codice), scegli **Upload from** (Carica da), quindi scegli **.zip or .jar file** (file .zip o .jar).
1. Carica il file `hms-lambda-func-1.0-SNAPSHOT-withdep.jar` generato in precedenza.
1. Nella pagina della funzione Lambda, scegli la scheda **Configuration** (Configurazione).
1. Dal riquadro a sinistra, scegli **Environment variables** (Variabili di ambiente).
1. Nella sezione **Variabili di ambiente**, scegliere **Modifica**.
![\[Scegliere Modifica per modificare le variabili di ambiente per la funzione Lambda.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/connect-data-source-hive-existing-iam-role-5.png)
1. Nella pagina **Edit environment variables** (Modifica variabili di ambiente), utilizza l'opzione **Add environment variable** (Aggiungi variabile di ambiente) per aggiungere le chiavi e i valori delle variabili di ambiente seguenti:
+ **HMS\$1URIS**: usa la seguente sintassi per inserire l'URI dell'host del metastore Hive che utilizza il protocollo Thrift alla porta 9083.
```
thrift://:9083
```
+ **SPILL\$1LOCATION**: specifica una posizione Amazon S3 nell'account Amazon Web Services per contenere metadati di spillover se la dimensione di risposta della funzione Lambda supera i 4 MB.
![\[Specifica dei valori per le variabili di ambiente della funzione Lambda.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/connect-data-source-hive-existing-iam-role-6.png)
1. Scegli **Save** (Salva).
A questo punto, puoi configurare Athena per utilizzare la funzione Lambda per connetterti al metastore Hive. Per le fasi, consulta [Configurazione di Athena per l'utilizzo di un connettore Hive Metastore distribuito](connect-data-source-hive-existing-lambda.md).
# Configurazione di Athena per l'utilizzo di un connettore Hive Metastore distribuito
Dopo aver distribuito un connettore di origine dati Lambda come `AthenaHiveMetastoreFunction` sul tuo account, puoi configurare Athena per usarlo. Per farlo, devi creare un nome di origine dati che faccia riferimento al metastore Hive esterno da utilizzare nelle query Athena.
**Per connettere Athena al metastore Hive utilizzando una funzione Lambda esistente**
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. Scegli **origini dati e cataloghi**.
1. Nella pagina **Data sources and catalogs** (Origini dati e cataloghi), scegli **Create data source** (Crea origine dati).
1. Nella pagina **Choose a data source** (Scegli un'origine dati), per **Data source** (Origini dati), scegli **S3 - Apache Hive metastore** (Metastore Apache Hive - S3).
1. Scegli **Next (Successivo)**.
1. Nella sezione **Data source details** (Dettagli origine dati), per **Data source name** (Nome origine dati), inserisci il nome che desideri utilizzare nelle istruzioni SQL quando si esegue una query sull'origine dati da Athena (ad esempio, `MyHiveMetastore`). Il nome può contenere fino a 127 caratteri e deve essere univoco all'interno dell'account. Non può essere modificato dopo la creazione. I caratteri validi sono a-z, A-z, 0-9, \$1 (trattino basso), @ (chiocciola) e - (trattino). I nomi `awsdatacatalog`, `hive`, `jmx` e `system` sono riservati ad Athena e non possono essere utilizzati per i nomi delle origini dati.
1. Nella sezione **Connection details** (Dettagli di connessione), usa la casella **Select or enter a Lambda function** (Seleziona o inserisci una funzione Lambda) per scegliere il nome della funzione appena creata. Viene visualizzato l'ARN della funzione Lambda.
1. (Facoltativo) Per **Tags** (Tag), aggiungi coppie chiave-valore da associare a questa 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 i dettagli dell'origine dati, quindi scegli **Create data source** (Crea origine dati).
1. La sezione **Data source details** (Dettagli sull'origine dati) della pagina dell'origine dati mostra le informazioni relative al nuovo connettore.
È ora possibile utilizzare il **Data source name** (Nome origine dati) specificato per fare riferimento al metastore Hive nelle query SQL in Athena.
Nelle query SQL utilizzare la sintassi di esempio seguente, sostituendo `ehms-catalog` con il nome dell'origine dati specificato in precedenza.
```
SELECT * FROM ehms-catalog.CustomerData.customers
```
1. Per visualizzare, modificare o eliminare le origini dati create, consulta [Gestione delle origini dati](data-sources-managing.md).
# Omettere il nome del catalogo nelle query di un metastore Hive esterno
Quando si eseguono query DML e DDL su metastore Hive esterne, è possibile semplificare la sintassi della query omettendo il nome del catalogo se tale nome è selezionato nell'editor di query. Alcune restrizioni si applicano a questa funzionalità.
## Istruzioni DML
**Per eseguire query con cataloghi registrati**
1. È possibile inserire il nome dell'origine dati prima del database utilizzando la sintassi `[[data_source_name].database_name].table_name`, come nell'esempio seguente.
```
select * from "hms-catalog-1".hms_tpch.customer limit 10;
```
1. Quando l'origine dati che si desidera utilizzare è già selezionata nell'editor di query, è possibile omettere il nome dalla query, come nell'esempio seguente.
```
select * from hms_tpch.customer limit 10:
```
![\[Query DML che utilizza un'origine dati di default.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/datastores-hive-default-catalog-2.png)
1. Quando si utilizzano più origini dati in una query, è possibile omettere solo il nome dell'origine dati di default ed è necessario specificare il nome completo per le origini dati non di default.
Ad esempio, supponiamo che `AwsDataCatalog` sia selezionato come origine dati di default nell'editor di query. L'`FROM`istruzione nel seguente estratto di query qualifica completamente i primi due nomi di origini dati, ma omette il nome della terza origine dati perché si trova nel catalogo dati. AWS Glue
```
...
FROM ehms01.hms_tpch.customer,
"hms-catalog-1".hms_tpch.orders,
hms_tpch.lineitem
...
```
## Istruzioni DDL
Le seguenti istruzioni DDL Athena supportano i prefissi dei nomi di catalogo. I prefissi dei nomi di catalogo in altre istruzioni DDL causano errori di sintassi.
```
SHOW TABLES [IN [catalog_name.]database_name] ['regular_expression']
SHOW TBLPROPERTIES [[catalog_name.]database_name.]table_name [('property_name')]
SHOW COLUMNS IN [[catalog_name.]database_name.]table_name
SHOW PARTITIONS [[catalog_name.]database_name.]table_name
SHOW CREATE TABLE [[catalog_name.][database_name.]table_name
DESCRIBE [EXTENDED | FORMATTED] [[catalog_name.][database_name.]table_name [PARTITION partition_spec] [col_name ( [.field_name] | [.'$elem$'] | [.'$key$'] | [.'$value$'] )]
```
Come per le istruzioni DML, è possibile omettere i prefissi dell'origine dati e del database dalla query quando l'origine dati e il database vengono selezionati nell'editor di query.
Nell'immagine seguente, l'origine dati `hms-catalog-1` e il database `hms_tpch` vengono selezionati nell'editor di query. L'istruzione`show create table customer` ha esito positivo anche se il prefisso `hms-catalog-1` e il nome del database `hms_tpch` vengono viene omessi dalla query stessa.
![\[Un' istruzione DDL che utilizza il catalogo predefinito.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/datastores-hive-default-catalog-4.png)
## Definizione di un'origine dati di default in una stringa di connessione JDBC
Quando si utilizza il driver Athena JDBC per collegare Athena a un metastore Hive esterno, è possibile utilizzare il parametro `Catalog` per specificare il nome dell'origine dati di default nella stringa di connessione in un editor SQL come [SQL Workbench](https://www.sql-workbench.eu/index.html).
**Nota**
Per scaricare i driver Athena JDBC più recenti, consultare [Utilizzo di Athena con il driver JDBC](https://docs.aws.amazon.com/athena/latest/ug/connect-with-jdbc.html).
La seguente stringa di connessione specifica l'origine dati predefinita. *hms-catalog-name*
```
jdbc:awsathena://AwsRegion=us-east-1;S3OutputLocation=s3://amzn-s3-demo-bucket/lambda/results/;Workgroup=AmazonAthenaPreviewFunctionality;Catalog=hms-catalog-name;
```
L'immagine seguente mostra un URL di connessione JDBC di esempio come configurato in SQL Workbench.
![\[Configurazione di un URL di connessione JDBC in SQL Workbench.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/datastores-hive-default-catalog-jdbc-1.jpg)
# Lavorare con le visualizzazioni Hive
È possibile utilizzare Athena per eseguire query sulle visualizzazioni Apache create in metastore Hive esterni. Athena traduce le tue visualizzazioni per te on-the-fly in fase di esecuzione senza modificare la vista originale o memorizzare la traduzione.
Ad esempio, supponiamo di avere una visualizzazione Hive come la seguente, che utilizza una sintassi non supportata in Athena come `LATERAL VIEW explode()`:
```
CREATE VIEW team_view AS
SELECT team, score
FROM matches
LATERAL VIEW explode(scores) m AS score
```
Athena traduce la stringa di query di visualizzazione Hive in un'istruzione simile alla seguente, che è in grado di eseguire:
```
SELECT team, score
FROM matches
CROSS JOIN UNNEST(scores) AS m (score)
```
Per informazioni sul collegamento di un metastore Hive esterno ad Athena, consulta la sezione [Utilizzare un metastore Hive esterno](connect-to-data-source-hive.md).
## Considerazioni e limitazioni
Durante l'esecuzione di query sulle visualizzazioni Hive da Athena, considera i seguenti punti:
+ Athena non supporta la creazione di visualizzazioni Hive. È possibile creare visualizzazioni Hive nel metastore esterno di Hive, sulle quali è possibile poi eseguire query da Athena.
+ Athena non supporta le visualizzazioni personalizzate UDFs per Hive.
+ A causa di un problema noto nella console Athena, le visualizzazioni Hive vengono mostrate nell'elenco delle tabelle anziché in quello delle visualizzazioni.
+ Sebbene il processo di traduzione sia automatico, alcune funzioni Hive non sono supportate per le visualizzazioni Hive o richiedono una gestione speciale. Per ulteriori informazioni, consulta la sezione seguente.
## Limitazioni nel supporto delle funzioni Hive
Questa sezione evidenzia le funzioni Hive che Athena non supporta per le visualizzazioni Hive o che richiedono un trattamento speciale. Attualmente, poiché Athena supporta principalmente le funzioni di Hive 2.2.0, le funzioni presenti solo nelle versioni successive (come Hive 4.0.0) non sono disponibili. Per un elenco completo delle funzioni Hive, consulta[Manuale del linguaggio Hive UDF](https://cwiki.apache.org/confluence/display/hive/languagemanual+udf).
### Funzioni di aggregazione
#### Funzioni di aggregazione che richiedono una gestione speciale
La seguente funzione di aggregazione per le visualizzazioni Hive richiede una gestione speciale.
+ **Avg**: al posto di `avg(INT i)`, utilizza `avg(CAST(i AS DOUBLE))`.
#### Funzioni aggregate non supportate
Le seguenti funzioni di aggregazione Hive non sono supportate in Athena per le visualizzazioni Hive.
```
covar_pop
histogram_numeric
ntile
percentile
percentile_approx
```
Funzioni di regressione come `regr_count`, `regr_r2` e `regr_sxx` non sono supportate in Athena per le visualizzazioni Hive.
### Funzioni aggregate non supportate
Le seguenti funzioni di aggregazione Hive non sono supportate in Athena per le visualizzazioni Hive.
```
date_format(date/timestamp/string ts, string fmt)
day(string date)
dayofmonth(date)
extract(field FROM source)
hour(string date)
minute(string date)
month(string date)
quarter(date/timestamp/string)
second(string date)
weekofyear(string date)
year(string date)
```
### Funzioni aggregate non supportate
Funzioni di regressione come `mask()`, e `mask_first_n()` non sono supportate in Athena per le visualizzazioni Hive.
### Funzioni varie
#### Funzioni varie che richiedono una gestione speciale
Le seguenti funzioni varie per le visualizzazioni Hive richiedono una gestione speciale.
+ **md5**: Athena supporta `md5(binary)` ma non `md5(varchar)`.
+ **Explode**: Athena supporta `explode` quando viene utilizzato nella seguente sintassi:
```
LATERAL VIEW [OUTER] EXPLODE()
```
+ **Explode**: Athena supporta `posexplode` quando viene utilizzato nella seguente sintassi:
```
LATERAL VIEW [OUTER] POSEXPLODE()
```
Nell'output `(pos, val)`, Athena tratta la colonna `pos` come `BIGINT`. Per questo motivo, potrebbe essere necessario eseguire il cast della colonna `pos` a `BIGINT` per evitare una visualizzazione obsoleta. Nell'esempio seguente viene descritta tale tecnica.
```
SELECT CAST(c AS BIGINT) AS c_bigint, d
FROM table LATERAL VIEW POSEXPLODE() t AS c, d
```
#### Funzioni varie non supportate
Le seguenti funzioni di aggregazione Hive non sono supportate in Athena per le visualizzazioni Hive.
```
aes_decrypt
aes_encrypt
current_database
current_user
inline
java_method
logged_in_user
reflect
sha/sha1/sha2
stack
version
```
### Operatori
#### Operatori che richiedono una gestione speciale
I seguenti operatori per le visualizzazioni Hive richiedono una gestione speciale.
+ **Operatore mod o modulo (%)**: poiché il tipo `DOUBLE` esegue implicitamente un cast a `DECIMAL(x,y)`, la sintassi seguente può causare il messaggio di errore View is stale (La visualizzazione è non aggiornata):
```
a_double % 1.0 AS column
```
Per risolvere il problema, utilizza `CAST`, come nell'esempio seguente.
```
CAST(a_double % 1.0 as DOUBLE) AS column
```
+ **Operatore divisione (/)**: in Hive,`int` diviso per `int` produce un `double`. In Athena, la stessa operazione produce un `int` abbreviato.
#### Operatori non supportati
Athena non supporta i seguenti operatori per le visualizzazioni Hive.
**\$1A**: bitwise `NOT`
**A ^ b**: bitwise `XOR`
**A & b**: bitwise `AND`
**A \$1 b**: bitwise `OR`
**A <=> b**: Restituisce lo stesso risultato dell'operatore uguale (`=`) per operandi non nulli. Restituisce `TRUE` se entrambi sono `NULL`, `FALSE` se uno di questi è `NULL`.
### Funzioni stringa
#### Funzioni stringa che richiedono una gestione speciale
Le seguenti funzioni stringa per le visualizzazioni Hive richiedono una gestione speciale.
+ **chr (bigint\$1doppia a)**: Hive consente argomenti negativi; Athena no.
+ **instr (string str, string substr)**: poiché la mappatura Athena per la funzione `instr` restituisce `BIGINT` anziché `INT`, utilizza la sintassi seguente:
```
CAST(instr(string str, string substr) as INT)
```
Senza questo passaggio, la visualizzazione sarà considerata obsoleta.
+ **lunghezza (stringa a)**: poiché la mappatura Athena per la funzione `length` restituisce `BIGINT` anziché `INT`, utilizza la seguente sintassi in modo che la visualizzazione non venga considerata obsoleta:
```
CAST(length(string str) as INT)
```
#### Funzioni stringa non supportate
Le seguenti funzioni stringa di Hive non sono supportate nelle visualizzazioni Hive in Athena.
```
ascii(string str)
character_length(string str)
decode(binary bin, string charset)
encode(string src, string charset)
elt(N int,str1 string,str2 string,str3 string,...)
field(val T,val1 T,val2 T,val3 T,...)
find_in_set(string str, string strList)
initcap(string A)
levenshtein(string A, string B)
locate(string substr, string str[, int pos])
octet_length(string str)
parse_url(string urlString, string partToExtract [, string keyToExtract])
printf(String format, Obj... args)
quote(String text)
regexp_extract(string subject, string pattern, int index)
repeat(string str, int n)
sentences(string str, string lang, string locale)
soundex(string A)
space(int n)
str_to_map(text[, delimiter1, delimiter2])
substring_index(string A, string delim, int count)
```
### XPath funzioni non supportate
XPath Le funzioni di Hive come `xpath``xpath_short`, e non `xpath_int` sono supportate in Athena for Hive views.
## Risoluzione dei problemi
Quando si utilizzano le visualizzazioni Hive in Athena, potrebbero verificarsi i seguenti problemi:
+ ****La visualizzazione è obsoleta**: questo messaggio di solito indica una mancata corrispondenza di tipo tra la vista in Hive e Athena. Se la stessa funzione nelle funzioni e nella documentazione degli [operatori di [Hive LanguageManual UDF](https://cwiki.apache.org/confluence/display/hive/languagemanual+udf) e Presto](https://prestodb.io/docs/current/functions.html) presenta firme diverse, prova a inserire il tipo di dati non corrispondente.
+ **Function not registered** (Funzione non registrata): Athena non supporta attualmente la funzione. Per ulteriori informazioni, consulta le informazioni descritte precedentemente in questo documento.
# Usalo AWS CLI con Hive metastores
È possibile utilizzare i comandi CLI `aws athena` per gestire i cataloghi dati di metastore Hive utilizzati con Athena. Dopo aver definito uno o più cataloghi da utilizzare con Athena, è possibile fare riferimento a tali cataloghi nei comandi DDL e DML di `aws athena`.
## Utilizzo di per gestire i cataloghi metastore di Hive AWS CLI
### Registrazione di un catalogo: Create-data-catalog
Per registrare un catalogo dati, utilizzare il comando `create-data-catalog`. Utilizzare il parametro `name` per specificare il nome che si desidera utilizzare per il catalogo. Trasmetti l'ARN della funzione Lambda all'opzione `metadata-function` dell'argomento `parameters`. Per creare tag per il nuovo catalogo, utilizzare il parametro `tags` con una o più coppie di argomenti `Key=key,Value=value` separate da spazi.
Nell'esempio seguente viene registrato il catalogo del metastore Hive denominato `hms-catalog-1`. Il comando è stato formattato per la leggibilità.
```
$ aws athena create-data-catalog
--name "hms-catalog-1"
--type "HIVE"
--description "Hive Catalog 1"
--parameters "metadata-function=arn:aws:lambda:us-east-1:111122223333:function:external-hms-service-v3,sdk-version=1.0"
--tags Key=MyKey,Value=MyValue
--region us-east-1
```
### Visualizzazione dei dettagli del catalogo: Get-data-catalog
Per visualizzare i dettagli di un catalogo, passare il nome del catalogo al comando `get-data-catalog`, come nell'esempio seguente.
```
$ aws athena get-data-catalog --name "hms-catalog-1" --region us-east-1
```
Il seguente risultato di esempio è in formato JSON.
```
{
"DataCatalog": {
"Name": "hms-catalog-1",
"Description": "Hive Catalog 1",
"Type": "HIVE",
"Parameters": {
"metadata-function": "arn:aws:lambda:us-east-1:111122223333:function:external-hms-service-v3",
"sdk-version": "1.0"
}
}
}
```
### Elenco dei cataloghi registrati: List-data-catalogs
Per elencare i cataloghi registrati, utilizzare il comando `list-data-catalogs` e, facoltativamente, specificare una regione, come nell'esempio seguente. I cataloghi elencati includono sempre AWS Glue.
```
$ aws athena list-data-catalogs --region us-east-1
```
Il seguente risultato di esempio è in formato JSON.
```
{
"DataCatalogs": [
{
"CatalogName": "AwsDataCatalog",
"Type": "GLUE"
},
{
"CatalogName": "hms-catalog-1",
"Type": "HIVE",
"Parameters": {
"metadata-function": "arn:aws:lambda:us-east-1:111122223333:function:external-hms-service-v3",
"sdk-version": "1.0"
}
}
]
}
```
### Aggiornamento di un catalogo: Update-data-catalog
Per aggiornare un catalogo dati, utilizzare il comando `update-data-catalog`, come nell'esempio seguente. Il comando è stato formattato per la leggibilità.
```
$ aws athena update-data-catalog
--name "hms-catalog-1"
--type "HIVE"
--description "My New Hive Catalog Description"
--parameters "metadata-function=arn:aws:lambda:us-east-1:111122223333:function:external-hms-service-new,sdk-version=1.0"
--region us-east-1
```
### Eliminazione di un catalogo: Delete-data-catalog
Per eliminare un catalogo dati, utilizzare il comando `delete-data-catalog`, come nell'esempio seguente.
```
$ aws athena delete-data-catalog --name "hms-catalog-1" --region us-east-1
```
### Visualizzazione dei dettagli del database: get-database
Per visualizzare i dettagli di un database, passare il nome del catalogo e del database al comando `get-database`, come nell'esempio seguente.
```
$ aws athena get-database --catalog-name hms-catalog-1 --database-name mydb
```
Il seguente risultato di esempio è in formato JSON.
```
{
"Database": {
"Name": "mydb",
"Description": "My database",
"Parameters": {
"CreatedBy": "Athena",
"EXTERNAL": "TRUE"
}
}
}
```
### Elencazione dei database in un catalogo: list-databases
Per elencare i database in un catalogo, utilizzare il comando `list-databases` e, facoltativamente, specificare una regione, come nell'esempio seguente.
```
$ aws athena list-databases --catalog-name AwsDataCatalog --region us-west-2
```
Il seguente risultato di esempio è in formato JSON.
```
{
"DatabaseList": [
{
"Name": "default"
},
{
"Name": "mycrawlerdatabase"
},
{
"Name": "mydatabase"
},
{
"Name": "sampledb",
"Description": "Sample database",
"Parameters": {
"CreatedBy": "Athena",
"EXTERNAL": "TRUE"
}
},
{
"Name": "tpch100"
}
]
}
```
### Visualizzazione dei dettagli della tabella: Get-table-metadata
Per visualizzare i metadati di una tabella, inclusi i nomi delle colonne e i tipi di dati, passare il nome del catalogo, del database e del nome della tabella al comando `get-table-metadata`, come nell'esempio seguente.
```
$ aws athena get-table-metadata --catalog-name AwsDataCatalog --database-name mydb --table-name cityuseragent
```
Il seguente risultato di esempio è in formato JSON.
```
{
"TableMetadata": {
"Name": "cityuseragent",
"CreateTime": 1586451276.0,
"LastAccessTime": 0.0,
"TableType": "EXTERNAL_TABLE",
"Columns": [
{
"Name": "city",
"Type": "string"
},
{
"Name": "useragent1",
"Type": "string"
}
],
"PartitionKeys": [],
"Parameters": {
"COLUMN_STATS_ACCURATE": "false",
"EXTERNAL": "TRUE",
"inputformat": "org.apache.hadoop.mapred.TextInputFormat",
"last_modified_by": "hadoop",
"last_modified_time": "1586454879",
"location": "s3://amzn-s3-demo-bucket/",
"numFiles": "1",
"numRows": "-1",
"outputformat": "org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat",
"rawDataSize": "-1",
"serde.param.serialization.format": "1",
"serde.serialization.lib": "org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe",
"totalSize": "61"
}
}
}
```
### Visualizzazione dei metadati per tutte le tabelle di un database: List-table-metadata
Per visualizzare i metadati per tutte le tabelle di un database, passare il nome del catalogo e del nome del database al comando `list-table-metadata`. Il comando `list-table-metadata` è simile al comando `get-table-metadata`, ad eccezione del fatto che non si specifica un nome di tabella. Per limitare il numero di risultati, è possibile utilizzare l'opzione `--max-results`, come nell'esempio seguente.
```
$ aws athena list-table-metadata --catalog-name AwsDataCatalog --database-name sampledb --region us-east-1 --max-results 2
```
Il seguente risultato di esempio è in formato JSON.
```
{
"TableMetadataList": [
{
"Name": "cityuseragent",
"CreateTime": 1586451276.0,
"LastAccessTime": 0.0,
"TableType": "EXTERNAL_TABLE",
"Columns": [
{
"Name": "city",
"Type": "string"
},
{
"Name": "useragent1",
"Type": "string"
}
],
"PartitionKeys": [],
"Parameters": {
"COLUMN_STATS_ACCURATE": "false",
"EXTERNAL": "TRUE",
"inputformat": "org.apache.hadoop.mapred.TextInputFormat",
"last_modified_by": "hadoop",
"last_modified_time": "1586454879",
"location": "s3://amzn-s3-demo-bucket/",
"numFiles": "1",
"numRows": "-1",
"outputformat": "org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat",
"rawDataSize": "-1",
"serde.param.serialization.format": "1",
"serde.serialization.lib": "org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe",
"totalSize": "61"
}
},
{
"Name": "clearinghouse_data",
"CreateTime": 1589255544.0,
"LastAccessTime": 0.0,
"TableType": "EXTERNAL_TABLE",
"Columns": [
{
"Name": "location",
"Type": "string"
},
{
"Name": "stock_count",
"Type": "int"
},
{
"Name": "quantity_shipped",
"Type": "int"
}
],
"PartitionKeys": [],
"Parameters": {
"EXTERNAL": "TRUE",
"inputformat": "org.apache.hadoop.mapred.TextInputFormat",
"location": "s3://amzn-s3-demo-bucket/",
"outputformat": "org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat",
"serde.param.serialization.format": "1",
"serde.serialization.lib": "org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe",
"transient_lastDdlTime": "1589255544"
}
}
],
"NextToken": "eyJsYXN0RXZhbHVhdGVkS2V5Ijp7IkhBU0hfS0VZIjp7InMiOiJ0Ljk0YWZjYjk1MjJjNTQ1YmU4Y2I5OWE5NTg0MjFjYTYzIn0sIlJBTkdFX0tFWSI6eyJzIjoiY2xlYXJpbmdob3VzZV9kYXRhIn19LCJleHBpcmF0aW9uIjp7InNlY29uZHMiOjE1ODkzNDIwMjIsIm5hbm9zIjo2NTUwMDAwMDB9fQ=="
}
```
## Esecuzione di istruzioni DDL e DML
Quando si utilizza il AWS CLI per eseguire istruzioni DDL e DML, è possibile passare il nome del catalogo dei metastore Hive in due modi:
+ Direttamente nelle istruzioni che lo supportano.
+ Al parametro `--query-execution-context` `Catalog`.
### Istruzioni DDL
L'esempio seguente passa il nome del catalogo direttamente come parte dell'istruzione DDL `show create table`. Il comando è stato formattato per la leggibilità.
```
$ aws athena start-query-execution
--query-string "show create table hms-catalog-1.hms_tpch_partitioned.lineitem"
--result-configuration "OutputLocation=s3://amzn-s3-demo-bucket/lambda/results"
```
Nell'esempio seguente l’istruzione DDL `show create table` usa il parametro `Catalog` di `--query-execution-context` per passare il nome del catalogo del metastore Hive `hms-catalog-1`. Il comando è stato formattato per la leggibilità.
```
$ aws athena start-query-execution
--query-string "show create table lineitem"
--query-execution-context "Catalog=hms-catalog-1,Database=hms_tpch_partitioned"
--result-configuration "OutputLocation=s3://amzn-s3-demo-bucket/lambda/results"
```
### Istruzioni DML
La seguente istruzione DML `select` di esempio passa direttamente il nome del catalogo nella query. Il comando è stato formattato per la leggibilità.
```
$ aws athena start-query-execution
--query-string "select * from hms-catalog-1.hms_tpch_partitioned.customer limit 100"
--result-configuration "OutputLocation=s3://amzn-s3-demo-bucket/lambda/results"
```
La seguente istruzione DML `select` di esempio utilizza il parametro `Catalog` di `--query-execution-context` per passare il nome del catalogo del metastore Hive `hms-catalog-1`. Il comando è stato formattato per la leggibilità.
```
$ aws athena start-query-execution
--query-string "select * from customer limit 100"
--query-execution-context "Catalog=hms-catalog-1,Database=hms_tpch_partitioned"
--result-configuration "OutputLocation=s3://amzn-s3-demo-bucket/lambda/results"
```
# Modificare il connettore metastore Hive esterno Athena
Se si hanno esigenze particolari, è possibile modificare il connettore Athena per il metastore Hive esterno per uso personale. Athena fornisce un'implementazione di riferimento del connettore su GitHub .com all'indirizzo. [https://github.com/awslabs/aws-athena-hive-metastore](https://github.com/awslabs/aws-athena-hive-metastore) La maggior parte dei casi d'uso non richiede la modifica dell'implementazione di riferimento. Tuttavia, se necessario, è possibile modificare il codice sorgente e caricare gli artefatti e sviluppare gli artefatti autonomamente.
L'implementazione di riferimento è un progetto [Apache Maven](https://maven.apache.org/) che presenta i seguenti moduli:
+ `hms-service-api` – Contiene le operazioni API tra la funzione Lambda e i client del servizio Athena. Queste operazioni API sono definite nell'interfaccia `HiveMetaStoreService`. Poiché si tratta di un contratto di servizio, non è necessario modificare nulla in questo modulo.
+ `hms-lambda-handler` – Un insieme di gestori Lambda predefiniti che elaborano tutte le chiamate API al metastore Hive. La classe `MetadataHandler` è il dispatcher per tutte le chiamate API. Non è necessario modificare questo pacchetto.
+ `hms-lambda-func` – Una funzione Lambda di esempio con i seguenti componenti.
+ `HiveMetaStoreLambdaFunc` Una funzione Lambda di esempio che estende `MetadataHandler`.
+ `ThriftHiveMetaStoreClient`: Un client Thrift che comunica con il metastore Hive. Questo client è stato predisposto per Hive 2.3.0. Se si utilizza una versione di Hive diversa, potrebbe essere necessario aggiornare questa classe per assicurarsi che gli oggetti di risposta siano compatibili.
+ `ThriftHiveMetaStoreClientFactory` – Controlla il comportamento della funzione Lambda. Ad esempio, è possibile fornire il proprio set di provider di gestori sovrascrivendo il metodo `getHandlerProvider()`.
+ `hms.properties` – Configura funzione Lambda La maggior parte dei casi d’uso richiede solo l'aggiornamento delle due proprietà seguenti.
+ `hive.metastore.uris`: l’URI del metastore Hive nel formato `thrift://:9083`.
+ `hive.metastore.response.spill.location`: la posizione Amazon S3 in cui archiviare gli oggetti di risposta quando le loro dimensioni superano una determinata soglia (ad esempio, 4 MB). La soglia viene definita nella proprietà `hive.metastore.response.spill.threshold`. La modifica del valore predefinito non è consigliata.
**Nota**
Queste due proprietà possono essere sovrascritte dalle [variabili di ambiente Lambda](https://docs.aws.amazon.com/lambda/latest/dg/env_variables.html) `HMS_URIS` e `SPILL_LOCATION`. Utilizzare queste variabili invece di ricompilare il codice sorgente per la funzione Lambda quando si desidera utilizzare la funzione con una diversa posizione del metastore Hive o con una diversa posizione di spill.
+ `hms-lambda-layer`: un progetto assembly di Maven che inserisce `hms-service-api`, `hms-lambda-handler` e le loro dipendenze in un file `.zip`. Il file `.zip` viene registrato come layer Lambda per l'utilizzo da parte di più funzioni Lambda.
+ `hms-lambda-rnp`: registra le risposte di una funzione Lambda e le utilizza per riprodurre la risposta. Puoi utilizzare questo modello per simulare le risposte Lambda per i test.
## Costruire gli artefatti in modo autonomo
Dopo aver modificato il codice sorgente, è possibile creare manualmente gli artefatti e caricarli in una posizione Amazon S3.
Prima di creare gli artefatti, aggiornare le proprietà `hive.metastore.uris` e `hive.metastore.response.spill.location` nel file `hms.properties` nel modulo `hms-lambda-func`.
Per costruire gli artefatti, è necessario avere installato Apache Maven ed eseguire il comando `mvn install`. Questo genera il layer del file `.zip` nella cartella di output chiamata `target` nel modulo `hms-lambda-layer` e il file `.jar` della funzione Lambda nel modulo `hms-lambd-func`.