Usar Apache Hive en Cloud Dataproc

En este instructivo se muestra cómo usar Apache Hive en Cloud Dataproc de manera efectiva y flexible mediante el almacenamiento de datos de Hive en Cloud Storage y el alojamiento del almacén de metadatos Hive en una base de datos de MySQL en Cloud SQL. Esta división entre los recursos de procesamiento y almacenamiento ofrece algunas ventajas:

  • Flexibilidad y agilidad: puedes adaptar las configuraciones del clúster para cargas de trabajo de Hive específicas y aumentar o disminuir el escalamiento de cada clúster de forma independiente, según sea necesario.
  • Ahorro de costos: puedes iniciar un clúster efímero cuando necesites ejecutar un trabajo de Hive y borrarlo cuando se finalice. Los recursos que necesitan tus trabajos solo estarán activos durante su uso; así que solo pagarás por lo que usas. También puedes usar VM interrumpibles para procesar datos no críticos o crear clústeres muy grandes a un costo total más bajo.

Hive es un popular sistema de almacén de datos de código abierto desarrollado en Apache Hadoop. Hive ofrece un lenguaje de consulta similar a SQL llamado HiveQL, que se utiliza para analizar grandes conjuntos de datos estructurados. El almacén de metadatos de Hive conserva los metadatos de las tablas de Hive, como esquemas y ubicaciones. Mientras que MySQL generalmente se utiliza como un backend para el almacén de metadatos de Hive, Cloud SQL simplifica la configuración, el mantenimiento, la gestión y la administración de las bases de datos relacionales en Google Cloud Platform (GCP).

Cloud Dataproc es un servicio rápido, sencillo y completamente administrado en GCP para ejecutar las cargas de trabajo de Apache Spark y Apache Hadoop de manera simple y rentable. Aunque las instancias de Cloud Dataproc pueden permanecer sin estado, recomendamos la persistencia de los datos de Hive en Cloud Storage y el almacén de metadatos de Hive en MySQL en Cloud SQL.

Objetivos

  • Crear una instancia de MySQL en Cloud SQL para el almacén de datos de Hive
  • Implementar servidores de Hive en Cloud Dataproc
  • Instalar el proxy de Cloud SQL en las instancias de clústeres de Cloud Dataproc
  • Subir los datos de Hive a Cloud Storage
  • Ejecutar las consultas de Hive en varios clústeres de Cloud Dataproc

Costos

En este instructivo se usan los siguientes componentes facturables de Google Cloud Platform:

  • Cloud Dataproc
  • Cloud Storage
  • Cloud SQL

Puedes usar la calculadora de precios para realizar una estimación de costos según el uso previsto.

Los usuarios nuevos de GCP pueden optar por a una prueba gratuita.

Antes de comenzar

Crear un nuevo proyecto

  1. En GCP Console, ve a la página Administrar recursos.

    Ir a la página Administrar recursos

  2. Selecciona un proyecto o haz clic en Crear proyecto para crear un proyecto de GCP nuevo.

  3. En el cuadro de diálogo, ponle nombre a tu proyecto. Toma nota de tu ID del proyecto generado.

  4. Haz clic en Crear para crear un proyecto nuevo.

Habilitar facturación

Inicializar el entorno

  1. Inicia una instancia de Cloud Shell:

    IR A Cloud Shell

  2. En Cloud Shell, configura la zona predeterminada de Compute Engine en la zona donde crearás los clústeres de Cloud Dataproc. Para los fines de este instructivo, se utiliza la zona us-central1-a en la región us-central1.

    export REGION=us-central1
    export ZONE=us-central1-a
    gcloud config set compute/zone $ZONE
  3. Ejecuta el siguiente comando en Cloud Shell para habilitar las API de Administrador de Cloud Dataproc y Cloud SQL:

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

Arquitectura de referencia

Con el fin de simplificar la tarea, en este instructivo implementarás todos los servicios de procesamiento y almacenamiento en la misma región de GCP para minimizar la latencia de red y los costos de transporte de la red. En la figura 1 se muestra la arquitectura para este instructivo.

Diagrama de la arquitectura de una sola región.
Figura 1. Ejemplo de la arquitectura de Hive de una sola región

Con esta arquitectura, el ciclo de vida de una consulta de Hive sigue estos pasos:

  1. El cliente de Hive envía una consulta a un servidor de Hive que se ejecuta en un clúster efímero de Cloud Dataproc.
  2. El servidor procesa los metadatos de la consulta y las solicitudes desde el servidor de almacén de metadatos.
  3. El servido de almacén de metadatos recupera estos datos desde Cloud SQL a través del proxy de Cloud SQL.
  4. El servidor carga los datos desde el almacén de Hive ubicado en un depósito regional en Cloud Storage.
  5. El servidor muestra el resultado al cliente.

Consideraciones para arquitecturas multirregionales

En este instructivo, nos enfocaremos en la arquitectura de una sola región. Sin embargo, puedes considerar una arquitectura multirregional si necesitas ejecutar servidores de Hive en diferentes regiones geográficas. En ese caso, debes crear clústeres de Cloud Dataproc separados para alojar el servicio de almacén de metadatos y que residan en la misma región que la instancia de Cloud SQL. A veces, el servicio de almacén de metadatos puede enviar volúmenes altos de solicitudes a la base de datos de MySQL. Por esto es importante mantener este servicio geográficamente cerca de la base de datos de MySQL para minimizar el impacto en el rendimiento. De la misma manera, el servidor de Hive envía muchas menos solicitudes al servicio de almacén de metadatos. Por lo tanto, puede ser más aceptable que el servidor de Hive y el servicio de almacén de metadatos residan en diferentes regiones a pesar del aumento de latencia.

El servicio de almacén de metadatos solo puede ejecutarse en los nodos principales de Cloud Dataproc, pero no en los nodos trabajadores. Cloud Dataproc aplica 2 nodos trabajadores como mínimo en los clústeres estándar y en los de alta disponibilidad. Para evitar desperdiciar recursos en nodos trabajadores que no se utilizan, puedes crear un clúster con un solo nodo para el servicio de almacén de datos. Para lograr una alta disponibilidad, puedes crear varios clústeres con un solo nodo.

El proxy de Cloud SQL debe instalarse solo en los clústeres de servicio del almacén de metadatos, ya que solo estos clústeres deben conectarse directamente a la instancia de Cloud SQL. Luego, los servidores de Hive apuntan a los clústeres de servicio del almacén de metadatos configurando la propiedad hive.metastore.uris en la lista de URI separada por comas. Por ejemplo:

thrift://metastore1:9083,thrift://metastore2:9083

También puedes usar un depósito multirregional si los servidores de Hive en varias ubicaciones necesitan acceder a los datos de Hive. La elección entre depósitos en una región o en varias depende del caso práctico. Debes lograr un equilibrio de costos entre latencia, disponibilidad y ancho de banda. Consulta la documentación sobre consideraciones de ubicación para obtener más detalles.

En la figura 2 se muestra un ejemplo de la arquitectura multirregional.

Diagrama de la arquitectura multiregional de Hive.
Figura 2. Ejemplo de una arquitectura multirregional de Hive

Como puedes observar, la situación de arquitectura multirregional es un poco más compleja. Para ser concisos, en este instructivo se utiliza la arquitectura de una sola región.

Crear un depósito de almacenamiento

El primer paso es crear un depósito de almacenamiento que alojará los datos de Hive y se compartirá a todos los servidores de Hive.

Para crearlo, ejecuta los siguientes comandos en Cloud Shell:

export PROJECT=$(gcloud info --format='value(config.project)')
gsutil mb -l $REGION gs://$PROJECT-warehouse

Crear una instancia de Cloud SQL

En esta sección, crearás una instancia nueva de Cloud SQL, que luego se usará para alojar el almacén de metadatos de Hive.

En Cloud Shell, crea una instancia nueva de Cloud SQL:

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

Este comando puede tardar unos minutos en completarse.

Crear un clúster de Cloud Dataproc

Crea el primer clúster de Cloud Dataproc:

gcloud dataproc clusters create hive-cluster \
    --scopes sql-admin \
    --image-version 1.3 \
    --initialization-actions gs://dataproc-initialization-actions/cloud-sql-proxy/cloud-sql-proxy.sh \
    --properties hive:hive.metastore.warehouse.dir=gs://$PROJECT-warehouse/datasets \
    --metadata "hive-metastore-instance=$PROJECT:$REGION:hive-metastore"

Notas:

  • Proporciona el alcance de acceso sql-admin para que las instancias de clústeres tengan acceso a la API de Administrador de Cloud SQL.
  • Especifica la versión 1.3 de la imagen del clúster, que es la última versión disponible en el momento que se escribió este instructivo.
  • Proporciona el URI para el depósito de almacenamiento de Hive en la propiedad hive:hive.metastore.warehouse.dir. Esta acción configura los servidores de Hive para que lean y escriban en la ubicación correcta.
  • Proporciona la acción de inicialización del proxy de Cloud SQL que Cloud Dataproc ejecuta automáticamente en las instancias de clústeres. La acción realiza las siguientes operaciones:

    • Instala el proxy de Cloud SQL.
    • Establece una conexión segura para la instancia de Cloud SQL especificada en el parámetro de metadatos hive-metastore-instance.
    • Crea el usuario hive y la base de datos del almacén de metadatos de Hive.

    Puedes ver el código completo de la acción de inicialización del proxy de Cloud SQL en GitHub.

  • Para que este instructivo sea más simple, se usa solo una instancia principal. Para aumentar la resiliencia en cargas de trabajo de producción, considera crear un clúster con tres instancias principales mediante el modo de alta disponibilidad de Cloud Dataproc.

Crear una tabla de Hive

En esta sección, subirás un conjunto de datos de ejemplo al depósito de almacenamiento, crearás una tabla de Hive nueva y ejecutarás las consultas de HiveQL en ese conjunto de datos.

  1. Copia el conjunto de datos de ejemplo en el depósito de almacenamiento:

    gsutil cp gs://hive-solution/part-00000.parquet \
    gs://$PROJECT-warehouse/datasets/transactions/part-00000.parquet

    Este conjunto de datos se comprime en formato Parquet y contiene miles de registros de transacciones en un banco ficticio con tres columnas: fecha, importe y tipo de transacción.

  2. Crea una tabla de Hive externa para el conjunto de datos:

    gcloud dataproc jobs submit hive \
        --cluster hive-cluster \
        --execute "
          CREATE EXTERNAL TABLE transactions
          (SubmissionDate DATE, TransactionAmount DOUBLE, TransactionType STRING)
          STORED AS PARQUET
          LOCATION 'gs://$PROJECT-warehouse/datasets/transactions';"

Ejecutar consultas de Hive

Puedes utilizar diferentes herramientas en Cloud Dataproc para ejecutar consultas de Hive. En esta sección, aprenderás a realizar consultas con las siguientes herramientas:

En cada sección, ejecuta una consulta de ejemplo.

Realizar consultas de Hive con la API de empleos de Cloud Dataproc

Ejecuta la siguiente consulta simple de HiveQL para verificar que el archivo parquet esté correctamente vinculado a la tabla de Hive:

gcloud dataproc jobs submit hive \
    --cluster hive-cluster \
    --execute "
      SELECT *
      FROM transactions
      LIMIT 10;"

Se muestra el siguiente resultado:

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

Realizar consultas de Hive con Beeline

  1. Abre una sesión de SSH con la instancia principal de Cloud Dataproc:

    gcloud compute ssh hive-cluster-m
  2. En el mensaje del comando de la instancia principal, abre una sesión de Beeline:

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

    Notas:

    • También puedes hacer referencia al nombre de la instancia principal como el host, en vez de localhost:

      beeline -u "jdbc:hive2://hive-cluster-m:10000"
    • Si usaras el modo de alta disponibilidad con 3 instancias principales, deberías usar el siguiente 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. Cuando se muestra el mensaje de Beeline, ejecuta la siguiente consulta de HiveQL:

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

    Se muestra el siguiente resultado:

    +------------------+--------------------+
    | transactiontype  |   averageamount    |
    +------------------+--------------------+
    | authorization    | 4890.092525252529  |
    | credit           | 4863.769269565219  |
    | debit            | 4982.781458176331  |
    +------------------+--------------------+
  4. Cierre la sesión de Beeline:

    !quit
  5. Cierra la conexión de SSH:

    exit

Realizar consultas de Hive con SparkSQL

  1. Abre una sesión de SSH con la instancia principal de Cloud Dataproc:

    gcloud compute ssh hive-cluster-m
  2. En el mensaje del comando de la instancia principal, abre una sesión de shell nueva de PySpark:

    pyspark
  3. Cuando se muestra el mensaje de shell de PySpark, escribe el siguiente código de 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()

    Se muestra el siguiente resultado:

    +-----------------+--------------------+
    | 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. Cierra la sesión de PySpark:

    exit()
  5. Cierra la conexión de SSH:

    exit

Inspeccionar el almacén de metadatos de Hive

Ahora, verifica que el almacén de metadatos de Hive en Cloud SQL contenga la información sobre la tabla transactions.

  1. En Cloud Shell, inicia una sesión nueva de MySQL en la instancia de Cloud SQL:

    gcloud sql connect hive-metastore --user=root

    Cuando se te indique ingresar la contraseña de usuario root, no ingreses nada y solo presiona la tecla RETURN. Con el fin de que el instructivo sea más simple, no configuraste una contraseña para el usuario root. Para obtener información sobre cómo configurar una contraseña a fin de proteger más la base de datos del almacén de metadatos, consulta la documentación de Cloud SQL. La acción de inicialización del proxy de Cloud SQL también proporciona un mecanismo para proteger contraseñas mediante la encriptación. A fin de obtener más información, consulta el repositorio del código de la acción.

  2. En el mensaje de comando de MySQL, indica que hive_metastore es la base de datos predeterminada para el resto de la sesión:

    USE hive_metastore;
  3. Verifica que la ubicación del depósito de almacenamiento esté registrada en el almacén de metadatos:

    SELECT DB_LOCATION_URI FROM DBS;

    El resultado obtenido se verá así:

    +-------------------------------------+
    | DB_LOCATION_URI                     |
    +-------------------------------------+
    | gs://[PROJECT]-warehouse/datasets   |
    +-------------------------------------+
  4. Verifica que la tabla esté correctamente mencionada en el almacén de metadatos:

    SELECT TBL_NAME, TBL_TYPE FROM TBLS;

    El resultado obtenido se verá así:

    +--------------+----------------+
    | TBL_NAME     | TBL_TYPE       |
    +--------------+----------------+
    | transactions | EXTERNAL_TABLE |
    +--------------+----------------+
  5. Verifica que las columnas de la tabla estén correctamente mencionadas:

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

    El resultado obtenido se verá así:

    +-------------------+-----------+
    | COLUMN_NAME       | TYPE_NAME |
    +-------------------+-----------+
    | submissiondate    | date      |
    | transactionamount | double    |
    | transactiontype   | string    |
    +-------------------+-----------+
  6. Verifica que el formato de entrada y la ubicación estén correctamente mencionados:

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

    El resultado obtenido se verá así:

    +---------------------------------------------------------------+------------------------------------------------+
    | INPUT_FORMAT                                                  | LOCATION                                       |
    +---------------------------------------------------------------+------------------------------------------------+
    | org.apache.hadoop.hive.ql.io.parquet.MapredParquetInputFormat | gs://[PROJECT]-warehouse/datasets/transactions |
    +---------------------------------------------------------------+------------------------------------------------+
    
  7. Cierra la sesión de MySQL:

    exit

Crear otro clúster de Cloud Dataproc

En esta sección, crearás otro clúster de Cloud Dataproc para verificar que los datos y los metadatos de Hive se puedan compartir a varios clústeres.

  1. Crea un clúster nuevo de Cloud Dataproc:

    gcloud dataproc clusters create other-hive-cluster \
        --scopes cloud-platform \
        --image-version 1.3 \
        --initialization-actions gs://dataproc-initialization-actions/cloud-sql-proxy/cloud-sql-proxy.sh \
        --metadata  "hive-metastore-instance=$PROJECT:$REGION:hive-metastore"

    No proporciones una referencia al depósito de almacenamiento de Hive como lo hiciste anteriormente, cuando creaste el primer clúster con la propiedad hive:hive.metastore.warehouse.dir. La ubicación de depósito ya está registrada en el almacén de metadatos de Hive, como lo verificaste en la sección anterior.

  2. Verifica que el clúster nuevo pueda acceder a los datos:

    gcloud dataproc jobs submit hive \
        --cluster other-hive-cluster \
        --execute "
          SELECT TransactionType, COUNT(TransactionType) as Count
          FROM transactions
          WHERE SubmissionDate = '2017-08-22'
          GROUP BY TransactionType;"

    Se muestra el siguiente resultado:

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

Felicitaciones. Completaste el instructivo.

Limpiar

Sigue estos pasos para evitar que se apliquen cargos a tu cuenta de Google Cloud Platform por los recursos que usaste en este instructivo:

Para evitar que se apliquen cargos a tu cuenta de GCP por los recursos utilizados en este instructivo, realiza los siguientes pasos:

  • Limpia todos los recursos que creaste para evitar que se apliquen cargos en el futuro. La manera más fácil de eliminar la facturación es borrar el proyecto que creaste para el instructivo.
  • Como alternativa, puedes borrar recursos individuales.

Borrar el proyecto

  1. En la GCP Console, dirígete a la página Proyectos.

    Ir a la página Proyectos

  2. En la lista de proyectos, selecciona el proyecto que deseas borrar y haz clic en Borrar.
  3. En el cuadro de diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrar el proyecto.

Borrar recursos individuales

Ejecuta los siguientes comandos en Cloud Shell para borrar los recursos individuales, en vez de eliminar el proyecto completo:

gcloud dataproc clusters delete hive-cluster --quiet
gcloud dataproc clusters delete other-hive-cluster --quiet
gcloud sql instances delete hive-metastore --quiet
gsutil rm -r gs://$PROJECT-warehouse

Pasos siguientes

  • Prueba BigQuery, el almacén de datos empresarial sin servidores, altamente escalable y económico de Google.
  • Consulta esta guía sobre cómo migrar cargas de trabajo de Hadoop a GCP.
  • Consulta esta acción de inicialización para obtener más detalles sobre cómo usar HCatalog de Hive en Cloud Dataproc.
  • Aprende a configurar Cloud SQL para alta disponibilidad a fin de aumentar la confiabilidad del servicio.
  • Prueba otras características de Google Cloud Platform por ti mismo. Revisa nuestros instructivos.
¿Te sirvió esta página? Envíanos tu opinión:

Enviar comentarios sobre…