Los datos de serie temporal son un activo muy valioso que puedes usar para varias aplicaciones, que incluyen tendencias, supervisión y aprendizaje automático. Puedes generar datos de series temporales a partir de la infraestructura del servidor, el código de la aplicación y otras fuentes. OpenTSDB puede recopilar y retener grandes cantidades de datos de series temporales con un alto nivel de detalle.
En esta guía, se muestra a los ingenieros y a los arquitectos de software cómo crear una capa de recopilación escalable para datos de series temporales mediante el uso de GKE. También se muestra cómo trabajar con los datos recopilados con Bigtable. En esta guía, suponemos que estás familiarizado con Kubernetes y Bigtable.
En el siguiente diagrama, se ilustra la arquitectura de alto nivel de esta guía:
En el diagrama anterior, se muestran varias fuentes de datos de series temporales, como los eventos de IoT y las métricas del sistema, que se almacenan en Bigtable con OpenTSDB implementado en GKE.
Objetivos
- Compilar las imágenes de contenedor que se usan en esta guía mediante Cloud Build
- Administra estas imágenes de contenedor mediante Artifact Registry.
- Crear una instancia de Bigtable.
- Crear un clúster de GKE.
- Implementar OpenTSDB en tu clúster de GKE.
- Enviar métricas de serie temporal a OpenTSDB.
- Visualizar métricas con OpenTSDB y Grafana.
Costos
En este documento, usarás los siguientes componentes facturables de Google Cloud:
Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios.
Cuando finalices las tareas que se describen en este documento, puedes borrar los recursos que creaste para evitar que continúe la facturación. 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.
-
Habilita las API de Bigtable, Bigtable Admin, GKE, Compute Engine, Cloud Build, and Artifact Registry.
En la consola de Google Cloud, ve a la página Bienvenida.
Toma nota del ID del proyecto, ya que se usa en un paso posterior.
-
En la consola de Google Cloud, activa Cloud Shell.
Crear una instancia de Bigtable
En esta guía, se usa Bigtable para almacenar los datos de series temporales que recopilas, por lo que debes crear una instancia de Bigtable.
Bigtable es un almacenamiento de claves/columnas amplias que funciona bien para datos de series temporales. Bigtable es compatible con la API de HBase, por lo que puedes usar el software diseñado para funcionar con Apache HBase, como OpenTSDB. Para obtener más información sobre el esquema de HBase que usa OpenTSDB, consulta HBase Schema.
Un componente clave de OpenTSDB es el cliente AsyncHBase, que permite te permite realizar una escritura masiva en HBase de una manera totalmente asíncrona, sin bloqueo y segura para los subprocesos. Cuando usas OpenTSDB con Bigtable, AsyncHBase se implementa como el cliente AsyncBigtable.
En esta guía, se usa una instancia de Bigtable con un clúster de nodo único. Cuando migras a un entorno de producción, considera usar instancias de Bigtable con clústeres más grandes. Para obtener más información sobre cómo elegir el tamaño del clúster, consulta Información sobre el rendimiento de Bigtable.
En Cloud Shell, configura las variables de entorno de tu zona de Google Cloud en la que crearás los clústeres de Bigtable y GKE, y el identificador de instancias para el clúster de Bigtable:
export BIGTABLE_INSTANCE_ID=BIGTABLE_INSTANCE_ID export ZONE=ZONE
Reemplaza lo siguiente:
BIGTABLE_INSTANCE_ID
: El identificador de tu instancia de Bigtable.ZONE
: Es la zona en la que se crearán el clúster de Bigtable y el clúster de GKE.
El comando debe ser similar al siguiente ejemplo:
export BIGTABLE_INSTANCE_ID=bt-opentsdb export ZONE=us-central1-f
Crea la instancia de Bigtable:
gcloud bigtable instances create ${BIGTABLE_INSTANCE_ID} \ --cluster-config=id=${BIGTABLE_INSTANCE_ID}-${ZONE},zone=${ZONE},nodes=1 \ --display-name=OpenTSDB
Crea las imágenes que se usan para implementar y probar OpenTSDB
Para implementar y demostrar OpenTSDB con un backend de almacenamiento de Bigtable, en esta guía se usa una serie de imágenes de contenedor de Docker que se implementan en GKE. Debes compilar varias de estas imágenes mediante el código de un repositorio de GitHub adjunto con Cloud Build. Cuando se implementa una infraestructura en GKE, se usa un repositorio de contenedores. En esta guía, usarás Artifact Registry para administrar estas imágenes de contenedor.
En Cloud Shell, configura las variables de entorno de tu zona de Google Cloud en la que crearás el repositorio de Artifact Registry:
export PROJECT_ID=PROJECT_ID export REGION=REGION export AR_REPO=AR_REPO
Reemplaza lo siguiente:
PROJECT_ID
: el ID de tu proyectoREGION
: La región en la que se creará el repositorio de Artifact RegistryAR_REPO
: Es el nombre de tu repositorio de Artifact Registry.
El comando debe ser similar al siguiente ejemplo:
export PROJECT_ID=bt-opentsdb-project-id export REGION=us-central1 export AR_REPO=opentsdb-bt-repo
Crea un repositorio de Artifact Registry:
gcloud artifacts repositories create ${AR_REPO} \ --repository-format=docker \ --location=${REGION} \ --description="OpenTSDB on bigtable container images"
Crea y administra las imágenes usadas para implementar y demostrar OpenTSDB
En esta guía, se usan dos imágenes de contenedor de Docker. La primera imagen se usa con dos propósitos: realizar la configuración única de la base de datos de Bigtable para OpenTSDB y, luego, implementar los contenedores de servicio de lectura y escritura para la implementación de OpenTSDB. La segunda imagen se usa para generar datos de métricas de muestra a fin de demostrar la implementación de OpenTSDB.
Cuando envías el trabajo de compilación de la imagen del contenedor a Cloud Build, debes etiquetar las imágenes para que se almacenen en Artifact Registry después de compilarlas.
En Cloud Shell, clona el repositorio de GitHub que contiene el código adjunto:
git clone https://github.com/GoogleCloudPlatform/opentsdb-bigtable.git
Ve al directorio del código de muestra:
cd opentsdb-bigtable
Configura las variables de entorno para la imagen de servidor de OpenTSDB que usa Bigtable como backend de almacenamiento:
export SERVER_IMAGE_NAME=opentsdb-server-bigtable export SERVER_IMAGE_TAG=2.4.1
Compila la imagen mediante Cloud Build:
gcloud builds submit \ --tag ${REGION}-docker.pkg.dev/${PROJECT_ID}/${AR_REPO}/${SERVER_IMAGE_NAME}:${SERVER_IMAGE_TAG} \ build
Debido a que etiquetaste la imagen de forma adecuada, cuando se complete la compilación, tu repositorio de Artifact Registry administrará la imagen.
Configura las variables de entorno para la imagen de generación de datos de series temporales de demostración:
export GEN_IMAGE_NAME=opentsdb-timeseries-generate export GEN_IMAGE_TAG=0.1
Compila la imagen mediante Cloud Build:
cd generate-ts ./build-cloud.sh cd ..
Cree un clúster de GKE
GKE proporciona un entorno Kubernetes administrado. Después de crear un clúster de GKE, puedes implementar en él los Pods de Kubernetes. En esta guía, se usan Pods de GKE y Kubernetes para ejecutar OpenTSDB.
OpenTSDB separa su almacenamiento de la capa de aplicación, lo cual le permite implementarse de forma simultánea en múltiples instancias. Si se ejecuta en paralelo, OpenTSDB puede controlar una gran cantidad de datos de series temporales.
En Cloud Shell, configura las variables de entorno para la zona de Google Cloud en la que crearás el clúster de Bigtable y el clúster de GKE, y el nombre, el tipo de nodo y la versión de tu clúster de GKE:
export GKE_CLUSTER_NAME=GKE_CLUSTER_NAME export GKE_VERSION=1.20 export GKE_NODE_TYPE=n1-standard-4
Reemplaza
GKE_CLUSTER_NAME
por el nombre de tu clúster de GKE.El comando debe ser similar al siguiente ejemplo:
export GKE_CLUSTER_NAME=gke-opentsdb export GKE_VERSION=1.20 export GKE_NODE_TYPE=n1-standard-4
Crea un clúster de GKE:
gcloud container clusters create ${GKE_CLUSTER_NAME} \ --zone=${ZONE} \ --cluster-version=${GKE_VERSION} \ --machine-type ${GKE_NODE_TYPE} \ --scopes "https://www.googleapis.com/auth/cloud-platform"
Esta operación puede tardar unos minutos. Agregar los alcances a tu clúster de GKE permite que el contenedor de OpenTSDB interactúe con Bigtable y Container Registry.
En el resto de esta guía, se usan los contenedores que acabas de compilar y que administra Artifact Registry. Las secuencias de comandos de Dockerfile y
entrypoint
que se usan para compilar el contenedor se encuentran en la carpetabuild
del repositorio de la guía.Obtén las credenciales para que puedas conectarte a tu clúster de GKE:
gcloud container clusters get-credentials ${GKE_CLUSTER_NAME} --zone ${ZONE}
Crea un ConfigMap con detalles de configuración
Kubernetes usa ConfigMap para separar los detalles de configuración de la imagen de contenedor a fin de que las aplicaciones sean más portátiles. La configuración de OpenTSDB se especifica en el archivo opentsdb.conf
. Se incluye un ConfigMap que contiene el archivo opentsdb.conf
con el código de muestra.
En este paso y en los que siguen, se usa la utilidad envsubst
de GNU a fin de reemplazar los marcadores de posición de variables de entorno en los archivos de plantilla YAML por los valores respectivos de tu implementación.
Crea un ConfigMap a partir del archivo
opentsdb-config.yaml
actualizado:envsubst < configmaps/opentsdb-config.yaml.tpl | kubectl create -f -
Crea tablas de OpenTSDB en Bigtable
Antes de poder realizar operaciones de lectura o escritura de datos con OpenTSDB, debes crear tablas en Bigtable para almacenar esos datos. Para crear las tablas, deberás crear un trabajo de Kubernetes.
En Cloud Shell, inicia el trabajo:
envsubst < jobs/opentsdb-init.yaml.tpl | kubectl create -f -
El trabajo puede tardar uno o más minutos en completarse. Verifica si el trabajo se haya completado de forma correcta:
kubectl describe jobs
El resultado muestra que un trabajo se realizó correctamente cuando
Pods Statuses
muestra1 Succeeded
Examina los registros de trabajo de creación de tablas:
OPENTSDB_INIT_POD=$(kubectl get pods --selector=job-name=opentsdb-init \ --output=jsonpath={.items..metadata.name}) kubectl logs $OPENTSDB_INIT_POD
El resultado es similar al siguiente:
create 'tsdb-uid', {NAME => 'id', COMPRESSION => 'NONE', BLOOMFILTER => 'ROW', DATA_BLOCK_ENCODING => 'DIFF'}, {NAME => 'name', COMPRESSION => 'NONE', BLOOMFILTER => 'ROW', DATA_BLOCK_ENCODING => 'DIFF'} 0 row(s) in 3.2730 seconds create 'tsdb', {NAME => 't', VERSIONS => 1, COMPRESSION => 'NONE', BLOOMFILTER => 'ROW', DATA_BLOCK_ENCODING => 'DIFF'} 0 row(s) in 1.8440 seconds create 'tsdb-tree', {NAME => 't', VERSIONS => 1, COMPRESSION => 'NONE', BLOOMFILTER => 'ROW', DATA_BLOCK_ENCODING => 'DIFF'} 0 row(s) in 1.5420 seconds create 'tsdb-meta', {NAME => 'name', COMPRESSION => 'NONE', BLOOMFILTER => 'ROW', DATA_BLOCK_ENCODING => 'DIFF'} 0 row(s) in 1.9910 seconds
El resultado enumera cada tabla que se creó. Este trabajo ejecuta varios comandos de creación de tablas, cada uno con el formato de
create TABLE_NAME
. Las tablas se crean de forma correcta cuando tienes un resultado como el siguiente0 row(s) in TIME seconds
.TABLE_NAME
: es el nombre de la tabla que crea el trabajo.TIME
: la cantidad de tiempo que tomó crear la tabla.
Modelo de datos
Las tablas que creaste almacenan datos de OpenTSDB. En un paso posterior, escribirás datos de series temporales en estas tablas. Los datos de series temporales se organizan y almacenan de la siguiente manera:
Campo | Obligatorio | Descripción | Ejemplo |
---|---|---|---|
metric
|
Obligatorio | Elemento que se mide: la clave predeterminada |
sys.cpu.user
|
timestamp
|
Obligatorio | Inicio del tiempo Unix de la medición | 1497561091 |
tags
|
Se requiere al menos una etiqueta | Califica la medición con fines de consulta. |
hostname=www
cpu=0
env=prod
|
value
|
Obligatorio | Valor de la medición | 89.3 |
La métrica, la marca de tiempo y las etiquetas (clave de etiqueta y valor de etiqueta) forman la clave de fila. La marca de tiempo se normaliza a una hora para garantizar que una fila no contenga demasiados datos. Para obtener más información, consulta Esquema de HBase.
Implementa OpenTSDB
En el siguiente diagrama, se muestra la arquitectura de implementación de OpenTSDB con sus servicios que se ejecutan en GKE y con Bigtable como backend de almacenamiento:
En esta guía, se usan dos implementaciones de OpenTSDB en Kubernetes: una implementación envía métricas a Bigtable y la otra implementa lecturas desde este. El uso de dos implementaciones evita que las operaciones de lectura y escritura de larga ejecución se bloqueen entre sí. Los Pods en cada implementación usan la misma imagen de contenedor.
OpenTSDB proporciona un daemon llamado tsd
que se ejecuta en cada contenedor. Un solo proceso tsd
puede manejar una alta capacidad de procesamiento de eventos por segundo. Para distribuir la carga, cada implementación de esta guía crea tres réplicas de los Pods de lectura y escritura.
En Cloud Shell, crea una implementación para escribir métricas:
envsubst < deployments/opentsdb-write.yaml.tpl | kubectl create -f -
La información de configuración para la implementación de escritura se encuentra en el archivo
opentsdb-write.yaml.tpl
en la carpetadeployments
del repositorio de al guía.Crea una implementación para la lectura de métricas:
envsubst < deployments/opentsdb-read.yaml.tpl | kubectl create -f -
La información de configuración para la implementación del lector se encuentra en el archivo
opentsdb-read.yaml.tpl
en la carpetadeployments
del repositorio de la guía.
En una implementación de producción, puedes aumentar la cantidad de Pods tsd
en ejecución, ya sea de forma manual o mediante el ajuste de escala automático en Kubernetes. De forma similar, puedes aumentar la cantidad de instancias en tu clúster de GKE de forma manual o mediante el escalador automático del clúster.
Crea los servicios de OpenTSDB
Para proporcionar una conectividad de red coherente a las implementaciones, crea dos servicios de Kubernetes: un servicio escribe métricas en OpenTSDB y el otro las lee.
En Cloud Shell, crea el servicio para escribir métricas:
kubectl create -f services/opentsdb-write.yaml
La información de configuración para el servicio de escritura de métricas se encuentra en el archivo
opentsdb-write.yaml
en la carpetaservices
del repositorio de la guía. Este servicio se crea dentro de tu clúster de Kubernetes y otros servicios que se ejecutan en tu clúster pueden acceder a él.Crea el servicio para la lectura de métricas:
kubectl create -f services/opentsdb-read.yaml
La información de configuración para el servicio de lectura de métricas se encuentra en el archivo
opentsdb-read.yaml
en la carpetaservices
del repositorio de la guía.
Escribe datos de serie temporal en OpenTSDB
Existen varios mecanismos para escribir datos en OpenTSDB. Después de definir los extremos del servicio, puede dirigir los procesos para que se empiecen a escribir datos en ellos. En esta guía, se implementa un servicio de Python que emite datos de serie temporal demostrativos para dos métricas: Uso de memoria del clúster (memory_usage_gauge
) y Uso de CPU del clúster (cpu_node_utilization_gauge
).
En Cloud Shell, implementa el generador de métricas de series temporales en tu clúster:
envsubst < deployments/generate.yaml.tpl | kubectl create -f -
Examina los datos de serie temporal de ejemplo con OpenTSDB
Puedes consultar las métricas de serie temporal mediante el extremo del servicio opentsdb-read
que implementaste antes en la guía. Puedes usar los datos de varias maneras.
Una opción común es visualizarlo. OpenTSDB incluye una interfaz básica para visualizar las métricas que recopila. En esta guía, se usa Grafana, una alternativa popular para visualizar métricas que proporciona funciones adicionales.
Si deseas ejecutar Grafana en tu clúster, debes realizar un proceso similar al que usaste para configurar OpenTSDB. Además de crear un ConfigMap y una implementación, debes configurar la redirección de puertos de modo que puedas acceder a Grafana mientras se ejecuta en tu clúster de Kubernetes.
En Cloud Shell, crea el ConfigMap de Grafana con la información de configuración del archivo
grafana.yaml
en la carpetaconfigmaps
del repositorio de la guía:kubectl create -f configmaps/grafana.yaml
Crea la implementación de Grafana con la información de configuración del archivo
grafana.yaml
que se encuentra en la carpetadeployments
del repositorio de la guía:kubectl create -f deployments/grafana.yaml
Obtén el nombre del Pod de Grafana en el clúster y úsalo para configurar la redirección de puertos.
GRAFANA_PODS=$(kubectl get pods --selector=app=grafana \ --output=jsonpath={.items..metadata.name}) kubectl port-forward $GRAFANA_PODS 8080:3000
Verifica que la redirección fue exitosa. El resultado es similar al siguiente:
Forwarding from 127.0.0.1:8080 -> 3000
Para conectarte a la interfaz web de Grafana, en Cloud Shell, haz clic en Web Preview y, a continuación, selecciona Preview on port 8080.
Para obtener más información, consulta Usa la vista previa en la Web.
Se abrirá una nueva pestaña del navegador y se conectará a la interfaz web de Grafana. Después de unos instantes, el navegador mostrará gráficos como los siguientes:
Esta implementación de Grafana se personalizó para esta guía. Los archivos
configmaps/grafana.yaml
ydeployments/grafana.yaml
configuran Grafana para conectarse al servicioopentsdb-read
, permiten la autenticación anónima y muestran algunas métricas básicas del clúster. Para una implementación de Grafana en un entorno de producción, te recomendamos que implementes los mecanismos de autenticación adecuados y utilices gráficos de serie temporal más completos.
Limpia
Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales.
Borra los recursos individuales
Borra el clúster de Kubernetes para borrar todos los artefactos que creaste:
gcloud container clusters delete GKE_CLUSTER_NAME
A fin de borrar el clúster de Kubernetes, escribe
Y
para confirmar.Para borrar la instancia de Bigtable, haz lo siguiente:
En la consola de Google Cloud, ve a Bigtable.
Selecciona la instancia que creaste antes y, a continuación, haz clic en Delete instance.
Borra el proyecto
- 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.
¿Qué sigue?
- Para aprender cómo mejorar el rendimiento de tus usos de OpenTSDB, consulta Diseño de esquemas de Bigtable para datos de series temporales.
- Para aprender cómo migrar de HBase a Bigtable, consulta Migra datos de HBase a Bigtable.
- El video Bigtable en acción de Google Cloud Next 17, describe la promoción de campo: una mejora importante del rendimiento.
- Para obtener más información sobre los alcances predeterminados de los clústeres de GKE, consulta los alcances de los clústeres.
- Explora arquitecturas de referencia, diagramas y prácticas recomendadas sobre Google Cloud. Consulta nuestro Cloud Architecture Center.