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.
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 :
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 queus-central1.ZONE: zone dans laquelle vous souhaitez créer le cluster, telle queus-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-adminafin 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=falsepour 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
hiveet 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.parquetL'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 toucheRETURN. Par souci de simplicité, vous n'avez défini aucun mot de passe pour l'utilisateurrootdans 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_metastorela 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.
- Dans la console Google Cloud, accédez à la page Gérer les ressources.
- Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
- Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.
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.