Esegui il deployment di Apache Hive su Dataproc

Last reviewed 2023-05-08 UTC

Questo documento descrive come eseguire il deployment dell'architettura in Utilizzare Apache Hive su Dataproc.

Questo documento è rivolto ad architetti cloud e data engineer interessati al deployment di Apache Hive su Dataproc e Hive Metastore in Cloud SQL.

In questa guida al deployment, esegui il deployment di tutti i servizi di calcolo e archiviazione nella stessa Google Cloud regione per ridurre al minimo la latenza di rete e i costi di trasporto di rete.

Il seguente diagramma mostra il ciclo di vita di una query Hive.

Diagramma di un'architettura a regione singola.

Nel diagramma, il client Hive invia una query, che viene elaborata, recuperata e restituita. L'elaborazione avviene nel server Hive. I dati vengono richiesti e restituiti da un magazzino Hive archiviato in un bucket regionale in Cloud Storage.

Obiettivi

  • Crea un'istanza MySQL su Cloud SQL per il metastore Hive.
  • Esegui il deployment dei server Hive su Dataproc.
  • Installa il proxy Cloud SQL sulle istanze del cluster Dataproc.
  • Carica i dati di Hive in Cloud Storage.
  • Esegui query Hive su più cluster Dataproc.

Costi

Questo deployment 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 Google Cloud utenti potrebbero avere diritto a una prova gratuita.

Al termine di questo deployment, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, vedi Pulizia.

Prima di iniziare

  1. Nella console Google Cloud, nella pagina di selezione del progetto, seleziona o crea un progetto Google Cloud.

    Vai al selettore dei progetti

  2. Verifica che la fatturazione sia attivata per il tuo progetto Google Cloud. Scopri come verificare se la fatturazione è abilitata in un progetto.

Inizializza l'ambiente

  1. Avvia un'istanza Cloud Shell:

    Vai a Cloud Shell

  2. In Cloud Shell, imposta la zona Compute Engine predefinita sulla zona in cui creerai i 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 esempio us-central1.
    • ZONE: la zona in cui vuoi creare il cluster, ad esempio us-central1-a.
  3. Abilita le API Dataproc e Cloud SQL Admin eseguendo questo comando in Cloud Shell:

    gcloud services enable dataproc.googleapis.com sqladmin.googleapis.com

(Facoltativo) Creazione del bucket del magazzino

Se non hai un bucket Cloud Storage per archiviare i dati di Hive, crea un bucket del magazzino (puoi eseguire i comandi seguenti in Cloud Shell) sostituendo BUCKET_NAME con un nome univoco del bucket:

export WAREHOUSE_BUCKET=BUCKET_NAME
gcloud storage buckets create gs://${WAREHOUSE_BUCKET} --location=${REGION}

Creazione dell'istanza Cloud SQL

In questa sezione crei una nuova istanza Cloud SQL che verrà successivamente utilizzata per ospitare il metastore Hive.

In Cloud Shell, crea una nuova istanza 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" \
    --public-ip-address

Note:

  • Fornisci l'sql-admin ambito di accesso per consentire alle istanze del cluster di accedere all'API Cloud SQL Admin.
  • Tu inserisci l'azione di inizializzazione in uno script archiviato in un bucket Cloud Storage e fai riferimento a quel bucket con il flag --initialization-actions. Per ulteriori informazioni, consulta la sezione Azioni di inizializzazione: considerazioni importanti e linee guida.
  • Fornisci l'URI del bucket del warehouse Hive nella proprietà hive:hive.metastore.warehouse.dir. In questo modo, i server Hive vengono configurati per leggere e scrivere nella posizione corretta. Questa proprietà deve contenere almeno una directory (ad esempio gs://my-bucket/my-directory). Hive non funzionerà correttamente se questa proprietà è impostata su un nome del bucket senza una directory (ad esempio gs://my-bucket).
  • Specifica enable-cloud-sql-proxy-on-workers=false per assicurarti che Proxy Cloud SQL venga eseguito solo sui nodi master, il che è sufficiente per il funzionamento del servizio metastore Hive ed evita un 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 quanto segue:

    • Installa il proxy Cloud SQL.
    • Stabilisce una connessione sicura all'istanza Cloud SQL specificata nel parametro dei metadati hive-metastore-instance.
    • Crea l'utente hive e il database del metastore Hive.

    Puoi visualizzare il codice completo per l'azione di inizializzazione di Cloud SQL Proxy su GitHub.

  • Questo deployment utilizza un'istanza Cloud SQL con 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". +. Il flag --public-ip-address è necessario per consentire al proxy Cloud SQL di collegarsi all'istanza Cloud SQL.

Creazione di una tabella Hive

In questa sezione caricherai un set di dati di esempio nel bucket del tuo data warehouse, creerai una nuova tabella Hive ed eseguirai alcune query HiveQL sul set di dati.

  1. Copia il set di dati di esempio nel bucket del tuo data warehouse:

    gcloud storage cp gs://hive-solution/part-00000.parquet \
    gs://${WAREHOUSE_BUCKET}/datasets/transactions/part-00000.parquet

    Il set di dati di esempio è compresso nel formato Parquet e contiene migliaia di record di transazioni bancarie fittizie con tre colonne: data, importo e tipo di transazione.

  2. 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 in Dataproc per eseguire query Hive. In questa sezione imparerai a eseguire query utilizzando i seguenti strumenti:

In ogni sezione viene eseguita una query di esempio.

Eseguire query su Hive con l'API Dataproc Jobs

Esegui la seguente semplice query HiveQL per verificare che il file parquet sia collegato correttamente alla tabella Hive:

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            |
+-----------------+--------------------+------------------+

Eseguire query su Hive con Beeline

  1. Apri una sessione SSH con l'istanza principale di Dataproc(CLUSTER_NAME-m):

    gcloud compute ssh CLUSTER_NAME-m
  2. Nel prompt dei comandi dell'istanza principale, apri una sessione Beeline:

    beeline -u "jdbc:hive2://localhost:10000"

    Note:

    • Puoi anche fare riferimento al nome dell'istanza principale come host anziché localhost:

      beeline -u "jdbc:hive2://CLUSTER_NAME-m:10000"
    • Se utilizzavi la modalità di alta disponibilità con 3 master, dovresti utilizzare 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"
  3. Quando viene visualizzato il prompt di Beeline, esegui la seguente 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  |
    +------------------+--------------------+
  4. Chiudi la sessione Beeline:

    !quit
  5. Chiudi la connessione SSH:

    exit

Eseguire query su Hive con SparkSQL

  1. Apri una sessione SSH con l'istanza principale di Dataproc:

    gcloud compute ssh CLUSTER_NAME-m
  2. Nel prompt dei comandi dell'istanza principale, apri una nuova sessione della shell PySpark:

    pyspark
  3. Quando viene visualizzato il prompt della shell 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  |
    +-----------------+--------------------+
  4. Chiudi la sessione PySpark:

    exit()
  5. Chiudi la connessione SSH:

    exit

Ispezione del metastore Hive

Ora verifica che il metastore Hive in Cloud SQL contenga informazioni sulla tabella transactions.

  1. In Cloud Shell, avvia una nuova sessione MySQL sull'istanza Cloud SQL:

    gcloud sql connect hive-metastore --user=root

    Quando ti viene chiesta la password dell'utente root, non digitare nulla e preme il tasto RETURN. Per semplicità, in questo deployment non hai impostato alcuna password per l'utente root. Per informazioni su come impostare una password per proteggere ulteriormente il database del metastore, consulta la documentazione di Cloud SQL. L'azione di inizializzazione del proxy Cloud SQL fornisce anche un meccanismo per proteggere le password tramite crittografia. Per ulteriori informazioni, consulta il repository del codice dell'azione.

  2. Nel prompt dei comandi MySQL, imposta hive_metastore come database predefinito per il resto della sessione:

    USE hive_metastore;
  3. Verifica che la posizione del bucket del magazzino sia registrata nel metastore:

    SELECT DB_LOCATION_URI FROM DBS;

    L'output è il seguente:

    +-------------------------------------+
    | DB_LOCATION_URI                     |
    +-------------------------------------+
    | gs://[WAREHOUSE_BUCKET]/datasets   |
    +-------------------------------------+
  4. Verifica che alla tabella sia fatto riferimento correttamente nel metastore:

    SELECT TBL_NAME, TBL_TYPE FROM TBLS;

    L'output è il seguente:

    +--------------+----------------+
    | TBL_NAME     | TBL_TYPE       |
    +--------------+----------------+
    | transactions | EXTERNAL_TABLE |
    +--------------+----------------+
  5. Verifica che anche le colonne della tabella siano referenziate 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 è il seguente:

    +-------------------+-----------+
    | COLUMN_NAME       | TYPE_NAME |
    +-------------------+-----------+
    | submissiondate    | date      |
    | transactionamount | double    |
    | transactiontype   | string    |
    +-------------------+-----------+
  6. Verifica che anche il formato e la posizione di input siano correttamente indicati:

    SELECT INPUT_FORMAT, LOCATION
    FROM SDS s, TBLS t
    WHERE s.SD_ID = t.SD_ID AND t.TBL_NAME = 'transactions';

    L'output è il seguente:

    +---------------------------------------------------------------+------------------------------------------------+
    | INPUT_FORMAT                                                  | LOCATION                                       |
    +---------------------------------------------------------------+------------------------------------------------+
    | org.apache.hadoop.hive.ql.io.parquet.MapredParquetInputFormat | gs://[WAREHOUSE_BUCKET]/datasets/transactions |
    +---------------------------------------------------------------+------------------------------------------------+
    
  7. Chiudi la sessione MySQL:

    exit

Creazione di un altro cluster Dataproc

In questa sezione crei un altro cluster Dataproc per verificare che i dati e il metastore Hive possano essere condivisi su più cluster.

  1. 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"
  2. 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 i passaggi di deployment.

Esegui la pulizia

Le sezioni seguenti spiegano come evitare addebiti futuri per il progetto Google Cloud e le risorse Apache Hive e Dataproc utilizzate in questo dispiegamento.

Elimina il progetto Google Cloud

Per evitare che al tuo Google Cloud account vengano addebitati costi relativi alle risorse utilizzate in questo deployment, puoi eliminare il progetto Google Cloud.

  1. In the Google Cloud console, go to the Manage resources page.

    Go to Manage resources

  2. In the project list, select the project that you want to delete, and then click Delete.
  3. In the dialog, type the project ID, and then click Shut down to delete the project.

Eliminazione di singole risorse

Esegui i seguenti comandi in Cloud Shell per eliminare le singole risorse anziché 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
gcloud storage rm gs://${WAREHOUSE_BUCKET}/datasets --recursive

Passaggi successivi