Questo tutorial mostra come utilizzare Apache Hive su Dataproc in modo efficiente e flessibile archiviando i dati di Hive in Cloud Storage e ospitando il metastore Hive in un database MySQL su Cloud SQL. Questa separazione tra risorse di calcolo e di archiviazione offre alcuni vantaggi:
- Flessibilità e agilità: puoi personalizzare le configurazioni del cluster per carichi di lavoro Hive specifici e fare lo scale up e lo scale down di ogni cluster in modo indipendente in base alle tue esigenze.
- Risparmi sui costi: puoi avviare un cluster temporaneo quando devi eseguire un job Hive ed eliminarlo al termine del job. Le risorse richieste dai tuoi job sono attive solo se vengono utilizzate, quindi paghi solo per quello che utilizzi. Puoi anche utilizzare VM prerilasciabili per l'elaborazione di dati non critici o per creare cluster molto grandi a un costo totale inferiore.
Hive è un noto sistema di data warehouse open source basato su Apache Hadoop. Hive offre un linguaggio di query di tipo SQL, chiamato HiveQL, che viene utilizzato per analizzare grandi set di dati strutturati. Il metastore Hive contiene metadati sulle tabelle Hive, ad esempio schema e posizione. Dove MySQL viene comunemente utilizzato come backend per il metastore Hive, Cloud SQL semplifica la configurazione, la manutenzione, la gestione e l'amministrazione dei database relazionali su Google Cloud.
Obiettivi
- Creare un'istanza MySQL su Cloud SQL per il metastore Hive.
- Eseguire il deployment dei server Hive su Dataproc.
- Installa il proxy Cloud SQL sulle istanze del cluster Dataproc.
- Caricare i dati Hive in Cloud Storage.
- Eseguire query Hive su più cluster Dataproc.
Costi
Questo tutorial utilizza i seguenti componenti fatturabili di Google Cloud:
- Dataproc
- Cloud Storage
- Cloud SQL
Puoi utilizzare il Calcolatore prezzi per generare una stima dei costi in base all'utilizzo previsto.
I nuovi utenti di Google Cloud potrebbero essere idonei a usufruire di una prova gratuita.
Prima di iniziare
Crea un nuovo progetto
-
Nella console Google Cloud, vai alla pagina del selettore progetto.
-
Seleziona o crea un progetto Google Cloud.
Abilita fatturazione
Inizializza l'ambiente
Avvia un'istanza di Cloud Shell:
In Cloud Shell, imposta la zona predefinita di Compute Engine sulla zona in cui creerai i tuoi cluster Dataproc.
export PROJECT=$(gcloud info --format='value(config.project)') export REGION=REGION export ZONE=ZONE gcloud config set compute/zone ${ZONE}Sostituisci quanto segue:
REGION: la regione in cui vuoi creare il cluster, ad esempious-central1.ZONE: la zona in cui vuoi creare il cluster, ad esempious-central1-a.
Abilita le API Dataproc e Cloud SQL Admin eseguendo questo comando in Cloud Shell:
gcloud services enable dataproc.googleapis.com sqladmin.googleapis.com
Architettura di riferimento
Per semplicità, in questo tutorial esegui il deployment di tutti i servizi di computing e archiviazione nella stessa area geografica di Google Cloud per ridurre al minimo la latenza di rete e i costi di trasporto della rete. La Figura 1 presenta l'architettura di questo tutorial.
Con questa architettura, il ciclo di vita di una query Hive segue questi passaggi:
- Il client Hive invia una query a un server Hive eseguito in un cluster Dataproc temporaneo.
- Il server elabora la query e richiede i metadati dal servizio metastore.
- Il servizio Metastore recupera i metadati Hive da Cloud SQL tramite il proxy Cloud SQL.
- Il server carica i dati dal warehouse Hive situato in un bucket a livello di regione in Cloud Storage.
- Il server restituisce il risultato al client.
Considerazioni per le architetture multiregionali
Questo tutorial è incentrato su un'architettura a regione singola. Tuttavia, puoi prendere in considerazione un'architettura multiregionale se devi eseguire server Hive in diverse aree geografiche. In tal caso, devi creare cluster Dataproc separati dedicati all'hosting del servizio metastore e che si trovano nella stessa area geografica dell'istanza Cloud SQL. A volte il servizio di metastore può inviare volumi elevati di richieste al database MySQL, quindi è fondamentale che il servizio di metastore sia geograficamente vicino al database MySQL per ridurre al minimo l'impatto sulle prestazioni. Invece, il server Hive in genere invia molte meno richieste al servizio Metastore. Pertanto, può essere più accettabile per il server Hive e il servizio di metastore risiedere in aree geografiche diverse nonostante l'aumento della latenza.
Il servizio Metastore può essere eseguito solo sui nodi master di Dataproc, non sui nodi worker. Dataproc applica almeno 2 nodi worker nei cluster standard e nei cluster ad alta disponibilità. Per evitare di sprecare risorse sui nodi worker inutilizzati, puoi creare un cluster nodo singolo per il servizio metastore. Per ottenere un'alta disponibilità, puoi creare più cluster a nodo singolo.
Il proxy Cloud SQL deve essere installato solo nei cluster di servizi Metastore, perché solo i cluster di servizi Metastore devono connettersi direttamente all'istanza Cloud SQL. I server Hive quindi rimandano ai cluster di servizio del metastore impostando la proprietà hive.metastore.uris
sull'elenco di URI separati da virgole. Ad esempio:
thrift://metastore1:9083,thrift://metastore2:9083
Puoi anche valutare l'utilizzo di un bucket a doppia area geografica o a più aree geografiche se devi accedere ai dati Hive dai server Hive che si trovano in più località. La scelta tra diversi tipi di località dei bucket dipende dal caso d'uso. Devi bilanciare latenza, disponibilità e costi.
La figura 2 mostra un esempio di architettura multiregionale.
Come puoi vedere, lo scenario multiregionale è leggermente più complesso. Per mantenere la concisione, questo tutorial utilizza un'architettura a regione singola.
(Facoltativo) Creazione del bucket del warehouse
Se non hai un bucket Cloud Storage per archiviare i dati Hive, crea un bucket warehouse (puoi eseguire i comandi seguenti in Cloud Shell) sostituendo BUCKET_NAME con un nome di bucket univoco:
export WAREHOUSE_BUCKET=BUCKET_NAME
gsutil mb -l ${REGION} gs://${WAREHOUSE_BUCKET}
Creazione dell'istanza Cloud SQL
In questa sezione creerai una nuova istanza di Cloud SQL che in seguito verrà utilizzata per ospitare il metastore Hive.
In Cloud Shell, crea una nuova istanza di Cloud SQL:
gcloud sql instances create hive-metastore \
--database-version="MYSQL_5_7" \
--activation-policy=ALWAYS \
--zone ${ZONE}
Il completamento di questo comando potrebbe richiedere alcuni minuti.
Creazione di un cluster Dataproc
Crea il primo cluster Dataproc, sostituendo CLUSTER_NAME con un nome come hive-cluster :
gcloud dataproc clusters create CLUSTER_NAME \
--scopes sql-admin \
--region ${REGION} \
--initialization-actions gs://goog-dataproc-initialization-actions-${REGION}/cloud-sql-proxy/cloud-sql-proxy.sh \
--properties "hive:hive.metastore.warehouse.dir=gs://${WAREHOUSE_BUCKET}/datasets" \
--metadata "hive-metastore-instance=${PROJECT}:${REGION}:hive-metastore" \
--metadata "enable-cloud-sql-proxy-on-workers=false"
Note:
- Fornisci l'ambito di accesso
sql-adminper consentire alle istanze del cluster di accedere all'API Cloud SQL Admin. - Puoi inserire l'azione di inizializzazione in uno script archiviato in un bucket Cloud Storage e fare riferimento a tale bucket con il flag
--initialization-actions. Per ulteriori informazioni, consulta Azioni di inizializzazione - Considerazioni e linee guida importanti. - Fornisci l'URI al bucket del warehouse Hive nella proprietà
hive:hive.metastore.warehouse.dir. Questo consente di configurare i server Hive da cui leggere e scrivere nella posizione corretta. Questa proprietà deve contenere almeno una directory (ad esempiogs://my-bucket/my-directory); Hive non funzionerà correttamente se la proprietà è impostata sul nome di un bucket senza directory (ad esempiogs://my-bucket). - Specifica
enable-cloud-sql-proxy-on-workers=falseper assicurarti che il proxy Cloud SQL venga eseguito solo sui nodi master, operazione sufficiente per il funzionamento del servizio Metastore Hive ed evitare il carico non necessario su Cloud SQL. Fornisci l'azione di inizializzazione del proxy Cloud SQL che Dataproc esegue automaticamente su tutte le istanze del cluster. L'azione esegue le seguenti operazioni:
- Installa il proxy Cloud SQL.
- Stabilisce una connessione sicura all'istanza Cloud SQL specificata nel parametro di metadati
hive-metastore-instance. - Crea l'utente
hivee il database del metastore Hive.
Puoi visualizzare il codice completo per l'azione di inizializzazione del proxy Cloud SQL su GitHub.
Per semplicità, questo tutorial utilizza una sola istanza master. Per aumentare la resilienza dei carichi di lavoro di produzione, considera la creazione di un cluster con tre istanze master utilizzando la modalità ad alta disponibilità di Dataproc.
Questo tutorial utilizza un'istanza Cloud SQL con un indirizzo IP pubblico. Se invece utilizzi un'istanza con solo un indirizzo IP privato, puoi forzare il proxy a utilizzare l'indirizzo IP privato passando il parametro
--metadata "use-cloud-sql-private-ip=true".
Creazione di una tabella Hive
In questa sezione caricherai un set di dati di esempio nel tuo bucket di warehouse, creerai una nuova tabella Hive ed eseguirai alcune query HiveQL su quel set di dati.
Copia il set di dati di esempio nel tuo bucket di warehouse:
gsutil cp gs://hive-solution/part-00000.parquet \ gs://${WAREHOUSE_BUCKET}/datasets/transactions/part-00000.parquetIl set di dati di esempio è compresso in formato Parquet e contiene migliaia di record di transazioni bancarie fittizie con tre colonne: data, importo e tipo di transazione.
Crea una tabella Hive esterna per il set di dati:
gcloud dataproc jobs submit hive \ --cluster CLUSTER_NAME \ --region ${REGION} \ --execute " CREATE EXTERNAL TABLE transactions (SubmissionDate DATE, TransactionAmount DOUBLE, TransactionType STRING) STORED AS PARQUET LOCATION 'gs://${WAREHOUSE_BUCKET}/datasets/transactions';"
Esecuzione di query Hive
Puoi utilizzare diversi strumenti all'interno di Dataproc per eseguire query Hive. In questa sezione imparerai a eseguire query utilizzando i seguenti strumenti:
- L'API Job di Hive di Dataproc.
- Beeline, un popolare client a riga di comando basato su SQLLine.
- SparkSQL, l'API Apache Spark per eseguire query sui dati strutturati.
In ogni sezione esegui una query di esempio.
Query su Hive con l'API Dataproc Jobs
Esegui la seguente query HiveQL semplice per verificare che il file parquet sia collegato correttamente alla tabella HiveQL:
gcloud dataproc jobs submit hive \
--cluster CLUSTER_NAME \
--region ${REGION} \
--execute "
SELECT *
FROM transactions
LIMIT 10;"
L'output include quanto segue:
+-----------------+--------------------+------------------+ | submissiondate | transactionamount | transactiontype | +-----------------+--------------------+------------------+ | 2017-12-03 | 1167.39 | debit | | 2017-09-23 | 2567.87 | debit | | 2017-12-22 | 1074.73 | credit | | 2018-01-21 | 5718.58 | debit | | 2017-10-21 | 333.26 | debit | | 2017-09-12 | 2439.62 | debit | | 2017-08-06 | 5885.08 | debit | | 2017-12-05 | 7353.92 | authorization | | 2017-09-12 | 4710.29 | authorization | | 2018-01-05 | 9115.27 | debit | +-----------------+--------------------+------------------+
Esecuzione di query su Hive con Beeline
Apri una sessione SSH con l'istanza master di Dataproc(
CLUSTER_NAME-m):gcloud compute ssh CLUSTER_NAME-m
Nel prompt dei comandi dell'istanza master, apri una sessione di Beeline:
beeline -u "jdbc:hive2://localhost:10000"
Note:
Puoi anche fare riferimento al nome dell'istanza master come host anziché
localhost:beeline -u "jdbc:hive2://CLUSTER_NAME-m:10000"
Se utilizzi la modalità ad alta disponibilità con 3 master, devi utilizzare invece il seguente comando:
beeline -u "jdbc:hive2://CLUSTER_NAME-m-0:2181,CLUSTER_NAME-m-1:2181,CLUSTER_NAME-m-2:2181/;serviceDiscoveryMode=zooKeeper;zooKeeperNamespace=hiveserver2"
Quando viene visualizzato il prompt di Beeline, esegui questa query HiveQL:
SELECT TransactionType, AVG(TransactionAmount) AS AverageAmount FROM transactions WHERE SubmissionDate = '2017-12-22' GROUP BY TransactionType;
L'output include quanto segue:
+------------------+--------------------+ | transactiontype | averageamount | +------------------+--------------------+ | authorization | 4890.092525252529 | | credit | 4863.769269565219 | | debit | 4982.781458176331 | +------------------+--------------------+
Chiudi la sessione Beeline:
!quit
Chiudi la connessione SSH:
exit
Esecuzione di query su Hive con SparkSQL
Apri una sessione SSH con l'istanza master di Dataproc:
gcloud compute ssh CLUSTER_NAME-m
Nel prompt dei comandi dell'istanza master, apri una nuova sessione di shell di PySpark:
pyspark
Quando viene visualizzato il prompt della shell di PySpark, digita il seguente codice Python:
from pyspark.sql import HiveContext hc = HiveContext(sc) hc.sql(""" SELECT SubmissionDate, AVG(TransactionAmount) as AvgDebit FROM transactions WHERE TransactionType = 'debit' GROUP BY SubmissionDate HAVING SubmissionDate >= '2017-10-01' AND SubmissionDate < '2017-10-06' ORDER BY SubmissionDate """).show()L'output include quanto segue:
+-----------------+--------------------+ | submissiondate | avgdebit | +-----------------+--------------------+ | 2017-10-01 | 4963.114920399849 | | 2017-10-02 | 5021.493300510582 | | 2017-10-03 | 4982.382279569891 | | 2017-10-04 | 4873.302702503676 | | 2017-10-05 | 4967.696333583777 | +-----------------+--------------------+
Chiudi la sessione PySpark:
exit()
Chiudi la connessione SSH:
exit
Ispezione del metastore Hive
Ora verifichi che il metastore Hive in Cloud SQL contenga
informazioni sulla tabella transactions.
In Cloud Shell, avvia una nuova sessione MySQL sull'istanza Cloud SQL:
gcloud sql connect hive-metastore --user=root
Quando ti viene richiesta la password utente di
root, non digitare nulla e premi semplicemente il tastoRETURN. Per semplicità, in questo tutorial non hai impostato nessuna password per l'utenteroot. Per informazioni sull'impostazione di una password per proteggere ulteriormente il database del metastore, consulta la documentazione di Cloud SQL. L'azione di inizializzazione del proxy Cloud SQL fornisce inoltre un meccanismo per proteggere le password tramite la crittografia. Per ulteriori informazioni, consulta il repository del codice dell'azione.Nel prompt dei comandi di MySQL, imposta
hive_metastorecome database predefinito per il resto della sessione:USE hive_metastore;
Verifica che la località del bucket di warehouse sia registrata nel metastore:
SELECT DB_LOCATION_URI FROM DBS;
L'output ha il seguente aspetto:
+-------------------------------------+ | DB_LOCATION_URI | +-------------------------------------+ | gs://[WAREHOUSE_BUCKET]/datasets | +-------------------------------------+
Verifica che nel metastore venga fatto riferimento correttamente alla tabella:
SELECT TBL_NAME, TBL_TYPE FROM TBLS;
L'output ha il seguente aspetto:
+--------------+----------------+ | TBL_NAME | TBL_TYPE | +--------------+----------------+ | transactions | EXTERNAL_TABLE | +--------------+----------------+
Verifica che anche le colonne della tabella facciano riferimento correttamente:
SELECT COLUMN_NAME, TYPE_NAME FROM COLUMNS_V2 c, TBLS t WHERE c.CD_ID = t.SD_ID AND t.TBL_NAME = 'transactions';
L'output ha il seguente aspetto:
+-------------------+-----------+ | COLUMN_NAME | TYPE_NAME | +-------------------+-----------+ | submissiondate | date | | transactionamount | double | | transactiontype | string | +-------------------+-----------+
Verifica che anche il formato di input e la posizione siano indicati correttamente:
SELECT INPUT_FORMAT, LOCATION FROM SDS s, TBLS t WHERE s.SD_ID = t.SD_ID AND t.TBL_NAME = 'transactions';
L'output ha il seguente aspetto:
+---------------------------------------------------------------+------------------------------------------------+ | INPUT_FORMAT | LOCATION | +---------------------------------------------------------------+------------------------------------------------+ | org.apache.hadoop.hive.ql.io.parquet.MapredParquetInputFormat | gs://[WAREHOUSE_BUCKET]/datasets/transactions | +---------------------------------------------------------------+------------------------------------------------+
Chiudi la sessione MySQL:
exit
Creazione di un altro cluster Dataproc
In questa sezione creerai un altro cluster Dataproc per verificare che i dati Hive e Hive possano essere condivisi tra più cluster.
Crea un nuovo cluster Dataproc:
gcloud dataproc clusters create other-CLUSTER_NAME \ --scopes cloud-platform \ --image-version 2.0 \ --region ${REGION} \ --initialization-actions gs://goog-dataproc-initialization-actions-${REGION}/cloud-sql-proxy/cloud-sql-proxy.sh \ --properties "hive:hive.metastore.warehouse.dir=gs://${WAREHOUSE_BUCKET}/datasets" \ --metadata "hive-metastore-instance=${PROJECT}:${REGION}:hive-metastore"\ --metadata "enable-cloud-sql-proxy-on-workers=false"Verifica che il nuovo cluster possa accedere ai dati:
gcloud dataproc jobs submit hive \ --cluster other-CLUSTER_NAME \ --region ${REGION} \ --execute " SELECT TransactionType, COUNT(TransactionType) as Count FROM transactions WHERE SubmissionDate = '2017-08-22' GROUP BY TransactionType;"L'output include quanto segue:
+------------------+--------+ | transactiontype | count | +------------------+--------+ | authorization | 696 | | credit | 1722 | | debit | 2599 | +------------------+--------+
Congratulazioni, hai completato il tutorial!
Esegui la pulizia
Per evitare che al tuo Account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.
Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial:
- Eseguire la pulizia delle risorse che hai creato, in modo che non ti vengano addebitati in futuro. Il modo più semplice per eliminare la fatturazione è eliminare il progetto che hai creato per il tutorial.
- In alternativa, puoi eliminare le singole risorse.
Elimina il progetto
- Nella console Google Cloud, vai alla pagina Gestisci risorse.
- Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
- Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.
Eliminare singole risorse
Esegui i comandi seguenti in Cloud Shell per eliminare singole risorse invece di eliminare l'intero progetto:
gcloud dataproc clusters delete CLUSTER_NAME --region ${REGION} --quiet
gcloud dataproc clusters delete other-CLUSTER_NAME --region ${REGION} --quiet
gcloud sql instances delete hive-metastore --quiet
gsutil rm -r gs://${WAREHOUSE_BUCKET}/datasets
Passaggi successivi
- Prova BigQuery, il data warehouse aziendale serverless, a scalabilità elevata e dai costi contenuti di Google.
- Consulta questa guida sulla migrazione dei carichi di lavoro Hadoop in Google Cloud.
- Consulta questa azione di inizializzazione per ulteriori dettagli su come utilizzare Hive HCatalog su Dataproc.
- Scopri come configurare Cloud SQL per l'alta disponibilità in modo da aumentare l'affidabilità del servizio.
- Esplora architetture di riferimento, diagrammi e best practice su Google Cloud. Dai un'occhiata al nostro Cloud Architecture Center.