Surveiller des données de séries temporelles avec OpenTSDB

Dans ce tutoriel, nous vous expliquons comment collecter, enregistrer et surveiller des données de séries temporelles sur Google Cloud Platform (GCP) à l'aide d'OpenTSDB exécuté sur Google Kubernetes Engine (GKE) et de Cloud 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.

Dans ce tutoriel, nous expliquons comment créer une couche de collecte de données évolutive via GKE et exploiter les données recueillies à l'aide de Cloud Bigtable. Le diagramme suivant représente l'architecture générale de la solution :

Diagramme d'architecture de haut niveau de la solution adoptée dans ce tutoriel pour utiliser TSDB sur GCP

Objectifs

  • Créer une instance Cloud 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

Ce tutoriel fait appel à des composants payants de GCP, par exemple :

  • Compute Engine
  • GKE
  • Cloud Bigtable
  • Cloud Storage

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût.

Les nouveaux utilisateurs de GCP peuvent bénéficier d'un essai gratuit.

Avant de commencer

  1. Connectez-vous à votre compte Google.

    Si vous n'en possédez pas déjà un, vous devez en créer un.

  2. Dans la page de sélection du projet de la console GCP, sélectionnez ou créez un projet GCP.

    Accéder à la page de sélection du projet

  3. Assurez-vous que la facturation est activée pour votre projet Google Cloud Platform. Découvrez comment confirmer que la facturation est activée pour votre projet.

  4. Activez les Cloud Bigtable, Cloud Bigtable Admin, Compute Engine, and Google Kubernetes Engine API requises.

    Activer les API

Notez l'ID de projet, car vous en aurez besoin lors d'une prochaine étape.

Préparer l'environnement

Dans ce tutoriel, vous allez utiliser Cloud Shell pour saisir des commandes. Cloud Shell vous donne accès à la ligne de commande dans la console GCP, et intègre le SDK Cloud ainsi que d'autres outils dont vous pourrez avoir besoin pour le développement dans GCP. Cloud Shell apparaît sous la forme d'une fenêtre au bas de la console GCP. Son initialisation peut prendre quelques minutes, mais la fenêtre s'affiche immédiatement.

  1. Activez Cloud Shell.

    ACTIVER Cloud Shell

  2. Définissez la zone Compute Engine par défaut sur la zone dans laquelle vous allez créer votre cluster Cloud Bigtable (us-central1-f, par exemple).

    gcloud config set compute/zone us-central1-f
    
  3. Clonez le dépôt git contenant l'exemple de code.

    git clone https://github.com/GoogleCloudPlatform/opentsdb-bigtable.git
    
  4. Accédez au répertoire de l'exemple de code.

    cd opentsdb-bigtable
    

Créer une instance Cloud Bigtable

Dans ce tutoriel, nous allons nous servir de Cloud Bigtable pour stocker les données de séries temporelles que vous collectez. Vous devez créer une instance Cloud Bigtable pour effectuer ce travail.

Cloud Bigtable est un magasin de paires clé/colonne large qui fonctionne particulièrement bien pour les données de séries temporelles, comme cela est expliqué sur la page Conception de schémas Cloud Bigtable pour les données de séries temporelles. Cloud Bigtable est compatible avec l'API HBase, ce qui facilite l'utilisation des logiciels conçus pour fonctionner avec Apache HBase, tels qu'OpenTSDB. Pour en savoir plus sur le schéma HBase utilisé par OpenTSDB, consultez la documentation OpenTSDB.

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 Cloud Bigtable, AsyncHBase est mis en œuvre en tant que client AsyncBigtable.

L'une des principales caractéristiques de Cloud Bigtable est sa capacité à évoluer aisément pour s'adapter à vos besoins. Dans ce tutoriel, nous utilisons un cluster de développement à un seul nœud, qui représente une option économique et suffisante pour la tâche à effectuer. Démarrez vos projets dans un cluster de développement, puis passez à un cluster de production plus grand lorsque vous êtes prêt à utiliser les données de production. Dans la documentation de Cloud Bigtable, vous trouverez des informations détaillées sur les performances et le scaling qui vous aideront à choisir une taille de cluster adaptée à votre propre travail.

Procédez comme suit pour créer votre instance Cloud Bigtable :

  1. Accédez à la page Créer une instance dans la console GCP.

    ACCÉDER À LA PAGE "CRÉER UNE INSTANCE"

  2. Saisissez le nom de la nouvelle instance dans le champ Nom de l'instance. Vous pouvez indiquer OpenTSDB instance ou le nom de votre choix. Une fois le nom de l'instance saisi, les champs ID d'instance et ID de cluster sont automatiquement renseignés sur la page.

  3. Définissez le champ Type d'instance sur Développement.

  4. Pour le champ Zone, sélectionnez us-central1-f ou la zone à partir de laquelle vous allez exécuter OpenTSDB.

  5. Cliquez sur Créer pour créer l'instance.

Notez les valeurs des champs ID d'instance et Zone, car vous en aurez besoin lors d'une prochaine étape.

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 tutoriel, 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; il peut gérer une grande quantité de données de séries temporelles. Le fait d'empaqueter OpenTSDB dans un conteneur Docker facilite son déploiement à grande échelle via GKE.

Créez un cluster Kubernetes en exécutant la commande ci-après. Cette opération peut durer quelques minutes :

gcloud container clusters create opentsdb-cluster --scopes \
"https://www.googleapis.com/auth/bigtable.admin",\
"https://www.googleapis.com/auth/bigtable.data"

Les deux champs d'application supplémentaires ajoutés à votre cluster GKE permettent au conteneur OpenTSDB d'interagir avec Cloud Bigtable. Vous pouvez extraire des images de Google Container Registry sans ajouter de champ d'application pour Cloud Storage, car le cluster a par défaut le droit d'accès en lecture à partir de Cloud Storage. Sachez que vous pouvez éventuellement avoir besoin de champs d'application supplémentaires dans des déploiements différents de celui-ci.

Dans le reste de ce tutoriel, nous utilisons le conteneur prédéfini gcr.io/cloud-solutions-images/opentsdb-bigtable:v1, situé dans Container Registry. Les scripts Dockerfile et ENTRYPOINT permettant de créer le conteneur se trouvent dans le dossier build du dépôt du tutoriel.

Créer un fichier ConfigMap contenant les détails de la configuration

Kubernetes fournit un mécanisme appelé ConfigMap, grâce auquel il est possible de séparer les détails de la configuration et l'image du conteneur afin d'améliorer la portabilité des applications. La configuration d'OpenTSDB est spécifiée dans opentsdb.conf. Un fichier ConfigMap contenant opentsdb.conf est fourni avec l'exemple de code. Vous devez le modifier de manière à intégrer les détails de votre instance.

Créer le fichier ConfigMap

Modifiez la configuration d'OpenTSDB de façon à vous servir du nom de projet, de l'identifiant d'instance et de la zone que vous avez utilisés lors de la création de votre instance.

  1. Pour ouvrir l'éditeur de code intégré à Cloud Shell, cliquez sur l'icône en forme de crayon dans la barre d'outils située en haut de la fenêtre Cloud Shell.

  2. Sélectionnez le fichier opentsdb-config.yaml sous opentsdb/configmaps pour l'ouvrir dans l'éditeur.

  3. Remplacez le texte d'espace réservé par le nom du projet, l'identifiant de l'instance et la zone que vous avez définis précédemment dans ce tutoriel.

  4. Depuis l'invite du Cloud Shell, créez un fichier ConfigMap à partir du fichier opentsdb-config.yaml mis à jour :

    kubectl create -f configmaps/opentsdb-config.yaml
    

Créer des tables OpenTSDB dans Cloud Bigtable

Avant de pouvoir lire ou écrire des données avec OpenTSDB, vous devez créer les tables nécessaires dans Cloud Bigtable pour stocker ces données. Procédez comme suit pour créer la tâche Kubernetes de création des tables :

  1. Lancez la tâche :

    kubectl create -f jobs/opentsdb-init.yaml
    
  2. Cette tâche peut durer une minute ou plus. Vérifiez qu'elle a abouti en exécutant régulièrement cette commande :

    kubectl describe jobs
    

    Le résultat doit indiquer qu'une tâche a abouti sous l'en-tête Pods Statuses.

  3. Exécutez les commandes suivantes pour obtenir les journaux des tâches de création de table :

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

Lorsque vous obtenez les journaux, examinez le bas du résultat, qui doit indiquer chacune des tables créées. Cette tâche exécute plusieurs commandes de création de table prenant chacune la forme suivante : create 'TABLE_NAME'. Recherchez une ligne au format 0 row(s) in 0.0000 seconds dans laquelle la durée d'exécution réelle de la commande est indiquée à la place de la valeur 0.0000.

Le résultat doit contenir une section ressemblant à ce qui suit :

create 'tsdb-uid',
  {NAME => 'id', COMPRESSION => 'NONE', BLOOMFILTER => 'ROW'},
  {NAME => 'name', COMPRESSION => 'NONE', BLOOMFILTER => 'ROW'}
0 row(s) in 1.3680 seconds

Hbase::Table - tsdb-uid

create 'tsdb',
  {NAME => 't', VERSIONS => 1, COMPRESSION => 'NONE', BLOOMFILTER => 'ROW'}
0 row(s) in 0.6570 seconds

Hbase::Table - tsdb

create 'tsdb-tree',
  {NAME => 't', VERSIONS => 1, COMPRESSION => 'NONE', BLOOMFILTER => 'ROW'}
0 row(s) in 0.2670 seconds

Hbase::Table - tsdb-tree

create 'tsdb-meta',
  {NAME => 'name', COMPRESSION => 'NONE', BLOOMFILTER => 'ROW'}
0 row(s) in 0.5850 seconds

Hbase::Table - tsdb-meta

Vous n'avez besoin d'exécuter cette tâche qu'une seule fois. Elle renvoie un message d'erreur si les tables existent déjà. Le cas échéant, vous pouvez poursuivre le tutoriel en utilisant les tables existantes.

Modèle de données

Les tables que vous venez de créer vont stocker 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 Obligatoire Élément mesuré – la clé par défaut sys.cpu.user
timestamp Obligatoire Époque de la mesure 1497561091
value Obligatoire Valeur de mesure 89,3
tags Veuillez indiquer au moins un tag. Qualifie la mesure à des fins de requêtes

hostname=www

cpu=0

env=prod

Déployer OpenTSDB

Dans la suite de ce tutoriel, vous trouverez les instructions nécessaires pour faire fonctionner l'exemple de scénario. Voici un diagramme de l'architecture que vous allez utiliser :

Diagramme de l'architecture utilisée dans ce tutoriel pour écrire, lire et visualiser des données de séries temporelles

Dans ce tutoriel, nous utilisons deux déploiements Kubernetes : un pour envoyer des métriques à OpenTSDB, et un autre pour lire les métriques à partir de ce dernier. L'utilisation de deux déploiements vise à éviter que les lectures et les écritures de longue durée 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 toutes les secondes. Afin de répartir la charge, chaque déploiement de ce tutoriel crée trois instances dupliquées des pods de lecture et d'écriture.

Créer un déploiement pour écrire les métriques

Les informations de configuration associées au déploiement d'écriture se trouvent dans le fichier opentsdb-write.yaml situé dans le dossier deployments du dépôt du tutoriel. Exécutez la commande suivante pour créer ce fichier :

kubectl create -f deployments/opentsdb-write.yaml

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

Les informations de configuration associées au déploiement de lecture se trouvent dans le fichier opentsdb-read.yaml situé dans le dossier deployments du dépôt du tutoriel. Exécutez la commande suivante pour créer ce fichier :

kubectl create -f deployments/opentsdb-read.yaml

Pour augmenter le nombre de pods tsd exécutés dans un déploiement de production, vous pouvez procéder en mode manuel ou vous servir 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 des services OpenTSDB

Afin de fournir une connectivité réseau cohérente aux déploiements, vous allez créer deux services Kubernetes. L'un de ces services écrit des métriques dans OpenTSDB, et l'autre lit ces métriques à partir de ce dernier.

Créer le service d'écriture de métriques

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 tutoriel. Exécutez la commande suivante pour créer ce service :

kubectl create -f services/opentsdb-write.yaml

Ce service est créé dans votre cluster GKE, et il est accessible aux autres services exécutés dans ce même cluster. Dans la section suivante de ce tutoriel, vous allez écrire des métriques pour ce service.

Créer le service de lecture de métriques

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 tutoriel. Exécutez la commande suivante pour créer ce service :

kubectl create -f services/opentsdb-read.yaml

É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 tutoriel s'appuie sur Heapster pour illustrer l'écriture de données. Votre déploiement Heapster collecte des données relatives à GKE et publie des métriques à partir du cluster GKE sur lequel vous exécutez OpenTSDB.

Exécutez la commande suivante pour déployer Heapster sur votre cluster :

kubectl create -f deployments/heapster.yaml

Examiner les 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 tutoriel. Les données se prêtent à différentes formes d'utilisation. Une option courante consiste à les visualiser. OpenTSDB intègre une interface de base permettant de visualiser les métriques qu'il collecte. Ce tutoriel fait appel à Grafana, une solution alternative très utilisée pour la visualisation de métriques, qui présente l'avantage d'offrir des fonctionnalités supplémentaires.

Configurer Grafana

L'exécution de Grafana dans votre cluster nécessite un processus semblable à celui dont vous vous êtes servi pour configurer OpenTSDB. Outre la création d'un fichier 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 GKE.

Procédez comme suit pour configurer Grafana :

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

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

    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=$(kubectl get pods --show-all --selector=app=grafana \
      --output=jsonpath={.items..metadata.name})
    
    kubectl port-forward $grafana 8080:3000
    
  4. Vérifiez que le transfert a abouti. Le résultat doit correspondre à ce qui suit :

    Forwarding from 127.0.0.1:8080 -> 3000
    Forwarding from [::1]:8080 -> 3000
    

Se connecter à l'interface Web de Grafana

Dans Cloud Shell, cliquez sur Aperçu Web, puis sélectionnez Prévisualiser sur le port 8080.

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 :

Exemple de visualisation via Grafana

Ce déploiement de Grafana a été personnalisé pour le présent tutoriel. 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. Un déploiement de Grafana en production appliquerait les mécanismes d'authentification appropriés et utiliserait des graphiques de séries temporelles plus riches.

Effectuer un nettoyage

Pour éviter que les ressources utilisées dans ce tutoriel soient facturées sur votre compte Google Cloud Platform :

  1. Supprimez le cluster GKE pour éliminer tous les artefacts précédemment créés via la commande kubectl create :

    gcloud container clusters delete opentsdb-cluster
    

    Pour supprimer le cluster GKE, confirmez votre choix en saisissant Y ou en appuyant sur Entrée.

  2. Pour supprimer le cluster Cloud Bigtable, cliquez sur Produits et services dans la console Google Cloud Platform. Cliquez sur Bigtable, sélectionnez le cluster que vous avez créé précédemment et cliquez sur Supprimer.

Étapes suivantes

  • Pour découvrir comment gagner en performances lorsque vous utilisez OpenTSDB, consultez la page Conception de schémas Cloud Bigtable pour les données de séries temporelles.

  • Regardez la vidéo Cloud Bigtable in Action (Démonstration de Cloud Bigtable) de la conférence Google Cloud Next '17. Cette vidéo est consacrée à la promotion de champ ainsi qu'à d'autres considérations relatives aux performances.

  • Consultez la documentation sur les champs d'application de cluster associés aux clusters GKE. Vous y trouverez la description des champs d'application par défaut, comme celui qui correspond à Cloud Storage, et des champs d'application que vous pouvez ajouter pour d'autres services Google.

  • Testez d'autres fonctionnalités de Google Cloud Platform. Découvrez nos tutoriels.