Surveillance Docker avec Prometheus, cAdvisor, Node Exporter et Grafana

Administration système Linux, Virtualisation et informatique en nuage

Introduction

À mesure que les entreprises adoptent des conteneurs Docker pour améliorer l’efficacité et la rapidité du déploiement des applications, la surveillance et l’observabilité deviennent de plus en plus critiques pour l’exécution des conteneurs en production. La surveillance fournit des mesures, des journaux et des informations précieuses sur les performances des applications et de l’infrastructure. Cela permet aux équipes de dépanner les problèmes de manière proactive avant qu’ils n’aient un impact en aval, ainsi que d’optimiser l’utilisation et les dépenses consacrées aux ressources containerisées.

Dans ce guide complet, nous allons mettre en place une pile de surveillance open source intégrée pour visualiser les mesures d’hôte et de conteneur Docker à l’aide de :

Prometheus : une base de données de séries temporelles open source populaire pour le stockage et l’interrogation de mesures numériques
cAdvisor : un utilitaire qui collecte les données d’utilisation des ressources et de performances des conteneurs en cours d’exécution
Node Exporter : expose les mesures matérielles et OS des serveurs physiques et virtuels Docker
Grafana : tableaux de bord et graphiques riches en fonctionnalités pour l’analyse et la visualisation

Collectivement, ces outils fournissent une observabilité de bout en bout dans les environnements containerisés, de l’infrastructure physique aux applications en cours d’exécution. Nous allons les déployer avec Docker et configurer l’ingestion de mesures, le stockage, l’interrogation et le tableau de bord pour comprendre exactement comment les conteneurs utilisent les ressources hôtes au fil du temps.

Pourquoi surveiller les conteneurs et les hôtes ?

Tout d’abord, pourquoi la surveillance est-elle si importante pour l’infrastructure de conteneurs ?

Au fur et à mesure que les applications sont empaquetées dans des conteneurs portables et isolés, elles se répartissent sur des pools de plus en plus fluides d’hôtes containerisés virtuels comme des nœuds dans un cluster.

Cette architecture éphémère introduit des défis de visibilité, notamment :

Comprendre comment les conteneurs utilisent les ressources physiques comme le CPU, la mémoire, le disque et le réseau
Cartographier quels conteneurs s’exécutent sur quels hôtes au fil du temps
Mettre en corrélation les performances des applications avec des mesures de ressources de plus bas niveau
Identifier les tendances et les pics d’utilisation pour éviter la surutilisation
Régler les configurations et les placements de conteneurs en fonction du comportement
Établir des alertes pour détecter les anomalies ou les problèmes

Bien que la containerisation apporte des avantages architecturaux grâce à un couplage lâche et à la portabilité, l’environnement devient de plus en plus complexe d’un point de vue opérationnel.

En collectant, stockant et traçant des mesures de séries temporelles détaillées, nous regagnons de la visibilité, notamment :

Surveillance des ressources en temps réel avec ventilation par hôte, conteneur, espace de noms
Analyse des tendances historiques pour la planification des capacités et l’optimisation
Alertes basées sur des mesures lorsque des seuils sont dépassés
Corrélation entre les temps de réponse des applications et les caractéristiques de plus bas niveau
Tableaux de bord pour comprendre l’infrastructure d’un seul coup d’œil

Comprendre exactement comment les applications consomment les ressources permet une exploitation plus efficace, des réponses automatisées et aide à prévenir l’instabilité due à la surutilisation ou aux goulets d’étranglement des ressources.

Conditions préalables

Pour suivre toutes les composantes, vous aurez besoin de :

Un serveur Linux exécutant Docker avec la dernière version de Docker Compose
Autorisation du démon Docker pour l’écriture de mesures à partir des exportateurs
Ports 9090, 9100 et 3000 accessibles depuis les outils de surveillance
Connaissances de base en administration Linux et Docker

Pour plus de commodité, nous utiliserons un système Ubuntu 20.04. Mais toute distribution Linux moderne devrait bien fonctionner.

Explorons maintenant comment connecter l’ingestion de mesures Prometheus et les tableaux de bord visualisés pour les environnements de conteneurs !

Étape 1 – Créer un réseau Docker isolé pour la surveillance

Tout d’abord, créez un réseau pont défini par l’utilisateur pour la communication entre les services de surveillance en utilisant :

$ docker network create monitoring-net

Cela permet d’exposer les services sur des noms d’hôtes cohérents au lieu d’adresses IP dynamiques qui peuvent changer :

prometheus  
grafana
cadvisor
node-exporter

Maintenant, exécutez chaque service connecté à ce réseau pour une connectivité simplifiée.

Étape 2 – Configurer la base de données de séries temporelles Prometheus

Prometheus est une base de données de séries temporelles spécialisée optimisée pour ingérer et interroger des mesures numériques comme des compteurs, des jauges et des histogrammes même à grande échelle ou à forte cardinalité. Il récupère et stocke des mesures numériques à des intervalles réguliers au fil du temps.

Prometheus s’exécute bien dans des conteneurs et s’intègre aux environnements Docker à l’aide d’exportateurs fournissant des mesures sur les conteneurs, les images, les volumes, etc.

Tirez l’image du serveur Prometheus le plus récent :

$ docker pull prom/prometheus:latest

Ensuite, créez un répertoire pour la persistance entre les redémarrages du conteneur :

$ mkdir -p /prometheus-data

Nous devons définir un fichier de configuration Prometheus pour découvrir ce qu’il faut surveiller. Créez-le dans /prometheus-data/prometheus.yml sur votre hôte avec les définitions de tâches initiales :

global:
  scrape_interval: 10s
  external_labels:
    monitor: production-01
scrape_configs:
  - job_name: 'prometheus'
    scrape_interval: 5s
    static_configs:
      - targets: ['localhost:9090']
  - job_name: 'cadvisor'
    scrape_interval: 5s
    static_configs:
      - targets: ['cadvisor:8080']
  - job_name: 'node'
    scrape_interval: 5s 
    static_configs:
      - targets: ['node-exporter:9100']

Cela configure la connectivité à :

Métriques auto-Prometheus sur le port 9090
cAdvisor exposant les mesures de conteneur sur 8080
Node Exporter pour les mesures du système d’exploitation hôte sur 9100

Nous définirons ces services ensuite.

Enfin, exécutez le serveur Prometheus en mode détaché :

$ docker run -d --name=prometheus \
    --network=monitoring-net \ 
    -p 9090:9090 \
    -v=/prometheus-data:/prometheus-data \
    prom/prometheus:latest \ 
    --config.file=/prometheus-data/prometheus.yml

Cela lance Prometheus connecté au réseau de surveillance, charge le fichier de configuration et le volume persistant.

Vous pouvez accéder à l’interface utilisateur Prometheus sur http://<server-ip>:9090. Nous intégrerons Grafana sous peu pour les tableaux de bord.

Étape 3 – Installer cAdvisor pour les mesures de conteneur

cAdvisor (Container Advisor) est un utilitaire permettant de collecter, d’agréger, de traiter et d’exporter des mesures de performances et d’utilisation des ressources à partir de conteneurs en cours d’exécution.

Par exemple, cAdvisor expose des statistiques d’utilisation du CPU, de la mémoire, du système de fichiers et du réseau par conteneur. Cela permet de comprendre combien de ressources les conteneurs utilisent par rapport à leurs machines hôtes au fil du temps.

cAdvisor s’exécute en tant que daemonset sur chaque nœud d’un cluster pour surveiller l’utilisation des ressources. Ici, nous l’exécuterons en standalone avec Docker.

Tirez l’image cAdvisor la plus récente :

$ docker pull gcr.io/cadvisor/cadvisor:latest

Lancez ensuite l’agent cAdvisor sous forme de conteneur :

$ docker run \
  --name=cadvisor \ 
  --network=monitoring-net \
  --volume=/:/rootfs:ro \
  --volume=/var/run:/var/run:rw \
  --volume=/sys:/sys:ro \ 
  --volume=/var/lib/docker/:/var/lib/docker:ro \
  --publish=8080:8080 \ 
  --detach=true \
  gcr.io/cadvisor/cadvisor:latest

Cela exécute cAdvisor avec accès à :

Système de fichiers hôte pour collecter l’utilisation du stockage par conteneur dans /
Socket Docker pour collecter des mesures détaillées sur les conteneurs en cours d’exécution
Informations hôte comme le processeur/la mémoire via /sys

cAdvisor récupère ces sources et expose des mesures agrégées sur le port 8080.

Prometheus découvrira automatiquement les mesures cAdvisor sur notre réseau de surveillance.

Étape 4 – Installation de Node Exporter sur les hôtes Docker

Alors que cAdvisor expose des mesures sur les conteneurs en cours d’exécution, Node Exporter collecte les mesures du système d’exploitation et du matériel des hôtes Docker eux-mêmes, telles que l’utilisation du processeur, de la mémoire, du disque, du réseau, des services systemd, etc.

Cela révèle les problèmes de performances et de saturation qui pourraient avoir un impact sur les applications comme le système d’exploitation ou le matériel physique.

À l’aide de Docker, lancez node-exporter de la même manière :

$ docker run -d \
  --name=node-exporter \   
  --network=monitoring-net \
  -p 9100:9100 \   
  prom/node-exporter:latest

Cela expose les mesures d’hôte sur le port 9100. Prometheus les découvrira pour les scraper dans des mesures comme :

node_cpu_seconds_total {mode="idle"}
node_memory_MemAvailable_bytes
node_network_transmit_bytes_total

Nous disposons maintenant de 2 pipelines envoyant des mesures système et conteneur dans Prometheus.

Étape 5 – Installer Grafana pour une belle visualisation des données

Les nombres bruts de mesures dans Prometheus peuvent être difficiles à interpréter dans l’interface CLI ou UI. Pour une meilleure analyse, Grafana fournit des tableaux de bord de données flexibles avec des graphiques, des jauges et des ventilations mélangeant plusieurs mesures.

Tirez et exécutez l’image Grafana officielle :

$ docker run -d \
  --name=grafana \  
  -p 3000:3000 \    
  --network=monitoring-net \ 
  grafana/grafana:latest

Cela exécute Grafana connecté à nos services de surveillance sur le port 3000.

Accédez à http://<server-ip>:3000 et connectez-vous à Grafana à l’aide des informations d’identification par défaut :

Nom d’utilisateur : admin
Mot de passe : admin

Configurons la source de données Prometheus ensuite…

Étape 6 – Configurer la source de données Prometheus dans Grafana

Dans le menu latéral de Grafana, cliquez sur « Configuration » puis sur « Sources de données ».

Ici, vous pouvez gérer les connexions aux bases de données de surveillance comme Prometheus, Graphite, InfluxDB, etc.

Sélectionnez « Ajouter une source de données » et définissez les champs suivants :

Nom : Prometheus
Type : Prometheus
URL : http://prometheus:9090
Accès : Proxy

Cliquez ensuite sur « Enregistrer et tester ». Grafana a maintenant accès à toutes les mesures stockées dans Prometheus !

Étape 7 – Importer des modèles de tableau de bord

Plutôt que de créer des tableaux de bord complètement from scratch, nous pouvons tirer parti de l’écosystème communautaire de tableaux de bord Grafana avec des modèles prédéfinis.

Survolez l’icône “+” dans le menu de gauche et sélectionnez « Importer ». Saisissez ensuite l’ID de tableau de bord 1860 qui gère les conteneurs, ou 893 pour la vue hôte Docker.

Grafana importe ces modèles pré-remplis avec des graphiques et des ventilations pour notre nouvelle source de données Prometheus. Personnalisez-les ou étendez-les avec des tableaux de bord plus ciblés !

Votre instance Grafana devrait maintenant disposer de tableaux de bord éclairants pour :

Mesures d’utilisation des ressources par conteneur
Statistiques de l’OS hôte, processeur, mémoire et Docker

Prometheus et Grafana fournissent désormais des pipelines de bout en bout pour les données, le stockage et la visualisation des environnements de conteneurs. Ensuite, discutons de la fonctionnalité administrative pour maintenir et mettre à l’échelle notre nouvelle pile de surveillance.

Administration des services de surveillance

Maintenant que vous avez Prometheus, Node Exporter, cAdvisor et Grafana en cours d’exécution, voici les meilleures pratiques pour les administrer sur le long terme.

Persistance de l’historique des mesures Prometheus

Par défaut, Prometheus stocke les mesures localement sur le disque, ce qui limite la capacité et la durabilité. Pour les systèmes de production, utilisez un stockage distant pour conserver l’historique plus longtemps pour une meilleure analyse des tendances et planification des capacités.

Les magasins à long terme compatibles avec Prometheus populaires incluent :

Stockage Blob Azure
AWS S3
Cloud Storage Google
Thanos

Configurez-les sous les sections remote_write: et remote_read: de prometheus.yml.

Conservation de l’historique des tableaux de bord dans Grafana

Pour conserver l’historique des tableaux de bord entre les redémarrages de Grafana, configurez une base de données comme PostgreSQL ou MySQL sous « Configuration – Sources de données – Base de données Grafana ». Synchronisez les tableaux de bord de surveillance avec le contrôle de version source pour l’historique des versions.

Limitation de la cardinalité des données

En raison du volume élevé de mesures possibles par conteneur, surveillez les explosions de « cardinalité des mesures ». Filtrez soigneusement avec le réétiquetage des mesures pour contrôler la croissance du stockage. La suppression de mesures moins précieuses peut améliorer les performances.

Partitionnement horizontal

Pour distribuer la charge à mesure que les environnements s’agrandissent, exécutez plusieurs pods Prometheus dans un StatefulSet avec des configurations de hashring ou de fédération. De même, Grafana peut être hautement disponible grâce aux contrôleurs de réplication.

Résumé

Dans ce guide, nous avons construit une pile de surveillance complète pour les hôtes Docker et les parcs de conteneurs, comprenant :

Prometheus : base de données centrale de mesures récupérant et stockant les statistiques de conteneur/hôte
cAdvisor : collecte l’utilisation des ressources des conteneurs en cours d’exécution
Node Exporter : collecte les mesures du système d’exploitation et du matériel des serveurs
Grafana : visualisation des mesures via des tableaux de bord perspicaces

Ensemble, ces outils fournissent une visibilité et des alertes de bout en bout pour détecter les anomalies dans les environnements de conteneurs dynamiques.

Maintenant que vous disposez d’une base de surveillance opérationnelle, les prochaines étapes possibles sont les suivantes :

Intégration des données de journal dans Elasticsearch pour corréler les traces avec les mesures
Construction de règles d’alerte et de webhooks dans Prometheus et Grafana
Mise à l’échelle automatique des conteneurs en fonction de l’utilisation avec Kubernetes Horizontal Pod Autoscaler
Recherche d’outils comme Weave Scope ou Lens pour mapper les conteneurs aux hôtes

Au fur et à mesure que vous déplacez les conteneurs et les microservices vers la production, j’espère que cette exploration des mesures, de la surveillance et de la visibilité vous aidera à exploiter l’infrastructure de manière fiable ! Faites-moi savoir si vous avez d’autres questions.