Supervisa datos de series temporales con OpenTSDB en Cloud Bigtable y GKE

Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.
En esta guía, se describe cómo recopilar, registrar y supervisar datos de serie temporal en Google Cloud mediante OpenTSDB que se ejecuta en Google Kubernetes Engine (GKE) y Bigtable.

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:

Fuentes de datos de series temporales almacenados en Bigtable.

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 instructivo, se usan 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. Es posible que los usuarios nuevos de Google Cloud califiquen para obtener una prueba gratuita.

Cuando finalices este instructivo, podrás borrar los recursos creados para evitar que se te siga facturando. Para obtener más información, consulta Cómo realizar una limpieza.

Antes de comenzar

  1. En la página del selector de proyectos de Google Cloud Console, selecciona o crea un proyecto de Google Cloud.

    Ir al selector de proyectos

  2. Comprueba que la facturación esté habilitada en tu proyecto.

    Descubre cómo puedes habilitar la facturación

  3. Habilita las API de Bigtable, Bigtable Admin, GKE, Compute Engine, Cloud Build, and Artifact Registry.

    Habilita las API

  4. En la consola de Google Cloud, ve a la página Panel.

    Ir al panel

    Toma nota del ID del proyecto, ya que se usa en un paso posterior.

  5. En la consola de Google Cloud, activa Cloud Shell.

    Activar 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 un tamaño de clúster, consulta Información sobre el rendimiento de Bigtable.

  1. 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
    
  2. 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.

  1. 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 proyecto
    • REGION: La región en la que se creará el repositorio de Artifact Registry
    • AR_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
    
  2. 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.

  1. En Cloud Shell, clona el repositorio de GitHub que contiene el código adjunto:

    git clone https://github.com/GoogleCloudPlatform/opentsdb-bigtable.git
    
  2. Ve al directorio del código de muestra:

    cd opentsdb-bigtable
    
  3. 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
    
  4. 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.

  5. 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
    
  6. 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.

  1. 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
    
  2. 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 carpeta build del repositorio de la guía.

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

  1. 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 muestra 1 Succeeded

  2. 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 siguiente 0 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:

Dos implementaciones de OpenTSDB en Kubernetes.

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.

  1. 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 carpeta deployments del repositorio de al guía.

  2. 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 carpeta deployments 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.

  1. 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 carpeta services 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.

  2. 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 carpeta services 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.

  1. En Cloud Shell, crea el ConfigMap de Grafana con la información de configuración del archivo grafana.yaml en la carpeta configmaps del repositorio de la guía:

    kubectl create -f configmaps/grafana.yaml
    
  2. Crea la implementación de Grafana con la información de configuración del archivo grafana.yaml que se encuentra en la carpeta deployments del repositorio de la guía:

    kubectl create -f deployments/grafana.yaml
    
  3. 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
    
  4. 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:

    Gráfico de líneas que muestra las métricas del clúster.

    Esta implementación de Grafana se personalizó para esta guía. Los archivos configmaps/grafana.yaml y deployments/grafana.yaml configuran Grafana para conectarse al servicio opentsdb-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

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

  2. Para borrar la instancia de Bigtable, haz lo siguiente:

    1. En la consola de Google Cloud, ve a Bigtable.

      Ir a Bigtable

    2. Selecciona la instancia que creaste antes y, a continuación, haz clic en Delete instance.

Borra el proyecto

  1. En la consola de Google Cloud, ve a la página Administrar recursos.

    Ir a Administrar recursos

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

¿Qué sigue?