Comment surveiller Kubernetes avec Prometheus

Présentation

Prometheus est un framework d'instrumentation open source. Prometheus peut absorber d'énormes quantités de données chaque seconde, ce qui le rend bien adapté aux charges de travail complexes.

Utilisez Prometheus pour surveiller vos serveurs, machines virtuelles, bases de données et exploitez ces données pour analyser les performances de vos applications et de votre infrastructure.

Cet article explique comment configurer la surveillance Prometheus dans un cluster Kubernetes.

Prérequis

Un cluster Kubernetes
Un kubectl entièrement configuré interface de ligne de commande sur votre machine locale

Surveiller le cluster Kubernetes avec Prometheus

Prometheus est un système basé sur le pull. Il envoie une requête HTTP, appelée scrape , en fonction de la configuration définie dans le fichier de déploiement . La réponse à ce scrape la demande est stockée et analysée dans le stockage avec les métriques du scrap lui-même.

Le stockage est une base de données personnalisée sur le serveur Prometheus et peut gérer un afflux massif de données. Il est possible de surveiller des milliers de machines simultanément avec un seul serveur.

Les données doivent être correctement exposées et formatées pour que Prometheus puisse les collecter. Prometheus peut accéder aux données directement à partir des bibliothèques clientes de l'application ou en utilisant des exportateurs.

Exportateurs sont utilisés pour les données sur lesquelles vous n'avez pas un contrôle total (par exemple, les métriques du noyau). Un exportateur est un logiciel placé à côté de votre application. Son but est d'accepter les requêtes HTTP de Prometheus, de s'assurer que les données sont dans un format pris en charge, puis de fournir les données demandées au serveur Prometheus.

Toutes vos applications sont désormais équipées pour fournir des données à Prometheus. Nous devons encore indiquer à Prometheus où rechercher ces données. Prometheus découvre des cibles à extraire à l'aide de Service Discovery .

Votre cluster Kubernetes dispose déjà d'étiquettes et d'annotations et d'un excellent mécanisme pour suivre les modifications et l'état de ses éléments. Par conséquent, Prometheus utilise l'API Kubernetes pour découvrir les cibles.

Les découvertes de service Kubernetes que vous pouvez exposer à Prometheus sont :

nœud
point de terminaison
service
module
entrée

Prometheus récupère les métriques au niveau de la machine séparément des informations sur l'application. La seule façon d'exposer les mesures de la mémoire, de l'espace disque, de l'utilisation du processeur et de la bande passante est d'utiliser un exportateur de nœuds . De plus, les métriques sur les cgroups doivent également être exposées.

Heureusement, l'exportateur cAdvisor est déjà intégré au niveau du nœud Kubernetes et peut être facilement exposé.

Une fois que le système a collecté les données, vous pouvez y accéder en utilisant le langage de requête PromQL, les exporter vers des interfaces graphiques telles que Grafana ou les utiliser pour envoyer des alertes avec Alertmanager.

Installer Prometheus Monitoring sur Kubernetes

La surveillance Prometheus peut être installée sur un cluster Kubernetes à l'aide d'un ensemble de fichiers YAML (Yet Another Markup Language). Ces fichiers contiennent des configurations, des autorisations et des services qui permettent à Prometheus d'accéder aux ressources et d'extraire des informations en récupérant les éléments de votre cluster.

Les fichiers YAML sont facilement suivis, modifiés et peuvent être réutilisés indéfiniment. Les fichiers présentés dans ce didacticiel sont facilement et gratuitement disponibles dans des référentiels en ligne tels que GitHub.

Créer un espace de noms de surveillance

Toutes les ressources de Kubernetes sont démarrées dans un espace de noms. Sauf indication contraire, le système utilise l'espace de noms par défaut. Pour avoir un meilleur contrôle sur le processus de surveillance du cluster, nous allons spécifier un espace de noms de surveillance.

Le nom de l'espace de noms doit être une étiquette compatible avec DNS. Pour une référence facile, nous allons nommer l'espace de noms :monitoring .

Il existe deux façons de créer un espace de noms de surveillance pour récupérer des métriques à partir de l'API Kubernetes.

Option 1 :

Entrez cette commande simple dans votre interface de ligne de commande et créez la surveillance espace de noms sur votre hôte :

kubectl create namespace monitoring

Option 2 :

Créez et appliquez un fichier .yml :

apiVersion: v1
kind: Namespace
metadata:
  name: monitoring

Cette méthode est pratique car vous pouvez déployer le même fichier dans des instances futures. Appliquez le fichier à votre cluster en saisissant la commande suivante dans votre terminal de commande :

kubectl -f apply namespace monitoring.yml

Quelle que soit la méthode utilisée, répertoriez les espaces de noms existants à l'aide de cette commande :

kubectl get namespaces

Configurer le fichier de déploiement Prometheus

La section suivante contient les éléments nécessaires pour configurer avec succès le scraping Prometheus sur votre cluster Kubernetes et ses éléments.

Les sections peuvent être implémentées en tant que .yml individuel fichiers exécutés en séquence. Après avoir créé chaque fichier, il peut être appliqué en saisissant la commande suivante :

kubectl -f apply [name_of_file].yml

Dans cet exemple, tous les éléments sont placés dans un seul .yml fichier et appliqué simultanément.

Le prometheus.yml file dans notre exemple indique le kubectl pour soumettre une requête au serveur d'API Kubernetes. Le fichier contient :

Autorisations permettant à Prometheus d'accéder à tous les pods et nœuds.
La configMap de Prometheus qui définit les éléments à supprimer.
Instructions de déploiement de Prometheus.
Un service qui vous donne accès à l'interface utilisateur de Prometheus.

Rôle de cluster, compte de service et liaison de rôle de cluster

Les espaces de noms sont conçus pour limiter les autorisations des rôles par défaut si nous voulons récupérer les données à l'échelle du cluster dont nous avons besoin pour donner à Prometheus l'accès à toutes les ressources de ce cluster. Un fichier Prometheus .yml de base qui fournit un accès à l'échelle du cluster contient les éléments suivants :

1. Définir le rôle du cluster

Les verbes de chaque règle définissent les actions que le rôle peut entreprendre sur les apiGroups.

apiVersion: rbac.authorization.k8s.io/v1beta1
kind: ClusterRole
metadata:
  name: prometheus
rules:
- apiGroups: [""]
  resources:
  - nodes
  - services
  - endpoints
  - pods
  verbs: ["get", "list", "watch"]
- apiGroups:
  - extensions
  resources:
  - ingresses
  verbs: ["get", "list", "watch"]

2. Créer un compte de service

De plus, nous devons créer un compte de service pour appliquer ce rôle à :

apiVersion: v1
kind: ServiceAccount
metadata:
  name: prometheus
  namespace: monitoring

3. Appliquer le ClusterRoleBinding

Enfin, nous devons appliquer un ClusterRoleBinding . Cette action va lier le compte de service au rôle de cluster créé précédemment.

apiVersion: rbac.authorization.k8s.io/v1beta1
kind: ClusterRoleBinding
metadata:
  name: prometheus
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: prometheus
subjects:
- kind: ServiceAccount
  name: prometheus
  namespace: monitoring

En ajoutant ces ressources à notre fichier, nous avons accordé à Prometheus un accès à l'échelle du cluster à partir de la surveillance espace de noms.

Carte de configuration Prometheus

Cette section du fichier fournit des instructions pour le processus de grattage. Des instructions spécifiques pour chaque élément du cluster Kubernetes doivent être personnalisées pour correspondre à vos exigences de surveillance et à la configuration du cluster.

1. Règles de grattage globales

apiVersion: v1
data:
  prometheus.yml: |
    global:
      scrape_interval: 10s

2. Nœud de grattage

Cette découverte de service expose les nœuds qui composent votre cluster Kubernetes. Le kubelet s'exécute sur chaque nœud et constitue une source d'informations précieuses.

2.1 Grattez le kubelet

    scrape_configs:
    - job_name: 'kubelet'
      kubernetes_sd_configs:
      - role: node
      scheme: https
      tls_config:
        ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
        insecure_skip_verify: true  # Required with Minikube.

2.2 Scraper cAdvisor (informations au niveau du conteneur)

Le kubelet ne fournit que des informations sur lui-même et non sur les conteneurs. Pour recevoir des informations au niveau du conteneur, nous devons utiliser un exportateur. Le cAdvisor est déjà intégré et n'a besoin que d'un metrics_path : /metrics/cadvisor pour que Prometheus collecte les données du conteneur :

    - job_name: 'cadvisor'
      kubernetes_sd_configs:
      - role: node
      scheme: https
      tls_config:
        ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
        insecure_skip_verify: true  # Required with Minikube.
      metrics_path: /metrics/cadvisor

3. Scraper le serveur API

Utilisez le rôle de points de terminaison pour cibler chaque instance d'application. Cette section du fichier vous permet de scraper les serveurs d'API dans votre cluster Kubernetes.

    - job_name: 'k8apiserver'
      kubernetes_sd_configs:
      - role: endpoints
      scheme: https
      tls_config:
        ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
        insecure_skip_verify: true  # Required if using Minikube.
      bearer_token_file: /var/run/secrets/kubernetes.io/serviceaccount/token
      relabel_configs:
   - source_labels: [__meta_kubernetes_namespace, __meta_kubernetes_service_name, __meta_kubernetes_endpoint_port_name]
        action: keep
        regex: default;kubernetes;https

4. Grattez les pods pour les services Kubernetes (à l'exception des serveurs d'API)

Supprimez les pods qui sauvegardent tous les services Kubernetes et ignorez les métriques du serveur d'API.

- job_name: 'k8services'
      kubernetes_sd_configs:
      - role: endpoints
      relabel_configs:
      - source_labels:
          - __meta_kubernetes_namespace
          - __meta_kubernetes_service_name
        action: drop
        regex: default;kubernetes
      - source_labels:
          - __meta_kubernetes_namespace
        regex: default
        action: keep
      - source_labels: [__meta_kubernetes_service_name]
        target_label: job

5. Rôle du module

Découvrez tous les ports de pod avec les métriques de nom en utilisant le nom du conteneur comme étiquette de tâche.

- job_name: 'k8pods'
      kubernetes_sd_configs:
      - role: pod
      relabel_configs:
      - source_labels: [__meta_kubernetes_pod_container_port_name]
        regex: metrics
        action: keep
      - source_labels: [__meta_kubernetes_pod_container_name]
        target_label: job
kind: ConfigMap
metadata:
  name: prometheus-config

6. Configurer ReplicaSet

Définissez le nombre de répliques dont vous avez besoin et un modèle à appliquer à l'ensemble défini de pods.

apiVersion: apps/v1beta2
kind: Deployment
metadata:
  name: prometheus
spec:
  selector:
    matchLabels:
      app: prometheus
  replicas: 1
  template:
    metadata:
      labels:
        app: prometheus
    spec:
      serviceAccountName: prometheus
      containers:
      - name: prometheus
        image: prom/prometheus:v2.1.0
        ports:
        - containerPort: 9090
          name: default
        volumeMounts:
        - name: config-volume
          mountPath: /etc/prometheus
      volumes:
      - name: config-volume
        configMap:
         name: prometheus-config

7. Définir nodePort

Prometheus est actuellement en cours d'exécution dans le cluster. Ajout de la section suivante à notre prometheus.yml va nous donner accès aux données que Prometheus a collectées.

kind: Service
apiVersion: v1
metadata:
  name: prometheus
spec:
  selector:
    app: prometheus
  type: LoadBalancer
  ports:
  - protocol: TCP
    port: 9090
    targetPort: 9090
    nodePort: 30909

Appliquer le fichier prometheus.yml

La carte de configuration définie dans le fichier fournit des données de configuration à chaque pod du déploiement :

kubectl apply -f prometheus.yml

Utilisez l'URL du nœud individuel et le nodePort défini dans le prometheus.yml fichier pour accéder à Prometheus depuis votre navigateur. Par exemple :

http://192.153.99.106:30909

En saisissant l'URL ou l'adresse IP de votre nœud et en spécifiant le port à partir du fichier yml, vous avez réussi à accéder à Prometheus Monitoring.

Comment surveiller les métriques kube-state ? (Facultatif)

Vous êtes désormais en mesure de surveiller entièrement votre infrastructure Kubernetes, ainsi que vos instances d'application. Cependant, cela n'inclut pas les métriques sur les informations dont Kubernetes dispose sur les ressources de votre cluster.

La kube-state-metrics est un exportateur qui permet à Prometheus de récupérer également ces informations. Créez un fichier YAML pour l'exportateur kube-state-metrics :

---
apiVersion: apps/v1beta2
kind: Deployment
metadata:
  name: kube-state-metrics
spec:
  selector:
    matchLabels:
      app: kube-state-metrics
  replicas: 1
  template:
    metadata:
      labels:
        app: kube-state-metrics
    spec:
      serviceAccountName: prometheus
      containers:
      - name: kube-state-metrics
        image: quay.io/coreos/kube-state-metrics:v1.2.0
        ports:
        - containerPort: 8080
          name: monitoring
---
kind: Service
apiVersion: v1
metadata:
  name: kube-state-metrics
spec:
  selector:
    app: kube-state-metrics
  type: LoadBalancer
  ports:
  - protocol: TCP
    port: 8080
    targetPort: 8080

Appliquez le fichier en saisissant la commande suivante :

kubectl apply -f kube-state-metrics.yml

Une fois que vous avez appliqué le fichier, accédez à Prometheus en entrant l'IP/URL du nœud et le nodePort défini comme précédemment défini.