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.

Schéma d'une architecture monorégionale

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

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

    Accéder au sélecteur de projet

  2. 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

  1. Démarrez une instance Cloud Shell :

    Accéder à Cloud Shell

  2. 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.
  3. 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.

  1. 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.

  2. 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 :

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

  1. Ouvrez une session SSH avec l'instance maître de Dataproc (CLUSTER_NAME-m) :

    gcloud compute ssh CLUSTER_NAME-m
  2. 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"
  3. 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  |
    +------------------+--------------------+
  4. Fermez la session Beeline :

    !quit
  5. Fermez la connexion SSH :

    exit

Interroger Hive avec SparkSQL

  1. Ouvrez une session SSH avec l'instance maître de Dataproc :

    gcloud compute ssh CLUSTER_NAME-m
  2. Dans l'invite de commande de l'instance maître, ouvrez une nouvelle session d'interface système PySpark :

    pyspark
  3. 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  |
    +-----------------+--------------------+
  4. Fermez la session PySpark :

    exit()
  5. 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.

  1. 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.

  2. 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;
  3. 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   |
    +-------------------------------------+
  4. 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 |
    +--------------+----------------+
  5. 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    |
    +-------------------+-----------+
  6. 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 |
    +---------------------------------------------------------------+------------------------------------------------+
    
  7. 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.

  1. 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"
  2. 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.

  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.

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.