Usa Apache Hive en Cloud Dataproc

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

  • Flexibilidad y agilidad: Puedes adaptar las opciones de configuración 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 activar un clúster efímero cuando necesites ejecutar un trabajo de Hive y borrarlo cuando ese trabajo se complete. Los recursos que necesitan los trabajos solo estarán activos durante su uso, de modo que solo pagarás por lo que uses. 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 compilado en Apache Hadoop. Hive ofrece un lenguaje de consulta similar a SQL llamado HiveQL, que se usa 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 se suele usar como backend para el almacén de metadatos de Hive, Cloud SQL facilita la configuración, el mantenimiento y la administración de las bases de datos relacionales en Google Cloud.

Dataproc es un servicio de Google Cloud completamente administrado, rápido y fácil de usar, que sirve para ejecutar cargas de trabajo de Apache Spark y Apache Hadoop de una manera simple y rentable. Aunque las instancias de Dataproc pueden permanecer sin estado, recomendamos que los datos de Hive se almacenen en Cloud Storage y el almacén de datos 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 Dataproc
  • Instalar el proxy de Cloud SQL en las instancias de clústeres de Dataproc
  • Subir los datos de Hive a Cloud Storage
  • Ejecutar consultas de Hive en varios clústeres de Dataproc

Costos

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

  • Dataproc
  • Cloud Storage
  • Cloud SQL

Puedes usar la calculadora de precios para generar un costo estimado según el uso previsto.

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

Antes de comenzar

Crear un nuevo proyecto

  1. En Cloud Console, ve a la página Selector de proyectos.

    Ir a la página de selección de proyectos

  2. Selecciona o crea un proyecto de Cloud.

Habilita la facturación

Inicializa el entorno

  1. Inicia una instancia de Cloud Shell:

    Ir a Cloud Shell

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

    export REGION=us-central1
        export ZONE=us-central1-a
        gcloud config set compute/zone $ZONE
  3. Habilita las API de administrador de Dataproc y Cloud SQL mediante la ejecución del siguiente comando en Cloud Shell:

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

Arquitectura de referencia

Para simplificar, en este instructivo, implementarás todos los servicios de procesamiento y almacenamiento en la misma región de Google Cloud, a fin de minimizar la latencia de red y los costos de transporte de red. En la figura 1, se muestra la arquitectura de este instructivo.

Diagrama de una arquitectura de una sola región
Figura 1. Ejemplo de una 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 de Dataproc efímero.
  2. El servidor procesa los metadatos de la consulta y las solicitudes desde el servicio de almacén de metadatos.
  3. El servicio de almacén de metadatos recupera los metadatos de Hive desde Cloud SQL a través del proxy de Cloud SQL.
  4. El servidor carga los datos desde el almacén de datos 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 regiones geográficas diferentes. En ese caso, debes crear clústeres de Dataproc independientes que usen con el fin de alojar el servicio de almacén de metadatos y que residan en la misma región que la instancia de Cloud SQL. A menudo, el servicio de almacén de metadatos envía volúmenes altos de solicitudes a la base de datos MySQL. Por esto, es importante mantener este servicio geográficamente cerca de la base de datos MySQL para minimizar el impacto en el rendimiento. De la misma manera, el servidor de Hive suele enviar 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 regiones diferentes a pesar del aumento de latencia.

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

El proxy de Cloud SQL debe instalarse solo en los clústeres del servicio de 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 del servicio de almacén de datos mediante la configuración de la propiedad hive.metastore.uris en la lista de URI separados por comas. Por ejemplo:

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

También puedes usar un depósito multirregional en caso de que sea necesario acceder a los datos de Hive desde servidores de Hive situados en diversas ubicaciones. Optar por depósitos regionales o multirregionales depende del caso práctico. Debes lograr un equilibrio entre los costos de latencia, disponibilidad y ancho de banda. Para obtener más detalles, consulta la documentación sobre consideraciones de ubicación.

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

Diagrama de una 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 usa la arquitectura de una sola región.

Crea 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

Crea la instancia de Cloud SQL

En esta sección, crearás una instancia de Cloud SQL nueva, que más tarde 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 \
        --zone $ZONE \
        --region $REGION

Este comando puede llevar unos minutos en completarse.

Crea un clúster de Dataproc

Crea el primer clúster de Dataproc:

gcloud dataproc clusters create hive-cluster \
        --scopes sql-admin \
        --image-version 1.3 \
        --initialization-actions gs://goog-dataproc-initialization-actions-${REGION}/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 permiso de acceso de sql-admin para permitir que las instancias de clústeres accedan 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 en que se escribió este instructivo.
  • Proporciona el URI al depósito de almacenamiento de Hive en la propiedad hive:hive.metastore.warehouse.dir. De este modo, se configuran 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 Dataproc ejecuta de forma automática en todas las instancias de clústeres. La acción realiza lo siguiente:

    • Instala el proxy de Cloud SQL.
    • Establece una conexión segura con la instancia de Cloud SQL especificada en el parámetro de metadatos hive-metastore-instance.
    • Crea el usuario de 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 las cargas de trabajo de producción, puedes crear un clúster con tres instancias principales mediante el modo de alta disponibilidad de Dataproc.

Crea una tabla de Hive

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

  1. Copia el conjunto de datos de muestra 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 bancarias ficticias, 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';" \
              --region $REGION

Ejecuta consultas de Hive

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

En cada sección, ejecutarás una consulta de muestra.

Consulta Hive con la API de trabajos de Dataproc

Ejecuta la siguiente consulta simple de HiveQL para verificar que el archivo Parquet esté vinculado de manera correcta a la tabla de Hive:

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

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

Realiza consultas en Hive con Beeline

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

    gcloud compute ssh hive-cluster-m
  2. En el símbolo del sistema 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 host en lugar 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 símbolo del sistema 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

Realiza consultas en Hive con SparkSQL

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

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

    pyspark
  3. Cuando se muestra el símbolo del sistema de la 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

Inspecciona el almacén de metadatos de Hive

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

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

    gcloud sql connect hive-metastore --user=root

    Cuando se te solicite la contraseña de usuario root, no escribas nada y solo presiona la tecla RETURN. A fin de simplificar, en este instructivo, no estableciste una contraseña para el usuario root. Para obtener información sobre cómo configurar una contraseña a fin de proteger aún 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. Si deseas obtener más información, consulta el repositorio de código de la acción.

  2. En el símbolo del sistema de MySQL, establece hive_metastore como 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

Crea otro clúster de Dataproc

En esta sección, crearás otro clúster de Dataproc para verificar que los datos y el almacén de metadatos de Hive puedan compartirse entre varios clústeres.

  1. Crea un clúster de Dataproc nuevo:

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

    No proporciones una referencia al depósito de almacenamiento de Hive como lo hiciste antes, 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;" \
              --region $REGION

    Se muestra el siguiente resultado:

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

Felicitaciones. Completaste el instructivo.

Realiza una limpieza

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 generen cargos en tu cuenta de Google Cloud por los recursos que se usaron en este instructivo, sigue estos pasos:

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

Borra el proyecto

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

    Ir a la página Administrar recursos

  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 haz clic en Cerrar para borrar el proyecto.

Borra recursos individuales

Ejecuta los siguientes comandos en Cloud Shell para borrar los recursos individuales, en vez de borrar 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
    

Próximos pasos

  • 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 Google Cloud.
  • Consulta esta acción de inicialización para obtener más detalles sobre cómo usar HCatalog de Hive en Dataproc.
  • Obtén información sobre cómo configurar Cloud SQL para la alta disponibilidad a fin de aumentar la confiabilidad del servicio.
  • Prueba otras funciones de Google Cloud. Consulta nuestros instructivos.