Le monitoring Prometheus est en train de devenir l’un des outils de monitoring Docker et Kubernetes indispensables. Ce guide vous expliquera comment mettre en œuvre un monitoring Kubernetes avec Prometheus. Vous apprendrez à déployer le serveur Prometheus, les exportateurs de métriques, la configuration de métriques kube-state-metric, l'extraction, la récupération et la collecte de métriques, la configuration des alertes avec Alertmanager et des tableaux de bord avec Grafana. Nous expliquerons comment le faire manuellement et en exploitant certaines des méthodes de déploiement/installation automatisées tels que les opérateurs Prometheus.

Pourquoi utiliser Prometheus pour la surveillance de Kubernetes ?

Deux évolutions technologiques ont nécessité un nouveau cadre de surveillance:

Culture DevOps:

Avant l’émergence de DevOps, la surveillance comprenait des hôtes, des réseaux et des services. Désormais, les développeurs ont besoin de la capacité d’intégrer facilement des mesures relatives aux applications et aux entreprises en tant que partie intégrante de l’infrastructure, car ils participent davantage au pipeline CI/CD et peuvent effectuer eux-mêmes de nombreuses opérations de débuguage. Le suivi devait être démocratisé, rendu plus accessible et couvrir d'autres couches de la stack.

Containers et Kubernetes:

les infrastructures basées sur des conteneurs modifient radicalement nos méthodes de journalisation, de débuguage, de haute disponibilité… et la surveillance ne fait pas exception. Vous avez maintenant un grand nombre d’entités logicielles volatiles, de services, d’adresses de réseau virtuel, de métriques exposées qui apparaissent ou disparaissent soudainement. Les outils de surveillance traditionnels ne sont pas conçus pour gérer cela.

Pourquoi Prometheus est-il le bon outil pour les environnements conteneurisés?

Modèle de données multidimensionnel:

le modèle est basé sur des paires clé-valeur, similaires à la manière dont Kubernetes organise les métadonnées d'infrastructure à l'aide d'étiquettes. Il permet des séries de données temporelles flexibles et précises, alimentant son langage de requête Prometheus.

Format et protocoles accessibles:

Exposer les métriques Prometheus est une tâche assez simple. Les métriques sont lisibles par l'homme, dans un format qui se passe d'explications et sont publiées à l'aide d'un transport HTTP standard. Vous pouvez vérifier que les métriques sont correctement exposées en utilisant simplement votre navigateur Web:

Découverte de services:

le serveur Prometheus est chargé de supprimer périodiquement les cibles afin que les applications et les services n’aient pas à s’inquiéter de l’émission de données (les métriques sont extraites, et non poussées). Ces serveurs Prometheus disposent de plusieurs méthodes pour détecter automatiquement les cibles de scrap, certaines pouvant être configurées pour filtrer et faire correspondre les métadonnées de conteneur, ce qui en fait un excellent choix pour les charges de travail éphémères Kubernetes.

Composants modulaires et hautement disponibles:

La collecte de mesures métriques, les alertes, la visualisation graphique, etc., sont effectuées par différents services composables. Tous ces services sont conçus pour prendre en charge la redondance et le sharding.

Surveillance de nouvelles couches d'infrastructure: composants Kubernetes

L'utilisation de concepts Kubernetes tels que l'hôte physique ou le port de service devient moins pertinente. Vous devez organiser la surveillance autour de différents groupes tels que les performances de microservice (avec différents pods dispersés autour de plusieurs nœuds), les espaces de noms, les versions de déploiement, etc. En utilisant le modèle de données à base d'étiquettes de Prometheus avec PromQL, vous pouvez facilement vous adapter à ces nouvelles étendues.  

Surveillance Kubernetes avec Prometheus:

Vue d'ensemble de l'architecture

1 - Les serveurs Prometheus ont besoin d’un maximum de reconnaissance automatique de la cible. Il y a plusieurs options pour y parvenir: Consul Prometheus Kubernetes SD plugin L'opérateur Prometheus et ses définitions de ressources personnalisées

2 - Outre les métriques d'application, nous souhaitons que Prometheus collecte les métriques relatives aux services Kubernetes, aux nœuds et au statut d'orchestration. Exportateur de nœud, pour les métriques classiques relatives à l'hôte: cpu, mem, réseau, etc. Métriques Kube-state-pour les métriques d'orchestration et de cluster: déploiements, métriques de pods, réservation de ressources, etc. Métriques Kube-system à partir de composants internes: kubelet, etcd, dns, ordonnanceur, etc.

3 - Prometheus peut configurer des règles pour déclencher des alertes à l'aide de PromQL. AlertManager sera chargé de la gestion des notifications d'alerte, du regroupement, de l'inhibition, etc.

4 - Le composant alertmanager configure les récepteurs, les passerelles pour envoyer des notifications d’alerte.

5 - Grafana peut extraire des métriques de n’importe quel nombre de serveurs Prometheus, de panneaux d’affichage et de tableaux de bord.

Installation du cluster sur VPS Ubuntu 16.04

Bien penser à se mettre en dernière version stable et compatible Kubernetes 1.12 pour Docker et suivre le tutoriel précédent pour le reste.

root@vps450831:~# sudo apt-get install docker-ce=18.06.0~ce~3-0~ubuntu

Pour créer le SDN Weave net sur votre cluster :

gabriel@vps450831:~$ kubectl apply -f "https://cloud.weave.works/k8s/net?k8s-version=$(kubectl version | base64 | tr -d '\n')"
serviceaccount/weave-net created
clusterrole.rbac.authorization.k8s.io/weave-net created
clusterrolebinding.rbac.authorization.k8s.io/weave-net created
role.rbac.authorization.k8s.io/weave-net created
rolebinding.rbac.authorization.k8s.io/weave-net created
daemonset.extensions/weave-net created
gabriel@vps450831:~$ kubectl get all --namespace=kube-system
NAME                                    READY   STATUS    RESTARTS   AGE
pod/coredns-576cbf47c7-7mglc            1/1     Running   0          3h48m
pod/coredns-576cbf47c7-mf4dd            1/1     Running   0          3h48m
pod/etcd-vps450831                      1/1     Running   0          3h47m
pod/kube-apiserver-vps450831            1/1     Running   0          3h47m
pod/kube-controller-manager-vps450831   1/1     Running   0          3h47m
pod/kube-proxy-7cfmv                    1/1     Running   0          3h48m
pod/kube-proxy-9fjsz                    1/1     Running   0          4m42s
pod/kube-scheduler-vps450831            1/1     Running   0          3h47m
pod/weave-net-8c2mk                     2/2     Running   0          5m
pod/weave-net-fvprv                     2/2     Running   0          4m42s

NAME               TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)         AGE
service/kube-dns   ClusterIP   10.96.0.10   <none>        53/UDP,53/TCP   3h48m

NAME                        DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR   AGE
daemonset.apps/kube-proxy   2         2         2       2            2           <none>          3h48m
daemonset.apps/weave-net    2         2         2       2            2           <none>          5m

NAME                      DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/coredns   2         2         2            2           3h48m

NAME                                 DESIRED   CURRENT   READY   AGE
replicaset.apps/coredns-576cbf47c7   2         2         2       3h48m

Après cela nous allons mettre en place la solution Prometheus sur notre cluster en utilisant les fichiers que vous trouverez dans ce repository :

git clone https://github.com/gabrielsagnard/kubernetes-prometheus

Se connecter au cluster

Connectez-vous à votre cluster Kubernetes et configurez le proxy pour accéder au tableau de bord Kubernetes.  

Remarque: Si vous utilisez GKE, vous devez exécuter les commandes suivantes, car vous avez besoin de privilèges pour créer des rôles de cluster.  

ACCOUNT=$(gcloud info --format='value(config.account)')
kubectl create clusterrolebinding owner-cluster-admin-binding \
    --clusterrole cluster-admin \
    --user $ACCOUNT

Créer un namespace

Tout d'abord, nous allons créer un espace de noms Kubernetes pour tous nos composants de monitoring. Exécutez la commande suivante pour créer un nouveau namespace appelé monitoring.  

kubectl create namespace monitoring

Vous devez attribuer l’autorisation de lecture du cluster à ce namespace afin que Prometheus puisse extraire les métriques des API kubernetes.  

Placez-vous dans le dossier cloné sur votre serveur à la racine des dossiers de votre utilisateur comme ceci :

cd kubernetes-prometheus

Créez le rôle à l'aide de la commande suivante.

kubectl create -f clusterRole.yaml

Créer une Config Map

Nous devrions créer une Config Map avec toute la configuration de scrap de Prometheus qui sera montée sur le conteneur Prometheus dans /etc/prometheus en tant que fichier prometheus.yaml. Cette Config Map contient toute la configuration permettant de découvrir de manière dynamique les pods et les services exécutés dans le cluster kubernetes.  

Toujours dans le même dossier cloné sur votre serveur, exécutez la commande suivante pour créer la carte de configuration en kubernetes :

kubectl create -f config-map.yaml -n monitoring

Créer un déploiement Prometheus

Nous allons à présent créer le déploiement de l'application web Prometheus grâce au fichier prometheus-deployment.yaml.

Dans cette configuration, nous montons la ConfigMap de Prometheus en tant que fichier dans /etc/prometheus. Il utilise l'image officielle de Prometheus issue du hub de docker.

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: prometheus-deployment
  namespace: monitoring
spec:
  replicas: 1
  template:
    metadata:
      labels:
        app: prometheus-server
    spec:
      containers:
        - name: prometheus
          image: prom/prometheus:v2.1.0
          args:
            - "--config.file=/etc/prometheus/prometheus.yml"
            - "--storage.tsdb.path=/prometheus/"
          ports:
            - containerPort: 9090
          volumeMounts:
            - name: prometheus-config-volume
              mountPath: /etc/prometheus/
            - name: prometheus-storage-volume
              mountPath: /prometheus/
      volumes:
        - name: prometheus-config-volume
          configMap:
            defaultMode: 420
            name: prometheus-server-conf

        - name: prometheus-storage-volume
          emptyDir: {}

Créez un déploiement sur le namespace monitoring à l'aide du fichier ci-dessus.  

kubectl create  -f prometheus-deployment.yaml --namespace=monitoring

Vous pouvez vérifier le déploiement créé à l'aide de la commande suivante.  

kubectl get deployments --namespace=monitoring

Vous pouvez également obtenir des détails à partir du dashboard kubernetes, comme indiqué ci-dessous.

Connexion à Prometheus

Vous pouvez vous connecter à  l'interface web de Prometheus de deux manières.

  • Utilisation de la redirection de port Kubectl
  • Exposer le déploiement Prometheus en tant que service avec le NodePort ou un load balancer.

Nous allons examiner les deux options.  

Utilisation de la redirection de port Kubectl

En utilisant la redirection de port kubectl, vous pouvez accéder au pod à partir de votre station de travail en utilisant un port sélectionné sur votre hôte local.  

1. Commencez par obtenir le nom exact du pod Prometheus.

kubectl get pods --namespace=monitoring

Le résultat de la commande ressemblera à ce qui suit :

➜  kubectl get pods --namespace=monitoring
NAME                                     READY     STATUS    RESTARTS   AGE
prometheus-monitoring-3331088907-hm5n1   1/1       Running   0          5m

2. Exécutez la commande suivante avec le nom de votre pod pour accéder à Prometheus à partir du port 8080 de localhost.  

Remarque: remplacez prometheus-monitoring-3331088907-hm5n1 par le nom de votre pod.

kubectl port-forward prometheus-monitoring-3331088907-hm5n1 8080:9090 -n monitoring

Maintenant, si vous accédez à http://localhost:8080 sur votre navigateur, vous obtiendrez la page d'accueil de Prometheus.

Exposer Prometheus en tant que service

Pour accéder au tableau de bord Prometheus via une adresse IP ou un nom DNS, vous devez l'exposer en tant que service kubernetes.  

1. Créez le fichier prometheus-service.yaml  via la commande suivante :

kubectl create -f prometheus-service.yaml --namespace=monitoring

Nous exposerons Prometheus sur tous les IP du nœud Kubernetes sur le port 30000.

apiVersion: v1
kind: Service
metadata:
  name: prometheus-service
spec:
  selector: 
    app: prometheus-server
  type: NodePort
  ports:
    - port: 8080
      targetPort: 9090 
      nodePort: 30000

Remarque: Si vous êtes sur AWS ou Google Cloud, vous pouvez utiliser le type Loadbalancer, qui créera un équilibreur de charge et le dirigera vers le service automatiquement.

2. Une fois créé, vous pouvez accéder au tableau de bord Prometheus à l'aide de l'adresse IP du nœud Kubernetes sur le port 30000. Si vous êtes sur le cloud, assurez-vous de disposer des règles de pare-feu appropriées pour accéder aux applications.

3. Maintenant, si vous allez à status -> Targets, vous verrez automatiquement tous les noeuds finaux Kubernetes connectés à Prometheus à l'aide de la découverte de services, comme indiqué ci-dessous. Vous obtiendrez ainsi toutes les métriques de conteneur et de nœud kubernetes dans Prometheus.

4. Vous pouvez aller sur la page d'accueil et sélectionner les mesures dont vous avez besoin dans la liste déroulante pour obtenir le graphique correspondant à la plage de temps que vous mentionnez. Un exemple de graphique d'utilisation de la mémoire du conteneur est présenté ci-dessous.

Exportateurs Prometheus ; Surveillance des applications à l'aide des exportateurs Prometheus

Il est probable que de nombreuses applications que vous souhaitez déployer dans votre cluster Kubernetes n’exposent pas les métriques Prometheus prêtes à l’emploi. Dans ce cas, vous devez regrouper un exportateur Prometheus, un processus supplémentaire capable d'extraire les formats d'état/journaux/autres métriques du service principal et d'exposer ces informations en tant que métriques Prometheus. En d'autres termes, un adaptateur Prometheus.  

Vous pouvez déployer un pod contenant le serveur Redis et un conteneur Prometheus sidecar à l'aide de la commande suivante:

# Clone the repo if you don't have it already
git clone https://github.com/gabrielsagnard/prometheus-monitoring-guide
kubectl create -f prometheus-monitoring-guide/redis_prometheus_exporter.yaml

Si vous affichez le redis pod, vous remarquerez qu'il contient deux conteneurs:

gabriel@vps450831:~$ kubectl get pods
NAME                   READY   STATUS    RESTARTS   AGE
redis-cf766cf8-q5nwd   2/2     Running   0          14s

Pour obtenir toutes les métriques de service redis:

Comment monitorer les applications Kubernetes avec Prometheus.

Surveillance du cluster Kubernetes avec Prometheus et les métriques kube-state-state

Outre la surveillance des services déployés dans le cluster, vous souhaitez également surveiller le cluster Kubernetes lui-même. Les trois aspects de la surveillance des groupes à prendre en compte sont les suivants:  

  • Les hôtes (noeuds) Kubernetes - métriques sysadmin classiques telles que cpu, charge, disque, mémoire, etc.
  • Mesures de niveau d'orchestration: état de déploiement, demandes de ressources, planification et latence du serveur api, etc.
  • Composants internes du système kube - Mesures de service détaillées pour le planificateur, le gestionnaire de contrôleur, le service DNS, etc.

L'architecture de monitoring interne de Kubernetes a récemment subi des modifications que nous allons essayer de résumer ici. Pour plus d'informations, vous pouvez consulter le schéma conceptuel d'infrastructure.

Monitoring des composants Kubernetes sur une stack Prometheus

Heapster: Heapster est un agrégateur de données de monitoring et d'événement à l'échelle du cluster qui s'exécute en tant que pod dans le cluster.

Outre les points de terminaison Kubelets/cAdvisor, vous pouvez ajouter des sources de métriques supplémentaires à Heapster, telles que les métriques kube-state-metrics (voir ci-dessous).

Heapster est maintenant DEPRECATED, son remplacement est le serveur de métriques.

cAdvisor: cAdvisor est un agent d'analyse des performances et de l'utilisation des ressources en conteneur open source. Il est spécialement conçu pour les conteneurs et prend en charge les conteneurs Docker de manière native. Dans Kubernetes, cAdvisor s'exécute dans le cadre du fichier binaire Kubelet. Tout agrégateur récupérant les métriques de nœud local et Docker scrape directement les points finaux de Kubelet Prometheus.

Kube-state-metrics: kube-state-metrics est un service simple qui écoute le serveur d'API Kubernetes et génère des métriques sur l'état des objets, tels que les déploiements, les nœuds et les pods. Il est important de noter que la métrique kube-state-metric est simplement un point de terminaison de métriques, une autre entité doit la parcourir et fournir un stockage à long terme (c'est-à-dire le serveur Prometheus).  

Metrics-server: Metrics Server est un agrégateur de données d'utilisation des ressources à l'échelle du cluster. Il est destiné à être le remplaçant par défaut de Heapster. Encore une fois, le serveur de mesures ne présentera que les derniers points de données et n’est pas responsable du stockage à long terme.  

Ainsi:  

  • Les métriques d'état Kube sont axées sur les métadonnées d'orchestration: déploiement, pod, statut de réplique, etc.
  • Metrics-server se concentre sur l'implémentation de l'API des métriques de ressources: CPU, descripteurs de fichier, mémoire, latences des requêtes, etc.

Surveillance des noeuds Kubernetes avec Prometheus

Les nœuds ou les hôtes Kubernetes doivent être surveillés. Nous disposons de nombreux outils pour surveiller un hôte Linux. Dans ce guide, nous allons utiliser le Prometheus node exporter:  

  • Il est hébergé par le projet Prometheus lui-même
  • Il est celui qui sera déployé automatiquement lorsque nous utiliserons l'opérateur Prometheus dans les prochains chapitres
  • Il peut être déployé en tant que DaemonSet et, par conséquent il sera automatiquement mis à l'échelle si vous ajoutez ou supprimez des nœuds de votre cluster.

Utilisons Helm/Tiller:  Si vous souhaitez utiliser Helm, n'oubliez pas de créer les rôles RBAC et les comptes de service pour le composant Tiller avant de poursuivre.

(Petit rappel sur l'installation d'Helm dans cet article).

helm init –service-account tiller 
helm install –name node-exporter stable/prometheus-node-exporter 

Once the chart is installed and running, you can display the service that you need to scrape:

gabriel@vps450831:~$ kubectl get svc
NAME                                     TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)             AGE
kubernetes                               ClusterIP   10.96.0.1       <none>        443/TCP             4d
node-exporter-prometheus-node-exporter   ClusterIP   10.105.2.109    <none>        9100/TCP            2d20h

Installer Grafana

Vous pouvez à nouveau lister les namespaces en lançant la commande :

kubectl get namespaces

et vous devriez voir quelque chose de similaire à:  

NAME          STATUS    AGE
default       Active    1h
kube-system   Active    1h
monitoring    Active    1h

Vous pouvez déployer Grafana en créant le déploiement et le service qui va de pair, en exécutant :

 kubectl create -f grafana-deployment.yaml  
kubectl create -f grafana-service.yaml. 

Vous pouvez ensuite checker en lançant  :

kubectl get services --namespace= monitoring grafana -o yaml  

IMPORTANT : Les fichiers sont disponibles ici.

N'hésitez pas à explorer Grafana via la ligne de commande kubectl et/ou le dashboard.

Le nom d'utilisateur par défaut est admin et le mot de passe est aussi admin (à changer à la première connexion).

Commençons par ajouter Prometheus en tant que Source Data.  

Cliquez sur l'icône en haut à gauche de Grafana et allez à «Sources Data».

Cliquez sur «Ajouter une Source Data».

Pour le nom, utilisez simplement “Prometheus” Sélectionnez "Prometheus" comme type.

Pour l'URL, nous utiliserons l'adresse IP du Cluster maître Kubernetes et le port d'écoute de Prometheus. Donc, entrez http://ipduserveur:9090.

Créez un nouveau tableau de bord en cliquant sur l'icône en haut à gauche et en sélectionnant Tableau de bord-> Nouveau.  Téléchargez le fichier du tableau de bord à partir du site de Grafana. En voici un exemple trouvé ici et déjà très bien réalisé, et un second pour Redis.

Pour Redis :

Et un dernier pour la route dispo ici :

Conclusion :

La première partie de ce guide explique les bases du service Prometheus, son intégration avec l'orchestrateur Kubernetes et différents microservices que vous pouvez trouver sur un déploiement typique à l'échelle du cloud. Avec cette discussion sur l'ajout d'alertes, de tableaux de bord et d'un stockage à long terme au-dessus du serveur principal Prometheus, ici dans la partie 2, nous nous rapprochons beaucoup d'une solution de monitoring viable.  

Dans l'article suivant, nous expliquerons comment procéder pour déployer un cluster K8s dans le cloud cette fois-ci et non plus sur un VPS ainsi qu'une stack et la solution de monitoring qui va de pair.

Bibliographie :