Déployer Apache Hive sur Dataproc

Last reviewed 2023-05-08 UTC

Ce document explique comment déployer l'architecture sur la page Utiliser Apache Hive sur Dataproc.

Ce document est destiné aux architectes de cloud et aux ingénieurs de données qui souhaitent déployer Apache Hive sur Dataproc et le métastore Hive dans Cloud SQL.

Architecture

Dans ce guide de déploiement, vous déployez tous les services de calcul et de stockage dans la même région Google Cloud afin de minimiser la latence et les coûts de transport du réseau.

Le schéma suivant illustre le cycle de vie d'une requête Hive.

Dans le schéma, le client Hive envoie une requête, qui est traitée, extraite et renvoyée. Le traitement s'effectue sur le serveur Hive. Les données sont demandées et récupérées à partir d'un entrepôt Hive stocké dans un bucket régional de Cloud Storage.

Objectifs

Créer une instance MySQL sur Cloud SQL pour le métastore Hive
Déployer des serveurs Hive sur Dataproc
Installer le proxy Cloud SQL sur les instances de cluster Dataproc.
Importer des données Hive vers Cloud Storage
Exécuter des requêtes Hive sur plusieurs clusters Dataproc

Coûts

Ce déploiement utilise les composants facturables de Google Cloud suivants :

Dataproc
Cloud Storage
Cloud SQL

Vous pouvez utiliser le Simulateur de coût pour générer une estimation du coût en fonction de votre utilisation prévue.

Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Une fois que vous avez terminé ce déploiement, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Avant de commencer

Dans la console Google Cloud, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

Remarque : Si vous ne comptez pas conserver les ressources créées dans ce déploiement, créez un projet au lieu d'en sélectionner un existant. Une fois le déploiement terminé, vous pouvez supprimer le projet afin de supprimer toutes les ressources qui lui sont associées.

Accéder au sélecteur de projet
Vérifiez que la facturation est activée pour votre projet Google Cloud. Découvrez comment vérifier si la facturation est activée sur un projet.

Initialiser l'environnement

Démarrez une instance Cloud Shell :

Accéder à Cloud Shell
Dans Cloud Shell, définissez la zone Compute Engine par défaut sur la zone dans laquelle vous allez créer vos clusters Dataproc.
```
export PROJECT=$(gcloud info --format='value(config.project)')
export REGION=REGION
export ZONE=ZONE
gcloud config set compute/zone ${ZONE}
```
Remplacez les éléments suivants :
- REGION : région dans laquelle vous souhaitez créer le cluster, telle que us-central1.
- ZONE : zone dans laquelle vous souhaitez créer le cluster, telle que us-central1-a.
Activez les API Dataproc et Cloud SQL Admin en exécutant la commande suivante dans Cloud Shell :
```
gcloud services enable dataproc.googleapis.com sqladmin.googleapis.com
```

(Facultatif) Créer le bucket d'entrepôt

Si vous n'avez pas de bucket Cloud Storage pour stocker des données Hive, créez un bucket d'entrepôt (vous pouvez exécuter les commandes suivantes dans Cloud Shell) en remplaçant BUCKET_NAME par un nom de bucket unique :

export WAREHOUSE_BUCKET=BUCKET_NAME
gsutil mb -l ${REGION} gs://${WAREHOUSE_BUCKET}

Créer l'instance Cloud SQL

Dans cette section, vous allez créer une nouvelle instance Cloud SQL qui sera ultérieurement utilisée pour héberger le métastore Hive.

Dans Cloud Shell, créez une instance Cloud SQL :

gcloud sql instances create hive-metastore \
    --database-version="MYSQL_5_7" \
    --activation-policy=ALWAYS \
    --zone ${ZONE}

L'exécution de cette commande peut prendre quelques minutes.

Création d'un cluster Dataproc

Créez le premier cluster Dataproc, en remplaçant CLUSTER_NAME par un nom tel que 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"

Remarques :

Vous devez fournir le champ d'application d'accès sql-admin afin d'autoriser les instances du cluster à accéder à l'API Cloud SQL Admin.
Vous placez l'action d'initialisation dans un script que vous stockez dans un bucket Cloud Storage, puis vous référencez ce bucket avec l'option --initialization-actions. Pour en savoir plus, consultez la section Consignes et remarques importantes de la page Actions d'initialisation.
Vous devez fournir l'URI au bucket d'entrepôt Hive dans la propriété hive:hive.metastore.warehouse.dir. Cela configure les serveurs Hive de sorte qu'ils puissent lire depuis l'emplacement correct et écrire à cet emplacement. Cette propriété doit contenir au moins un répertoire (par exemple, gs://my-bucket/my-directory). Hive ne fonctionnera pas correctement si cette propriété est définie sur un nom de bucket sans répertoire (par exemple, gs://my-bucket).
Vous devez spécifier enable-cloud-sql-proxy-on-workers=false pour vous assurer que le proxy Cloud SQL ne s'exécute que sur les nœuds maîtres, ce qui est suffisant pour que le service de métastore Hive fonctionne et évite une charge inutile sur Cloud SQL.
Vous devez fournir l'action d'initialisation du proxy Cloud SQL que Dataproc exécute automatiquement sur toutes les instances de cluster. L'action a les effets suivants :
- Elle installe le proxy Cloud SQL.
- Elle établit une connexion sécurisée à l'instance Cloud SQL spécifiée dans le paramètre de métadonnées hive-metastore-instance.
- Elle crée l'utilisateur hive et la base de données du métastore Hive.
Vous pouvez consulter le code complet de l'action d'initialisation du proxy Cloud SQL sur GitHub.
Ce déploiement utilise une instance Cloud SQL avec une adresse IP publique. Si vous utilisez une instance dotée seulement d'une adresse IP privée, vous pouvez forcer le proxy à utiliser l'adresse IP privée en transmettant le paramètre --metadata "use-cloud-sql-private-ip=true".

Créer une table Hive

Dans cette section, vous allez importer un exemple d'ensemble de données dans votre bucket d'entrepôt, créer une table Hive et exécuter des requêtes HiveQL sur cet ensemble de données.

Copiez l'exemple d'ensemble de données dans le bucket d'entrepôt :
```
gsutil cp gs://hive-solution/part-00000.parquet \
gs://${WAREHOUSE_BUCKET}/datasets/transactions/part-00000.parquet
```
L'exemple d'ensemble de données est compressé au format Parquet et contient des milliers d'enregistrements de transactions bancaires fictifs avec trois colonnes : date, montant et type de transaction.

Créez une table Hive externe pour l'ensemble de données :

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';"

Exécuter des requêtes Hive

Vous pouvez utiliser différents outils dans Dataproc pour exécuter des requêtes Hive. Dans cette section, vous allez apprendre à en envoyer à l'aide des outils suivants :

API Hive Jobs de Dataproc
Beeline, un client de ligne de commande populaire basé sur SQLLine
SparkSQL, l'API d'Apache Spark pour l'interrogation de données structurées

Dans chaque section, vous allez exécuter un exemple de requête.

Interroger Hive avec l'API Jobs de Dataproc

Exécutez la requête HiveQL simple suivante pour vérifier que le fichier Parquet est correctement associé à la table Hive :

gcloud dataproc jobs submit hive \
    --cluster CLUSTER_NAME \
    --region ${REGION} \
    --execute "
      SELECT *
      FROM transactions
      LIMIT 10;"

Le résultat comprend les éléments suivants :

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

Interroger Hive avec Beeline

Ouvrez une session SSH avec l'instance maître de Dataproc (CLUSTER_NAME-m) :
```
gcloud compute ssh CLUSTER_NAME-m
```
Dans l'invite de commande de l'instance maître, ouvrez une session Beeline :
```
beeline -u "jdbc:hive2://localhost:10000"
```
Remarques :
- Vous pouvez également référencer le nom de l'instance maître en tant qu'hôte à la place de localhost :
```
beeline -u "jdbc:hive2://CLUSTER_NAME-m:10000"
```
- Si vous utilisiez le mode haute disponibilité avec trois maîtres, vous devriez plutôt utiliser la commande suivante :
```
beeline -u "jdbc:hive2://CLUSTER_NAME-m-0:2181,CLUSTER_NAME-m-1:2181,CLUSTER_NAME-m-2:2181/;serviceDiscoveryMode=zooKeeper;zooKeeperNamespace=hiveserver2"
```

Lorsque l'invite Beeline apparaît, exécutez la requête HiveQL suivante :

SELECT TransactionType, AVG(TransactionAmount) AS AverageAmount
FROM transactions
WHERE SubmissionDate = '2017-12-22'
GROUP BY TransactionType;

Le résultat comprend les éléments suivants :

+------------------+--------------------+
| transactiontype  |   averageamount    |
+------------------+--------------------+
| authorization    | 4890.092525252529  |
| credit           | 4863.769269565219  |
| debit            | 4982.781458176331  |
+------------------+--------------------+

Fermez la session Beeline :
```
!quit
```
Fermez la connexion SSH :
```
exit
```

Interroger Hive avec SparkSQL

Ouvrez une session SSH avec l'instance maître de Dataproc :
```
gcloud compute ssh CLUSTER_NAME-m
```
Dans l'invite de commande de l'instance maître, ouvrez une nouvelle session d'interface système PySpark :
```
pyspark
```

Lorsque l'invite d'interface système PySpark apparaît, saisissez le code Python suivant :

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()

Le résultat comprend les éléments suivants :

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

Fermez la session PySpark :
```
exit()
```
Fermez la connexion SSH :
```
exit
```

Inspecter le métastore Hive

Vous allez maintenant vérifier que le métastore Hive dans Cloud SQL contient des informations sur la table transactions.

Dans Cloud Shell, démarrez une nouvelle session MySQL sur l'instance Cloud SQL :
```
gcloud sql connect hive-metastore --user=root
```
Lorsque vous êtes invité à saisir le mot de passe de l'utilisateur root, ne tapez rien et appuyez simplement sur la touche RETURN. Par souci de simplicité, vous n'avez défini aucun mot de passe pour l'utilisateur root dans ce déploiement. Pour plus d'informations sur la définition d'un mot de passe afin de mieux protéger la base de données métastore, reportez-vous à la documentation Cloud SQL. L'action d'initialisation du proxy Cloud SQL permet également de protéger les mots de passe grâce au chiffrement. Pour plus d'informations, consultez le dépôt de code de l'action.
Dans l'invite de commande MySQL, faites de hive_metastore la base de données par défaut pour le reste de la session :
```
USE hive_metastore;
```

Vérifiez que l'emplacement du bucket d'entrepôt est enregistré dans le métastore :

SELECT DB_LOCATION_URI FROM DBS;

Le résultat est semblable à ce qui suit :

+-------------------------------------+
| DB_LOCATION_URI                     |
+-------------------------------------+
| gs://[WAREHOUSE_BUCKET]/datasets   |
+-------------------------------------+

Vérifiez que la table est correctement référencée dans le métastore :

SELECT TBL_NAME, TBL_TYPE FROM TBLS;

Le résultat est semblable à ce qui suit :

+--------------+----------------+
| TBL_NAME     | TBL_TYPE       |
+--------------+----------------+
| transactions | EXTERNAL_TABLE |
+--------------+----------------+

Vérifiez que les colonnes de la table sont elles aussi correctement référencées :

SELECT COLUMN_NAME, TYPE_NAME
FROM COLUMNS_V2 c, TBLS t
WHERE c.CD_ID = t.SD_ID AND t.TBL_NAME = 'transactions';

Le résultat est semblable à ce qui suit :

+-------------------+-----------+
| COLUMN_NAME       | TYPE_NAME |
+-------------------+-----------+
| submissiondate    | date      |
| transactionamount | double    |
| transactiontype   | string    |
+-------------------+-----------+

Vérifiez que le format d'entrée et l'emplacement sont eux aussi correctement référencés :

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

Le résultat est semblable à ce qui suit :

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

Fermez la session MySQL :
```
exit
```

Créer un autre cluster Dataproc

Dans cette section, vous allez créer un autre cluster Dataproc afin de vérifier que les données Hive et le métastore Hive peuvent être partagés entre plusieurs clusters.

Créez un 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"

Vérifiez que le nouveau cluster peut accéder aux données :

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;"

Le résultat comprend les éléments suivants :

+------------------+--------+
| transactiontype  | count  |
+------------------+--------+
| authorization    | 696    |
| credit           | 1722   |
| debit            | 2599   |
+------------------+--------+

Félicitations, vous avez terminé les étapes de déploiement.

Effectuer un nettoyage

Les sections suivantes expliquent comment éviter les frais futurs pour votre projet Google Cloud et pour les ressources Apache Hive et Dataproc que vous avez utilisées dans ce déploiement.

Supprimer le projet Google Cloud

Pour éviter que les ressources utilisées dans ce déploiement ne soient facturées sur votre compte Google Cloud, vous pouvez supprimer le projet Google Cloud.

Attention : La suppression d'un projet entraîne les effets décrits ci-dessous :

Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches décrites dans ce document et que vous le supprimez, vous supprimerez également tout autre travail effectué dans le projet.
Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.

Si vous envisagez d'explorer plusieurs architectures, tutoriels et guides de démarrage rapide, réutiliser des projets peut vous aider à ne pas dépasser les limites de quotas des projets.

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

Supprimer des ressources individuelles

Exécutez les commandes suivantes dans Cloud Shell pour supprimer des ressources individuelles plutôt que le projet entier :

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

Étapes suivantes

Essayez BigQuery, l'entrepôt de données d'entreprise à faible coût, extrêmement évolutif et sans serveur de Google.
Consultez ce guide sur la migration des charges de travail Hadoop vers Google Cloud.
Découvrez cette action d'initialisation pour plus de détails sur l'utilisation de Hive HCatalog sur Dataproc.
Découvrez comment configurer la haute disponibilité de Cloud SQL afin d'accroître la fiabilité du service.
Pour découvrir d'autres architectures de référence, schémas et bonnes pratiques, consultez le Centre d'architecture cloud.