Prometheus

Prometheus est un programme open source permettant de surveiller et d’alerter sur des métriques. Il est souvent utilisé pour monitorer des applications et des serveurs. Il est écrit en Go et est très performant. Ce projet permet aussi de stocker les données de monitoring dans une base de données. Ou de faire de l’écriture distribuée. Il est généralement utilisé avec Grafana pour la visualisation des données.

Schéma de fonctionnement

Installation de Prometheus

Création de la configuration kubernetes

Il faut créer un volume persistant pour prometheus pour stocker les métriques.

Il aurait été intéressant de mettre en place un système de stockage distribué pour les métriques de Prometheus. Mais nous n’avons pas eu le temps de le faire. Cela aurait permis de pouvoir stocker les metrics de manière distribuée et de pouvoir les répliquer. Et de rajouter des nœuds de stockage si besoin. Pour garder plus longtemps les metrics. Et en plus cela aurait permis d’avoir un Prometheus plus performant et hautement disponible.

pvc-prometheus.yaml

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: prometheus-pvc
  namespace: monitoring # Namespace ou il y a toute la stack de monitoring
spec:
  accessModes:
    - ReadWriteOnce # Seul un pod peut écrire dans le volume
  resources:
    requests:
      storage: 20Gi # Demande du stockage à la PVC class manager ( longhorn )

Ensuite, il faut déclarer les RBAC (Role-based access control) afin que Prometheus puisse avoir accès à l’API de kubernetes et découvrir les services qui émettent des métriques.

rbac-prometheus.yaml

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: prometheus
rules:
  - apiGroups: [ "" ]
    # Ressource autorisée
    resources:
      - nodes
      - nodes/proxy
      - services
      - endpoints
      - pods
    verbs: [ "get", "list", "watch" ]
  - apiGroups:
      - extensions
    resources:
      - ingresses
    verbs: [ "get", "list", "watch" ]
  - nonResourceURLs: [ "/metrics" ]
    verbs: [ "get" ]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: prometheus
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: prometheus
subjects:
  - kind: ServiceAccount
    name: default
    namespace: monitoring

Création de la configmap qui nous permettra de pouvoir stocker la configuration de Prometheus.

config-map.yaml

apiVersion: v1
kind: ConfigMap
metadata:
  name: prometheus-server-conf
  namespace: monitoring
data:
  prometheus.yml: |
    global:
      scrape_interval: 15s
      evaluation_interval: 15s
    scrape_configs:
      - job_name: 'prometheus'
        static_configs:
          - targets: ['localhost:9090']
      - job_name: 'node-exporter'
        kubernetes_sd_configs:
          - role: endpoints
        relabel_configs:
        - source_labels: [__meta_kubernetes_endpoints_name]
          regex: 'node-exporter'
          action: keep

Dans la configuration de prometheus, nous précisions le Kubernetes-sd (Kubernetes Service Discovery) ce qui permet à Prometheus de découvrir lui-même les nouvelles IP où se trouve les metrics pour le node exporter. Cela est possible grâce à la configuration du RBAC mentionné plus tôt.

Il est aurait dû être ajouté le Prometheus service discovery pour Netbox. Mais nous n’avons pas eu le temps de le faire. Cela aurait permis pour toutes les VM ajoutés dans Netbox avec un tag monitoring d’être surveillé par Prometheus. Grâce à Xen Orchestra, il est possible de faire des requêtes sur l’api de Netbox pour récupérer les IP des machines et les ajouter dans le service discovery de Prometheus.

Création de déploiement

deployement.yaml


apiVersion: apps/v1
kind: Deployment
metadata:
  name: prometheus-server
  namespace: monitoring
spec:
  replicas: 3
  selector:
    matchLabels:
      app: prometheus-server
  template:
    metadata:
      labels:
        app: prometheus-server
    spec:
      containers:
        - name: prometheus
          image: prom/prometheus
          ports:
            - containerPort: 9090
              name: http-prometheus
              protocol: TCP
          volumeMounts:
            - name: config-volume
              mountPath: /etc/prometheus
            - mountPath: /prometheus
              name: prometheus-pv
      volumes:
        - name: config-volume
          configMap:
            name: prometheus-server-conf
            defaultMode: 420
        - name: prometheus-pv
          persistenVolumeClaim:
            claimnName: prometheus-pvc

Dans notre déploiement, on précise le montage du volume dans le pvc afin de pouvoir écrire les metrics de manière persistante. Ensuite, on précise l’image docker de prometheus avec une version pour controller les mises à jour. On ouvre le port 9090 en TCP du conteneur dans le but de créer le service plus tard pour avoir accès. Ensuite, il faut préciser le volume de la configmap pour mettre le fichier de configuration qui était écrit plus tôt.

apiVersion: v1
kind: Service
metadata:
  name: prometheus
  namespace: monitoring
spec:
  ports:
    - port: 9090
      protocol: TCP
      targetPort: http-prometheus
  selector:
    app: prometheus-server
  sessionAffinity: None
  type: LoadBalancer

Configuration

Ensuite, on crée le service pour prometheus, il est configuré en mode “LoadBalancer”, afin d’ouvrir les ports sur tous les nœuds. Pour que loadbalancer puissent faire du round robin sur tous les nœuds.

Une fois cela fait, il faut rajouter la datasource dans grafana.

Pour rajouter la datasource.

Il faut d’abord se rendre dans data source

Ensuite, il faut ajouter une datasource

Puis saisir un nom pour la datasource, nous avons choisi Prometheus car il n’y a pas d’autres datasource prometheus

Et pour la connexion, il faut mettre le nom de service créé précédemment. Le nom du service permettra de résoudre l’IP d’un pods qui héberge prometheus.

Ensuite cliquer sur save and test

Si tout a bien fonctionné, vous devriez voir ce message

Une fois cela fait, il est possible de pouvoir explorer les metrics reporter par prometheus. Dans l’onglet explore de Grafana

Il est possible de confirmer que notre prometheus arrive à fonctionner correctement. Et qu’il est bien joignable par Grafana

Administration de prometheus

Pour des raisons de sécurité, nous ne ferons pas d’ingress pour prometheus mais s’il est nécessaire d’y avoir accès, nous ferons des port-forwarding avec kubectl sur le service directement.

Pour faire un port forwarding il faut utiliser kubectl.

kubectl port-forward -n monitoring service/prometheus 9090:9090

Cette commande va créer un port forward dans le namespace monitoring puis rediriger le port 9090:9090 du service prometheus qui a été défini plus tôt dans la configuration du service de prometheus

Si cela fonctionne le retour de la commande devrait être similaire à ceci:

Et donc si dans votre navigateur vous essayer d’accéder à l’url http://localhost:9090, le navigateur doit renvoyer la page d’administration de prometheus

Dans l’onglet target, il sera possible de voir si prometheus arrive à découvrir automatiquement les pods ou non. Et s’il y a des ip auxquels il n’arrive pas à accéder correctement.

Et dans l’onglet configuration, il sera possible de vérifier que la config map à correctement été appliqué