Surveiller des données de séries temporelles avec OpenTSDB sur Bigtable et GKE

Last reviewed 2022-01-12 UTC
Dans ce tutoriel, nous vous expliquons comment collecter, enregistrer et surveiller des données de séries temporelles sur Google Cloud avec OpenTSDB exécuté sur Google Kubernetes Engine (GKE) et Bigtable.

Les données de séries temporelles constituent un atout précieux que vous pouvez exploiter pour différentes applications, en particulier dans les domaines de la surveillance, de l'analyse des tendances et du machine learning. Vous pouvez générer des données de séries temporelles à partir de l'infrastructure de serveurs, du code d'application ou d'autres sources. OpenTSDB est capable de collecter et de conserver de grandes quantités de données de séries temporelles avec un degré élevé de précision.

Ce guide montre aux ingénieurs et architectes logiciels comment créer une couche de collecte évolutive pour des données de séries temporelles à l'aide de GKE. Il montre également comment utiliser les données collectées à l'aide de Bigtable. Dans ce guide, nous partons du principe que vous maîtrisez Kubernetes et Bigtable.

Le diagramme suivant illustre l'architecture générale de ce guide :

Sources des données de séries temporelles stockées dans Bigtable

Le schéma précédent montre plusieurs sources de données de séries temporelles, telles que les événements IoT et les métriques système, stockées dans Bigtable à l'aide d'OpenTSDB déployé sur GKE.

Objectifs

  • Créez des images de conteneurs utilisées dans ce guide à l'aide de Cloud Build.
  • Gérez ces images de conteneurs avec Artifact Registry.
  • Créer une instance Bigtable
  • Créer un cluster GKE
  • Déployer OpenTSDB sur votre cluster GKE
  • Envoyer des métriques de séries temporelles à OpenTSDB
  • Visualiser ces métriques à l'aide d'OpenTSDB et de Grafana

Coûts

Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Une fois que vous avez terminé les tâches décrites dans ce document, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Avant de commencer

  1. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

    Accéder au sélecteur de projet

  2. Vérifiez que la facturation est activée pour votre projet Google Cloud.

  3. Activer les API Bigtable, Bigtable Admin, GKE, Compute Engine, Cloud Build, and Artifact Registry.

    Activer les API

  4. Dans la console Google Cloud, accédez à la page d'accueil.

    Accéder à la page d'accueil

    Notez l'ID du projet, car il sera utilisé dans une étape ultérieure.

  5. Dans la console Google Cloud, activez Cloud Shell.

    Activer Cloud Shell

Créer une instance Bigtable

Ce guide utilise Bigtable pour stocker les données de séries temporelles que vous collectez. Vous devez donc créer une instance Bigtable.

Bigtable est un magasin de type clé/colonne large qui fonctionne parfaitement pour les données de séries temporelles. Bigtable est compatible avec l'API HBase. Vous pouvez donc utiliser un logiciel conçu pour fonctionner avec Apache HBase, tel qu'OpenTSDB. Pour plus d'informations sur le schéma HBase utilisé par OpenTSDB, consultez la page Schéma HBase.

Un composant clé d'OpenTSDB est le client AsyncHBase, qui lui permet d'effectuer des écritures groupées sur HBase d'une manière totalement asynchrone, non bloquante et sécurisée. Lorsque vous utilisez OpenTSDB avec Bigtable, AsyncHBase est mis en œuvre en tant que client AsyncBigtable.

Ce guide utilise une instance Bigtable avec un cluster à nœud unique. Lorsque vous passez à un environnement de production, pensez à utiliser des instances Bigtable avec des clusters plus importants. Pour en savoir plus sur le choix de la taille d'un cluster, consultez la page Comprendre les performances de Bigtable.

  1. Dans Cloud Shell, définissez les variables d'environnement de votre zone Google Cloud dans lesquelles vous allez créer votre cluster Bigtable et votre cluster GKE, ainsi que l'identifiant d'instance de votre cluster Bigtable :

    export BIGTABLE_INSTANCE_ID=BIGTABLE_INSTANCE_ID
export ZONE=ZONE

    Remplacez les éléments suivants :

    • BIGTABLE_INSTANCE_ID : identifiant de votre instance Bigtable.
    • ZONE : zone dans laquelle votre cluster Bigtable et votre cluster GKE seront créés.

    La commande doit ressembler à l'exemple suivant :

    export BIGTABLE_INSTANCE_ID=bt-opentsdb
export ZONE=us-central1-f

  2. Créez l'instance Bigtable :

    gcloud bigtable instances create ${BIGTABLE_INSTANCE_ID} \
    --cluster-config=id=${BIGTABLE_INSTANCE_ID}-${ZONE},zone=${ZONE},nodes=1 \
    --display-name=OpenTSDB

Créer les images utilisées pour déployer et tester OpenTSDB

Pour déployer et illustrer OpenTSDB avec un backend de stockage Bigtable, ce guide utilise une série d'images de conteneurs Docker déployées sur GKE. Vous pouvez créer plusieurs de ces images à l'aide du code d'un dépôt GitHub associé à Cloud Build. Lors du déploiement de l'infrastructure sur GKE, un dépôt de conteneurs est utilisé. Dans ce guide, vous gérez les images de conteneurs avec Artifact Registry.

  1. Dans Cloud Shell, définissez les variables d'environnement de votre zone Google Cloud dans laquelle vous allez créer votre dépôt Artifact Registry :

    export PROJECT_ID=PROJECT_ID
export REGION=REGION
export AR_REPO=AR_REPO

    Remplacez les éléments suivants :

    • PROJECT_ID : ID de votre projet
    • REGION : région dans laquelle votre dépôt Artifact Registry sera créé
    • AR_REPO : nom de votre dépôt Artifact Registry

    La commande doit ressembler à l'exemple suivant :

    export PROJECT_ID=bt-opentsdb-project-id
export REGION=us-central1
export AR_REPO=opentsdb-bt-repo

  2. Créer un dépôt Artifact Registry :

    gcloud artifacts repositories create ${AR_REPO} \
    --repository-format=docker  \
    --location=${REGION} \
    --description="OpenTSDB on bigtable container images"

Créer et gérer les images utilisées pour déployer et illustrer OpenTSDB

Deux images de conteneur Docker sont utilisées dans ce guide. La première image est utilisée à deux fins : pour effectuer la configuration unique de la base de données Bigtable pour OpenTSDB, et pour déployer les conteneurs de service de lecture et d'écriture pour le déploiement OpenTSDB. La deuxième image permet de générer des exemples de données de métriques afin de démontrer votre déploiement OpenTSDB.

Lorsque vous envoyez la tâche de compilation d'images de conteneurs à Cloud Build, vous ajoutez un tag aux images afin qu'elles soient stockées dans Artifact Registry après leur création.

  1. Dans Cloud Shell, clonez le dépôt GitHub contenant le code associé :

    git clone https://github.com/GoogleCloudPlatform/opentsdb-bigtable.git

  2. Accédez au répertoire de l'exemple de code :

    cd opentsdb-bigtable

  3. Définissez les variables d'environnement pour l'image de serveur OpenTSDB qui utilise Bigtable comme backend de stockage :

    export SERVER_IMAGE_NAME=opentsdb-server-bigtable
export SERVER_IMAGE_TAG=2.4.1

  4. Générez l'image à l'aide de Cloud Build :

    gcloud builds submit \
    --tag ${REGION}-docker.pkg.dev/${PROJECT_ID}/${AR_REPO}/${SERVER_IMAGE_NAME}:${SERVER_IMAGE_TAG} \
    build

    Étant donné que vous avez ajouté des tags à l'image de manière appropriée, une fois la compilation terminée, l'image sera gérée par votre dépôt Artifact Registry.

  5. Définissez les variables d'environnement pour l'image de génération de données de série temporelle de démonstration :

    export GEN_IMAGE_NAME=opentsdb-timeseries-generate
export GEN_IMAGE_TAG=0.1

  6. Générez l'image à l'aide de Cloud Build :

    cd generate-ts
./build-cloud.sh
cd ..

Créer un cluster GKE

GKE fournit un environnement Kubernetes géré. Après avoir créé un cluster GKE, vous pouvez y déployer des pods Kubernetes. Dans ce guide, nous allons exécuter OpenTSDB en utilisant des pods GKE et Kubernetes.

OpenTSDB sépare sa couche de stockage de sa couche d'application, ce qui lui permet d'être déployé simultanément sur plusieurs instances. Grâce à ce mode d'exécution parallèle, OpenTSDB peut gérer une grande quantité de données de séries temporelles.

  1. Dans Cloud Shell, définissez les variables d'environnement pour la zone Google Cloud dans laquelle vous allez créer votre cluster Bigtable et votre cluster GKE, ainsi que le nom, le type de nœud et la version de votre cluster GKE :

    export GKE_CLUSTER_NAME=GKE_CLUSTER_NAME
export GKE_VERSION=1.20
export GKE_NODE_TYPE=n1-standard-4

    Remplacez GKE_CLUSTER_NAME par le nom de votre cluster GKE.

    La commande doit ressembler à l'exemple suivant :

    export GKE_CLUSTER_NAME=gke-opentsdb
export GKE_VERSION=1.20
export GKE_NODE_TYPE=n1-standard-4

  2. Créez un cluster 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"

    Cette opération peut durer quelques minutes. L'ajout des champs d'application à votre cluster GKE permet à votre conteneur OpenTSDB d'interagir avec Bigtable et Container Registry.

    Le reste de ce guide utilise les conteneurs que vous venez de créer et qui sont gérés par Artifact Registry. Les scripts Dockerfile et entrypoint permettant de créer le conteneur se trouvent dans le dossier build du dépôt du guide.

  3. Obtenez les identifiants afin de pouvoir vous connecter à votre cluster GKE :

    gcloud container clusters get-credentials ${GKE_CLUSTER_NAME} --zone ${ZONE}

Créer un ConfigMap avec les détails de configuration

Kubernetes se sert de ConfigMap pour dissocier les détails de la configuration de l'image de conteneur afin de rendre les applications plus portables. La configuration d'OpenTSDB est spécifiée dans le fichier opentsdb.conf. Un fichier ConfigMap contenant le fichier opentsdb.conf est fourni avec l'exemple de code.

Dans cette étape et les suivantes, vous allez utiliser l'utilitaire GNU envsubst pour remplacer les espaces réservés des variables d'environnement dans les fichiers de modèle YAML par les valeurs respectives de votre déploiement.

  • Créez un ConfigMap à partir du fichier opentsdb-config.yaml mis à jour :

    envsubst < configmaps/opentsdb-config.yaml.tpl | kubectl create -f -

Créer des tables OpenTSDB dans Bigtable

Avant de pouvoir lire ou écrire des données avec OpenTSDB, vous devez créer des tables dans Bigtable pour stocker ces données. Pour créer les tables, vous devez créer une tâche Kubernetes.

  1. Dans Cloud Shell, lancez la tâche :

    envsubst < jobs/opentsdb-init.yaml.tpl | kubectl create -f -

    Cette tâche peut durer une minute ou plus. Vérifiez que la tâche a bien été exécutée :

    kubectl describe jobs

    Le résultat montre que l'exécution d'une tâche a réussi lorsque Pods Statuses affiche 1 Succeeded.

  2. Examinez les journaux de la tâche de création de table :

    OPENTSDB_INIT_POD=$(kubectl get pods --selector=job-name=opentsdb-init \
                    --output=jsonpath={.items..metadata.name})
kubectl logs $OPENTSDB_INIT_POD

    Le résultat ressemble à ce qui suit :

    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

    Le résultat répertorie chaque table créée. Cette tâche exécute plusieurs commandes de création de table, chacune au format create TABLE_NAME. Les tables sont créées correctement lorsque vous obtenez une sortie au format 0 row(s) in TIME seconds.

    • TABLE_NAME : nom de la table créée par la tâche.
    • TIME : délai nécessaire à la création de la table

Modèle de données

Les tables que vous avez créées stockent des points de données à partir d'OpenTSDB. Lors d'une prochaine étape, vous écrirez des données de séries temporelles dans ces tables. Les points de données de séries temporelles sont organisés et stockés comme suit :

Champ Obligatoire Description Exemple
metric Requis Élément mesuré : la clé par défaut sys.cpu.user
timestamp Requis Date de l'epoch Unix de la mesure 1497561091
tags Veuillez indiquer au moins un tag. Qualifie la mesure à des fins de requêtes hostname=www cpu=0 env=prod
value Requis Valeur de mesure 89,3

La métrique, l'horodatage et les tags (clé et valeur du tag) forment la clé de ligne. L'horodatage est normalisé à une heure, pour garantir qu'une ligne ne contient pas trop de points de données. Pour en savoir plus, consultez la page Schéma HBase.

Déployer OpenTSDB

Le schéma suivant illustre l'architecture de déploiement d'OpenTSTB avec ses services exécutés sur GKE et avec Bigtable comme backend de stockage :

Deux déploiements Kubernetes OpenTSDB.

Dans ce guide, nous utilisons deux déploiements Kubernetes OpenTSDB : l'un d'entre eux envoie des métriques à Bigtable et l'autre effectue des lectures de Bigtable. L'utilisation de deux déploiements vise à éviter que les lectures et les écritures de longue durée ne se bloquent mutuellement. Les pods de chaque déploiement utilisent le même conteneur. OpenTSDB fournit un daemon nommé tsd qui s'exécute dans chaque conteneur. Un processus tsd peut gérer à lui seul un débit élevé d'événements par seconde. Afin de répartir la charge, chaque déploiement de ce guide crée trois instances dupliquées des pods de lecture et d'écriture.

  1. Dans Cloud Shell, créez un déploiement pour écrire des métriques :

    envsubst < deployments/opentsdb-write.yaml.tpl | kubectl create -f  -

    Les informations de configuration associées au déploiement en écriture se trouvent dans le fichier opentsdb-write.yaml.tpl du dossier deployments du dépôt du guide.

  2. Créer un déploiement pour lire les métriques

    envsubst < deployments/opentsdb-read.yaml.tpl | kubectl create -f  -

    Les informations de configuration associées au déploiement en lecture se trouvent dans le fichier opentsdb-read.yaml.tpl du dossier deployments du dépôt du guide.

Pour augmenter le nombre de pods tsd en cours d'exécution dans un déploiement de production, vous pouvez procéder manuellement ou à l'aide de la fonctionnalité d'autoscaling de Kubernetes. De même, l'augmentation du nombre d'instances présentes dans votre cluster GKE peut s'effectuer manuellement ou via l'autoscaler de cluster.

Créer les services OpenTSDB

Afin de fournir une connectivité réseau cohérente aux déploiements, vous créez deux services Kubernetes : l'un d'entre eux écrit des métriques dans OpenTSDB et l'autre les lit.

  1. Dans Cloud Shell, créez le service permettant d'écrire des métriques :

    kubectl create -f services/opentsdb-write.yaml

    Les informations de configuration associées au service d'écriture de métriques sont contenues dans le fichier opentsdb-write.yaml situé dans le dossier services du dépôt du guide. Ce service est créé dans votre cluster Kubernetes, et il est accessible par d'autres services exécutés dans votre cluster.

  2. Créez le service de lecture de métriques :

    kubectl create -f services/opentsdb-read.yaml

    Les informations de configuration associées au service de lecture de métriques sont contenues dans le fichier opentsdb-read.yaml situé dans le dossier services du dépôt du guide.

Écrire des données de séries temporelles dans OpenTSDB

Il existe plusieurs mécanismes pour écrire des données dans OpenTSDB. Après avoir défini les points de terminaison de service, vous pouvez demander aux processus de commencer à écrire des données sur ceux-ci. Ce guide déploie un service Python qui émet des données de série temporelle illustrant deux métriques : Utilisation de la mémoire du cluster (memory_usage_gauge) et Utilisation du processeur du cluster (cpu_node_utilization_gauge).

  • Dans Cloud Shell, déployez le générateur de métriques de séries temporelles sur votre cluster :

    envsubst < deployments/generate.yaml.tpl | kubectl create -f -

Examiner les exemples de données de séries temporelles avec OpenTSDB

Vous pouvez interroger des métriques de séries temporelles à l'aide du point de terminaison du service opentsdb-read déployé précédemment dans ce guide. Vous pouvez utiliser les données de différentes manières. Une option courante consiste à les visualiser. OpenTSDB intègre une interface de base permettant de visualiser les métriques qu'il collecte. Ce guide fait appel à Grafana, une solution alternative très utilisée pour visualiser des métriques, qui présente l'avantage d'offrir des fonctionnalités supplémentaires.

L'exécution de Grafana dans votre cluster nécessite un processus semblable à celui que vous avez utilisé pour configurer OpenTSDB. Outre la création d'un ConfigMap et d'un déploiement, vous devez configurer le transfert de port de manière à pouvoir accéder à Grafana pendant son exécution dans votre cluster Kubernetes.

  1. Dans Cloud Shell, créez le fichier ConfigMap de Grafana à l'aide des informations de configuration contenues dans le fichier grafana.yaml situé dans le dossier configmaps du dépôt du guide :

    kubectl create -f configmaps/grafana.yaml

  2. Créez le déploiement de Grafana à l'aide des informations de configuration contenues dans le fichier grafana.yaml situé dans le dossier deployments du dépôt du guide :

    kubectl create -f deployments/grafana.yaml

  3. Obtenez le nom du pod de Grafana dans le cluster, puis utilisez-le pour configurer le transfert de port :

    GRAFANA_PODS=$(kubectl get pods --selector=app=grafana \
               --output=jsonpath={.items..metadata.name})
kubectl port-forward $GRAFANA_PODS 8080:3000

    Vérifiez que le transfert a abouti. Le résultat ressemble à ce qui suit :

    Forwarding from 127.0.0.1:8080 -> 3000

  4. Pour vous connecter à l'interface Web de Grafana, dans Cloud Shell, cliquez sur Aperçu sur le Web, puis sélectionnez Prévisualiser sur le port 8080.

    Pour en savoir plus, consultez la page Utiliser l'aperçu sur le Web.

    Le navigateur ouvre un nouvel onglet, qui se connecte à l'interface Web de Grafana. Après quelques instants, le navigateur affiche des graphiques comme celui-ci :

    Graphique en courbes affichant les métriques du cluster.

    Ce déploiement de Grafana a été personnalisé pour le présent guide. Les fichiers configmaps/grafana.yaml et deployments/grafana.yaml configurent Grafana pour se connecter au service opentsdb-read, afin d'autoriser l'authentification anonyme et d'afficher certaines métriques de base du cluster. Pour un déploiement de Grafana dans un environnement de production, nous vous recommandons de mettre en œuvre les mécanismes d'authentification appropriés et d'utiliser des graphiques de séries temporelles plus riches.

Nettoyer

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

Supprimer les ressources individuelles

  1. Supprimez le cluster Kubernetes pour supprimer tous les artefacts que vous avez créés :

    gcloud container clusters delete GKE_CLUSTER_NAME

    Pour supprimer le cluster Kubernetes, confirmez l'opération en saisissant Y.

  2. Pour supprimer l'instance Bigtable, procédez comme suit :

    1. Dans la console Google Cloud, accédez à Bigtable.

      Accéder à Bigtable

    2. Sélectionnez l'instance que vous avez créée précédemment, puis cliquez sur Supprimer l'instance.

Supprimer le projet

  1. Dans la console Google Cloud, accédez à la page Gérer les ressources.

    Accéder à la page Gérer les ressources

  2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
  3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Étape suivante