En este documento, se describe cómo implementar la arquitectura en Usa Apache Hive en Dataproc.
Este documento está dirigido a arquitectos de la nube y a ingenieros de datos que estén interesados en implementar Apache Hive en Dataproc y Hive Metastore en Cloud SQL.
Arquitectura
En esta guía de implementación, implementarás todos los servicios de procesamiento y almacenamiento en la misma región de Google Cloud para minimizar la latencia de red y los costos de transporte de red.
En el siguiente diagrama, se muestra el ciclo de vida de una consulta de Hive.
En el diagrama, el cliente de Hive envía una consulta, que se procesa, se recupera y se muestra. El procesamiento se realiza en el servidor de Hive. Los datos se solicitan y se recuperan de un almacén de Hive almacenado en un bucket regional en Cloud Storage.
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 esta implementación, 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.
Es posible que los usuarios nuevos de Google Cloud califiquen para obtener una prueba gratuita.
Cuando completes esta implementación puedes borrar los recursos que hayas creado para evitar que se te sigan facturando. Para obtener más información, consulta Cómo realizar una limpieza.
Antes de comenzar
En la página del selector de proyectos de la consola de Google Cloud, selecciona o crea un proyecto de Google Cloud.
Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud. Obtén información sobre cómo verificar si la facturación está habilitada en un proyecto.
Inicializa el entorno
Inicia una instancia de Cloud Shell:
En Cloud Shell, configura la zona en la que crearás los clústeres de Dataproc como zona predeterminada de Compute Engine.
export PROJECT=$(gcloud info --format='value(config.project)') export REGION=REGION export ZONE=ZONE gcloud config set compute/zone ${ZONE}Reemplaza lo siguiente:
REGION: Es la región en la que deseas crear el clúster, comous-central1.ZONE: La zona en la que deseas crear el clúster, comous-central1-a.
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
Crea el bucket de almacenamiento (opcional)
Si no tienes un bucket de Cloud Storage para almacenar datos de Hive, crea un bucket de almacenamiento (puedes ejecutar los siguientes comandos en Cloud Shell) y reemplaza BUCKET_NAME por un nombre de bucket único:
export WAREHOUSE_BUCKET=BUCKET_NAME
gsutil mb -l ${REGION} gs://${WAREHOUSE_BUCKET}
Crea la 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.
Cómo crear un clúster de Dataproc
Crea el primer clúster de Dataproc y reemplaza CLUSTER_NAME por un nombre como 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"
Notas:
- Proporciona el permiso de acceso de
sql-adminpara permitir que las instancias de clústeres accedan a la API de Administrador de Cloud SQL. - Debes colocar la acción de inicialización en una secuencia de comandos que almacenas en un bucket de Cloud Storage y hacer referencia a ese bucket con la marca
--initialization-actions. Consulta Acciones de inicialización: consideraciones y lineamientos importantes para obtener más información. - Proporciona el URI al bucket 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. Esta propiedad debe contener al menos un directorio (por ejemplo,gs://my-bucket/my-directory). Hive no funcionará correctamente si esta propiedad se configura como un nombre de bucket sin un directorio (por ejemplo,gs://my-bucket). - Especifica
enable-cloud-sql-proxy-on-workers=falsepara asegurarte de que el proxy de Cloud SQL solo se ejecute en nodos principales, lo que es suficiente para que el servicio de almacén de metadatos de Hive funcione y evita la carga innecesaria en Cloud SQL. 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
hivey 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.
En esta implementación, se usa una instancia de Cloud SQL con una dirección IP pública. Si, en cambio, usas una instancia con solo una dirección IP privada, puedes forzar al proxy a usar la dirección IP privada mediante el parámetro
--metadata "use-cloud-sql-private-ip=true".
Crea una tabla de Hive
En esta sección, subirás un conjunto de datos de ejemplo al bucket de almacenamiento, crearás una tabla de Hive nueva y ejecutarás las consultas de HiveQL en ese conjunto de datos.
Copia el conjunto de datos de ejemplo en el bucket de almacenamiento:
gsutil cp gs://hive-solution/part-00000.parquet \ gs://${WAREHOUSE_BUCKET}/datasets/transactions/part-00000.parquetEste 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.
Crea una tabla de Hive externa para el conjunto de datos:
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';"
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:
- La API de trabajos de Hive de Dataproc
- Beeline, un cliente de línea de comandos popular basado en SQLLine.
- SparkSQL, una API de Apache Spark para consultar datos estructurados.
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 CLUSTER_NAME \
--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
Abre una sesión SSH con la instancia principal de Dataproc (
CLUSTER_NAME-m):gcloud compute ssh CLUSTER_NAME-m
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://CLUSTER_NAME-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"
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 | +------------------+--------------------+
Cierre la sesión de Beeline:
!quit
Cierra la conexión de SSH:
exit
Realiza consultas en Hive con SparkSQL
Abre una sesión SSH con la instancia principal de Dataproc:
gcloud compute ssh CLUSTER_NAME-m
En el mensaje del comando de la instancia principal, abre una sesión de shell nueva de PySpark:
pyspark
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 | +-----------------+--------------------+
Cierra la sesión de PySpark:
exit()
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.
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 teclaRETURN. Con el fin de que esta implementación sea más simple, no estableciste una contraseña para el usuarioroot. 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.En el símbolo del sistema de MySQL, establece
hive_metastorecomo la base de datos predeterminada para el resto de la sesión:USE hive_metastore;
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://[WAREHOUSE_BUCKET]/datasets | +-------------------------------------+
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 | +--------------+----------------+
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 | +-------------------+-----------+
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://[WAREHOUSE_BUCKET]/datasets/transactions | +---------------------------------------------------------------+------------------------------------------------+
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.
Crea un clúster de Dataproc nuevo:
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"Verifica que el clúster nuevo pueda acceder a los datos:
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;"Se muestra el siguiente resultado:
+------------------+--------+ | transactiontype | count | +------------------+--------+ | authorization | 696 | | credit | 1722 | | debit | 2599 | +------------------+--------+
Felicitaciones. Completaste los pasos de la implementación.
Limpia
En las siguientes secciones, se explica cómo puedes evitar cargos futuros para el proyecto de Google Cloud y los recursos de Apache Hive y Dataproc que usaste en esta implementación.
Borra el proyecto de Google Cloud
Puedes borrar el proyecto de Google Cloud para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en esta implementación.
- En la consola de Google Cloud, ve a la página Administrar recursos.
- En la lista de proyectos, elige el proyecto que quieres borrar y haz clic en Borrar.
- En el diálogo, escribe el ID del proyecto y, luego, 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 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
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 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.
- Para obtener más información sobre las arquitecturas de referencia, los diagramas y las prácticas recomendadas, explora Cloud Architecture Center.