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 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 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 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 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 en 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 para este instructivo.

Diagrama de una arquitectura de una sola región
Figure 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 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 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 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 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 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 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 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 una arquitectura multiregional de Hive
Figure 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 \
    --zone ${ZONE}

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.4 \
    --region ${REGION} \
    --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. 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 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 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 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 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 \
        --region ${REGION} \
        --execute "
          CREATE EXTERNAL TABLE transactions
          (SubmissionDate DATE, TransactionAmount DOUBLE, TransactionType STRING)
          STORED AS PARQUET
          LOCATION 'gs://${PROJECT}-warehouse/datasets/transactions';"

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, ejecuta una consulta de ejemplo.

Consulta Hive con la API de trabajos de 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 \
    --region ${REGION} \
    --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            |
+-----------------+--------------------+------------------+

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

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

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 nueva de MySQL 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.4 \
        --region ${REGION} \
        --initialization-actions gs://goog-dataproc-initialization-actions-${REGION}/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 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 \
        --region ${REGION} \
        --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 el instructivo:

Para evitar que se generen costos 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 eliminar la facturación es borrar el proyecto que creaste para el instructivo.
  • Como alternativa, 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 eliminar el proyecto completo:

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

¿Qué sigue?

  • 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.
  • Aprende a configurar Cloud SQL para alta disponibilidad a fin de aumentar la confiabilidad del servicio.
  • Prueba otras características de Google Cloud. Consulta nuestros instructivos.