Prometheus

Serveur Prometheus

95 % Partie serveur quasiment achevée, reste à voir les alertes par SMS..

   

Prometheus LXC Alpine

Installation serveur de base

# apk update && apk upgrade
# apk add prometheus
# rc-update add prometheus default
# service prometheus start

On test en se rendant sur l'adresse http://IP_PROMETHEUS:9090 :

Facile!

(Optionnel) Securisation serveur

source autre source

Fortement conseillé si vous exposez le serveur sur Internet.

Par défaut tout circule en clair.

Ici on va uniquement sécuriser l'accès au serveur, mais il est également possible de passer par stunnel pour avoir les exportateurs qui envoient les données via Internet dans un tunnel crypté.. (certains exportateurs peuvent le gérer nativement également)

Proxy Local

On installe un proxy local pour sécuriser le flux :

# apk add nginx
# rc-update add nginx default
# service nginx start

Configuration

On crée un .htpasswd pour l'utilsateur "admin" et son mot de passe :

# apk add apache2-utils
# htpasswd -c /etc/nginx/.htpasswd admin

New password:

On prépare le cryptage (self signed) :

# apk add openssl
# mkdir -p /root/certs/prometheus/ && cd /root/certs/prometheus

# openssl req \
    -x509 \
    -newkey rsa:4096 \
    -nodes \
    -keyout prometheus.key \
    -out prometheus.crt

On configure le vhost :

---

• Alpine Linux 3.12

# vi /etc/nginx/conf.d/prometheus.conf

• Alpine Linux 3.13

# vi /etc/nginx/http.d/prometheus.conf

Voir ce lien

---

server {
        listen              9191 ssl;
        ssl_certificate     /root/certs/prometheus/prometheus.crt;
        ssl_certificate_key /root/certs/prometheus/prometheus.key;

        location / {
        auth_basic           "Prometheus";
        auth_basic_user_file /etc/nginx/.htpasswd;

        proxy_pass http://localhost:9090/;

       }
   }

# service nginx restart

On configure prometheus en rajoutant ces trois lignes :

bien respecter les empalcements.

# vi /etc/init.d/prometheus

...
command_args="--config.file=$prometheus_config_file \
       --web.listen-address="127.0.0.1:9090" \
       --web.external-url=https://127.0.0.1:9191 \
       --web.route-prefix="/" \
       --storage.tsdb.path=$prometheus_storage_path \
...

# service prometheus restart

* Caching service dependencies ... [ ok ]
* Starting prometheus ... [ ok ]

Le serveur ne doit plus être accessible via http://ip_prometheus:9090 mais le sera via https://ip_prometheus:9191 avec l'utilisateur "admin".

(Optionnel) Rétention de données

Source

Par défaut Prometheus conserve les données 15 jours, il est possible de modifier cela de plusieurs façons :

• --storage.tsdb.retention.size [EXPERIMENTAL] : Limiter la taille maximal conservée (B, KB, MB, GB, TB, PB, EB).
• --storage.tsdb.retention.time : Limiter le temps de rétention maximal.

Si vous indiquez plusieurs valeurs la première limitation atteinte fera autorité.

Il est également possible d'exporter les métriques sur une BDD distante.

Dans cette exemple nous allons modifier la rétention pour stocker jusqu'a 5Gb de données :

# vi /etc/init.d/prometheus

On remplace la ligne --storage.tsdb.retention.time=$prometheus_retention_time"

...
        --storage.tsdb.path=$prometheus_storage_path \                                                                                                                                                                                                                                                                                              
        --storage.tsdb.retention.size="5GB""                                                                                                                                                                                                                                                                                                          
command_user="prometheus:prometheus"
...

Bien noter le double "" à la fin de la ligne.

# service prometheus restart

AlerManager

Source Autre Source Autre Source Encore une

AlertManager LXC Alpine

Installation de base

# apk add alertmanager
# rc-update add alertmanager default
# service alertmanager start

Se rendre sur http://IP_SERVEUR:9093 pour vérifier le bon fonctionnement :

Liaison Prometheus/Alertmanager

Si "Prometheus" et "Alertmanager" sont sur le même serveur :

# vi /etc/prometheus/prometheus.yml

On configure prometheus en rajoutant ces trois lignes :

fichier "yml" : bien respecter les aligments / toujours utiliser de vrais espaces (pas d'espace avec tabulation)

# Alertmanager configuration
alerting:
  alertmanagers:
  - static_configs:
    - targets:
       - localhost:9093

# service prometheus restart

remplacer "localhost" par l'adresse IP du serveur abritant "Alermanager" le cas échéant.

On peut se rendre sur son serveur "Prometheus" et vérifier le bon fonctionnement :

Sécurisation

Ici configuration sur le même serveur que le Prometheus sécurisé. Nous ne reprendront pas l'installation du proxy Nginx local ou la création du mot de passe HTTP.

On prépare le cryptage :

# mkdir -p /root/certs/alertmanager/ && cd /root/certs/alertmanager

# openssl req \
    -x509 \
    -newkey rsa:4096 \
    -nodes \
    -keyout alertmanager.key \
    -out alertmanager.crt

On configure le vhost :

---

• Alpine Linux 3.12

# vi /etc/nginx/conf.d/alertmanager.conf

• Alpine Linux 3.13

# vi /etc/nginx/http.d/alertmanager.conf

Voir ce lien

---

server {
        listen              9193 ssl;
        ssl_certificate     /root/certs/alertmanager/alertmanager.crt;
        ssl_certificate_key /root/certs/alertmanager/alertmanager.key;

        location / {
        auth_basic           "alertmanager";
        auth_basic_user_file /etc/nginx/.htpasswd;

        proxy_pass http://localhost:9093/;

       }
   }

# service nginx restart

On configure AlertManager :

# vi /etc/init.d/alertmanager

On ajoute les lignes suivantes :

...
command_args="--config.file=$alertmanager_config_file \
        --storage.path=$alertmanager_storage_path \
        --web.listen-address="127.0.0.1:9093" \
        --web.external-url=https://127.0.0.1:9193 \
        --web.route-prefix="/" \
        $alertmanager_args"         
command_user="prometheus:prometheus"
...

# service alertmanager restart

Le serveur ne doit plus être accessible via http://ip_alertmanager:9093 mais le sera via https://ip_alertmanager:9193 avec l'utilisateur "admin".

Liaison sécurisé Prometheus/Alertmanager

Installation sur le même serveur

Auncunes modifications nécessaire.

Alertmanager sécurisé distant

Source

On configure "Prometheus" :

Prometheus:/# vi /etc/prometheus/prometheus.yml

fichier "yml" : bien respecter les aligments / toujours utiliser de vrais espaces (pas d'espace avec tabulation)

...
# Alertmanager configuration
alerting:
  alertmanagers:
    - scheme: https                                                                                                                                                                                                                                                                                                                                   
   tls_config:                                                                                                                                                                                                                                                                                                                                     
     insecure_skip_verify: true                                                                                                                                                                                                                                                                                                                    
   static_configs:                                                                                                                                                                                                                                                                                                                                 
    - targets:                                                                                                                                                                                                                                                                                                                                     
      - IP_ALERTMANAGER:9193                                                                                                                                                                                                                                                                                                                        
   basic_auth:                                                                                                                                                                                                                                                                                                                                     
         username: admin                                                                                                                                                                                                                                                                                                                           
         password: motdepasse
...

Prometheus:/# service prometheus restart

Envoie d'alertes par courriels

Source Source officiele

Editer le fichier de configuration et remplacer la configuration par défaut :

# vi /etc/alertmanager/alertmanager.yml

Exemple avec "office365"

fichier "yml" : bien respecter les aligments / toujours utiliser de vrais espaces (pas d'espace avec tabulation)

AlertManager n'est pas compatible avec les serveurs SMTP distant non crypté. (Je n'ai pas réussit à utiliser "aspmx.l.google.com" au moment d'écrire ces lignes)

# alertmanager.yml
global:
  # The smarthost and SMTP sender used for mail notifications.
  smtp_smarthost: 'smtp.office365.com:587'
  smtp_from: 'mail365valide@exemple.net'
  smtp_auth_username: 'mail365valide@exemple.net'
  smtp_auth_password: 'supermotdepasse'
route:
  # When a new group of alerts is created by an incoming alert, wait at
  # least 'group_wait' to send the initial notification.
  # This way ensures that you get multiple alerts for the same group that start
  # firing shortly after another are batched together on the first
  # notification.
  group_wait: 10s

  # When the first notification was sent, wait 'group_interval' to send a batch
  # of new alerts that started firing for that group.
  group_interval: 30s

  # If an alert has successfully been sent, wait 'repeat_interval' to
  # resend them.
  repeat_interval: 30m

  group_by: ['alertname', 'cluster', 'service']
  # defalt receiver
  receiver: email-me

receivers:
- name: email-me
  email_configs:
  - to: 'monmaildereception@exemple.net'
    send_resolved: true

# service alertmanager restart

Il est possible d'utiliser plusieurs destinataires avec envoie suivant divers critères.

La ligne "repeat_interval" fixe le délai des mails pour une même alerte, pensez à le réduire temporairement lorsque vous testez de nouvelles alertes.

Avoir des lien des courriels d'alertes qui renvoient sur un serveur AlertManager exposé sur Internet

Pour que les courriels d'alertes d'AlertManager vous redirigent correctement :

AlertManager:/# vi /etc/init.d/alertmanager

--web.listen-address="127.0.0.1:9093" \
        --web.external-url=https://alertmanagerdns.exemple.net:3000 \
        --web.route-prefix="/" \

AlertManager:/# service alertmanager restart

Alertes

Source de nombreuses alertes Source officielle Autre source

Configuration de Prometheus

On édite Prometheus pour activer le fichier de règles "rules.yml"

Prometheus:/# vi /etc/prometheus/prometheus.yml

fichier "yml" : bien respecter les aligments / toujours utiliser de vrais espaces (pas d'espace avec tabulation)

...
# Load rules once and periodically evaluate them according to the global 'evaluation_interval'.
rule_files:
  - /etc/prometheus/rules.yml
  # - "first_rules.yml" 
  # - "second_rules.yml"
...

On recharge pour activer la nouvelle configuration :

Prometheus:/# service alertmanager restart

Exemples d'alertes

Surveillance des exportateurs de métriques

Si un exportateur ou plus est inaccessible plus de 3 minutes on envoie une alerte de niveau critique (critical)

Prometheus:/# vi /etc/prometheus/rules.yml

fichier "yml" : bien respecter les aligments / toujours utiliser de vrais espaces (pas d'espace avec tabulation)

groups:
- name: nomdugroupe
  rules:
  - alert: InstanceDown
    expr: up == 0
    for: 3m
    labels:
      severity: 'critical'
    annotations:
      summary: "Exportateur {{ $labels.instance }} inaccessible"
      description: "Un exportateur de métriques est inaccessible depuis plus de 3mn. ({{ $labels.instance }} du job: {{ $labels.job }})"

Prometheus:/# service prometheus restart

Node-Exporter

Voir installation.

Utilisation CPU

On active une alerte (niveau "warning") lorsque le CPU est utilisé à plus de 80% plus de 5 minutes.

Prometheus:/# vi /etc/prometheus/rules.yml

fichier "yml" : bien respecter les aligments / toujours utiliser de vrais espaces (pas d'espace avec tabulation)

groups:
- name: nomdugroupe
  rules:
...
  - alert: HostHighCPULoad
    expr: 100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[2m])) * 100) > 80
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "Le CPU de l'instance {{ $labels.instance }}) a depasse les 80% d'utilisation depuis plus de 5 minutes"
      description: "Le CPU est occuppe a plus de 80% ({{ $labels.instance }})"

Prometheus:/# service prometheus restart

Perfomance CPU libre pour les VM (Host CPU steal noisy neighbor)

Utile pour la virtualisation. On vérifie que l'utilsation CPU du serveur ne cannibalise pas plus de 10% des ressources processeurs pour les machine virtuelles.

Prometheus:/# vi /etc/prometheus/rules.yml

fichier "yml" : bien respecter les aligments / toujours utiliser de vrais espaces (pas d'espace avec tabulation)

groups:
- name: nomdugroupe
  rules:
...
  - alert: HostCpuStealNoisyNeighbor
    expr: avg by(instance) (rate(node_cpu_seconds_total{mode="steal"}[5m])) * 100 > 10
    for: 0m
    labels:
      severity: warning
    annotations:
      summary: Utilisation CPU hote empiete sur les perfomances VM {{ $labels.instance }})
      description: "Cannibalisation CPU > 10%. Performances des VM fortement impactees.{{ $labels.instance }}"

Prometheus:/# service prometheus restart

Mémoire RAM disponible

On envoie un avertissement lorsque la mémoire RAM disponible est inférieur à 10% (plus de 2 minutes).

Prometheus:/# vi /etc/prometheus/rules.yml

fichier "yml" : bien respecter les aligments / toujours utiliser de vrais espaces (pas d'espace avec tabulation)

groups:
- name: nomdugroupe
  rules:
...
  - alert: HostOutOfMemory
    expr: node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes * 100 < 10
    for: 2m
    labels:
      severity: warning
    annotations:
      summary: "Le serveur '{{ $labels.instance }}' arrive a court de RAM disponible"
      description: Le serveur '{{ $labels.instance }}' ({{ $labels.job }} ) dispose de moins de 10% de RAM disponible

Prometheus:/# service prometheus restart

Espace Disque

On active un avertissement ("warning") lorsque l'espace disque est inférieur à 20% et une alerte critique lorsqu'il est inférieur à 10% (plus de 2 minutes).

Prometheus:/# vi /etc/prometheus/rules.yml

fichier "yml" : bien respecter les aligments / toujours utiliser de vrais espaces (pas d'espace avec tabulation)

groups:
- name: nomdugroupe
  rules:
...
  - alert: HostOutOfDiskSpace
    expr: (node_filesystem_avail_bytes * 100) / node_filesystem_size_bytes < 20 and ON (instance, device, mountpoint) node_filesystem_readonly == 0
    for: 2m
    labels:
      severity: warning
    annotations:
      summary: "L'espace disponible de '{{ $labels.mountpoint }}' du serveur {{ $labels.instance }} ({{ $labels.job }}) est inferieur a 20%."
      description: "l'espace '{{ $labels.mountpoint }}' ({{ $labels.device }} {{ $labels.fstype }}) du serveur {{ $labels.instance }} ({{ $labels.job }}) va manquer de place, espace disponible inferieur a 20%"
  - alert: HostOutOfDiskSpaceCrit
    expr: (node_filesystem_avail_bytes * 100) / node_filesystem_size_bytes < 10 and ON (instance, device, mountpoint) node_filesystem_readonly == 0
    for: 2m
    labels:
      severity: critical
    annotations:
      summary: "L'espace disponible de '{{ $labels.mountpoint }}' du serveur {{ $labels.instance }} ({{ $labels.job }}) est inferieur a 10%."
      description: "l'espace '{{ $labels.mountpoint }}' ({{ $labels.device }} {{ $labels.fstype }}) du serveur {{ $labels.instance }} ({{ $labels.job }}) va manquer de place, espace disponible inferieur a 10%"

Prometheus:/# service prometheus restart

Latence Disque

On active deux alertes (Avertissement ou "warning") lorsque la latence d'écriture ou de lecture dépasse les 100ms

Prometheus:/# vi /etc/prometheus/rules.yml

fichier "yml" : bien respecter les aligments / toujours utiliser de vrais espaces (pas d'espace avec tabulation)

groups:
- name: nomdugroupe
  rules:
...
  - alert: HostUnusualDiskReadLatency
    expr: rate(node_disk_read_time_seconds_total[1m]) / rate(node_disk_reads_completed_total[1m]) > 0.1 and rate(node_disk_reads_completed_total[1m]) > 0
    for: 2m
    labels:
      severity: warning
    annotations:
      summary: Latence lecture disque elevee {{ $labels.instance }} '{{ $labels.device }}' ({{ $labels.job }})
      description: "Augmentation latence disque (lecture) {{ $labels.instance }} '{{ $labels.device }}' ({{ $labels.job }})"
  - alert: HostUnusualDiskWriteLatency
    expr: rate(node_disk_write_time_seconds_total[1m]) / rate(node_disk_writes_completed_total[1m]) > 0.1 and rate(node_disk_writes_completed_total[1m]) > 0
    for: 2m
    labels:
      severity: warning
    annotations:
      summary: Latence ecriture disque elevee {{ $labels.instance }} '{{ $labels.device }}' ({{ $labels.job }})
      description: "Augmentation latence disque (ecriture) {{ $labels.instance }} '{{ $labels.device }}' ({{ $labels.job }})"

Prometheus:/# service prometheus restart

Inodes Disque (index)

On active un avertissement si un point de montage à moins de 10% d'inode disponible (plus de deux minutes).

Prometheus:/# vi /etc/prometheus/rules.yml

fichier "yml" : bien respecter les aligments / toujours utiliser de vrais espaces (pas d'espace avec tabulation)

groups:
- name: nomdugroupe
  rules:
...
  - alert: HostOutOfInodes
    expr: node_filesystem_files_free / node_filesystem_files * 100 < 10 and ON (instance, device, mountpoint) node_filesystem_readonly == 0
    for: 2m
    labels:
      severity: warning
    annotations:
      summary: "Le point de montage '{{ $labels.mountpoint }}' ({{ $labels.fstype }}) sur '{{ $labels.instance }}' ({{ $labels.job }}) arrive a court d'inodes"
      description: Le point de montage '{{ $labels.mountpoint }}' ({{ $labels.fstype }} {{ $labels.device }}) sur '{{ $labels.instance }}' ({{ $labels.job }}) a moins de 10% d'inodes disponible.

Prometheus:/# service prometheus restart

Utilisation "swap" (espace d'échange)

On active une alerte lorsque que l'espace "swap" atteint les 80% de remplissage plus de deux minutes.

Prometheus:/# vi /etc/prometheus/rules.yml

fichier "yml" : bien respecter les aligments / toujours utiliser de vrais espaces (pas d'espace avec tabulation)

groups:
- name: nomdugroupe
  rules:
...
  - alert: HostSwapIsFillingUp
    expr: (1 - (node_memory_SwapFree_bytes / node_memory_SwapTotal_bytes)) * 100 > 80
    for: 2m
    labels:
      severity: warning
    annotations:
      summary: L'espace swap se remplit dangereusement sur '{{ $labels.instance }}' ({{ $labels.job }})
      description: "L'espace swap a depasse les 80% de remplissage {{ $labels.instance }} ({{ $labels.job }})"

Prometheus:/# service prometheus restart

Service systemd

On active une alerte (niveau "warning") lorsque un service de "systemd" a crashé.

Prometheus:/# vi /etc/prometheus/rules.yml

fichier "yml" : bien respecter les aligments / toujours utiliser de vrais espaces (pas d'espace avec tabulation)

groups:
- name: nomdugroupe
  rules:
...
  - alert: HostSystemdServiceCrashed
    expr: node_systemd_unit_state{state="failed"} == 1
    for: 0m
    labels:
      severity: warning
    annotations:
      summary: Le service '{{ $labels.name }}' de '{{ $labels.instance }}' ({{ $labels.job }}) a crashe
      description: "Le service '{{ $labels.name }}' de '{{ $labels.instance }}' ({{ $labels.job }}) a crashe"

Prometheus:/# service prometheus restart

Pression Mémoire

On active un avertissement lorsque la mémoire est sous forte pression plus de deux minutes.

Prometheus:/# vi /etc/prometheus/rules.yml

fichier "yml" : bien respecter les aligments / toujours utiliser de vrais espaces (pas d'espace avec tabulation)

groups:
- name: nomdugroupe
  rules:
...
  - alert: HostMemoryUnderMemoryPressure
    expr: rate(node_vmstat_pgmajfault[1m]) > 1000
    for: 2m
    labels:
      severity: warning
    annotations:
      summary: Memoire sous forte pression {{ $labels.instance }} ({{ $labels.job }})
      description: "Forte pression memoire, haut taux d'erreurs de page majeur (major page fault) {{ $labels.instance }} ({{ $labels.job }})"

Prometheus:/# service prometheus restart

Surveillance erreurs réseau

On active deux avertissements en cas d'erreur réseau en réception ou en transmission sur une interface réseau:

Prometheus:/# vi /etc/prometheus/rules.yml

fichier "yml" : bien respecter les aligments / toujours utiliser de vrais espaces (pas d'espace avec tabulation)

groups:
- name: nomdugroupe
  rules:
...
  - alert: HostNetworkReceiveErrors
    expr: rate(node_network_receive_errs_total[2m]) / rate(node_network_receive_packets_total[2m]) > 0.01
    for: 2m
    labels:
      severity: warning
    annotations:
      summary: L'interface '{{ $labels.device }}' sur {{ $labels.instance }} ({{ $labels.job }}) a rencontre des erreurs de reception
      description: "L'interface '{{ $labels.device }}' sur {{ $labels.instance }} ({{ $labels.job }}) a rencontre des erreurs de reception dans les 5 dernieres minutes"
  - alert: HostNetworkTransmitErrors
    expr: rate(node_network_transmit_errs_total[2m]) / rate(node_network_transmit_packets_total[2m]) > 0.01
    for: 2m
    labels:
      severity: warning
    annotations:
      summary: L'interface '{{ $labels.device }}' sur {{ $labels.instance }} ({{ $labels.job }}) a rencontre des erreurs de transmission
      description: "L'interface '{{ $labels.device }}' sur {{ $labels.instance }} ({{ $labels.job }}) a rencontre des erreurs de transmission dans les 5 dernieres minutes"

Prometheus:/# service prometheus restart

Alèrte alarme température

On active une alerte critique lorsque le serveur actionne une alerte de température.

Prometheus:/# vi /etc/prometheus/rules.yml

fichier "yml" : bien respecter les aligments / toujours utiliser de vrais espaces (pas d'espace avec tabulation)

groups:
- name: nomdugroupe
  rules:
...
  - alert: HostNodeOvertemperatureAlarm
    expr: node_hwmon_temp_crit_alarm_celsius * on(chip, instance, sensor) group_left(label) node_hwmon_sensor_label == 1
    for: 0m
    labels:
      severity: critical
    annotations:
      summary: DANGER Alarme surchauffe active pour '{{ $labels.label }}' sur '{{ $labels.instance }}' ({{ $labels.job }} {{ $labels.chip }})
      description: "DANGER la machine a activee une alarme de surchauffe pour '{{ $labels.label }}' sur '{{ $labels.instance }}' ({{ $labels.job }} {{ $labels.chip }})"

Prometheus:/# service prometheus restart

Alerte température

On active un avertissement lorsque la température d'un capteur atteint 90% du seuil maximum recommandé et une alarme critique lorsqu'il atteint 90% du seuil critique.

Prometheus:/# vi /etc/prometheus/rules.yml

fichier "yml" : bien respecter les aligments / toujours utiliser de vrais espaces (pas d'espace avec tabulation)

groups:
- name: nomdugroupe
  rules:
...
  - alert: HostMaxtTempWarning
    expr: node_hwmon_temp_celsius / node_hwmon_temp_max_celsius *100 * on(chip, instance, sensor) group_left(label) node_hwmon_sensor_label >= 90
    for: 0m
    labels:
      severity: warning
    annotations:
      summary: "Un composant monte en temperature. '{{ $labels.label }}' ({{ $labels.instance }} {{ $labels.job }})."
      description: "le capteur '{{ $labels.label }}' ({{ $labels.sensor }}) sur '{{ $labels.instance }}' ({{ $labels.job }}) se rapproche de sa temperature maximale "
  - alert: HostMaxtTempCrit
    expr: node_hwmon_temp_celsius / node_hwmon_temp_crit_celsius *100 * on(chip, instance, sensor) group_left(label) node_hwmon_sensor_label >= 90
    for: 0m
    labels:
      severity: critical
    annotations:
      summary: "DANGER. Un composant monte dangereusement en temperature. '{{ $labels.label }}' ({{ $labels.instance }} {{ $labels.job }})."
      description: "le capteur '{{ $labels.label }}' ({{ $labels.sensor }}) sur '{{ $labels.instance }}' ({{ $labels.job }}) se rapproche de sa temperature critique "

Prometheus:/# service prometheus restart

Surveillance état des "pool ZFS" ( "zpool" )

Nécessite au minimum la verion '1.1.0' de 'prometheus-node-exporter'.

Ne fonctionne plus depuis ZFS 2.1.

---

Inutile depuis ProxMox 7.

Sur ProxMox/Debian il possible de passer par l'activation du dépôt "Testing" et ensuite installer une version plus récente via la commande :

# apt install prometheus-node-exporter/testing

---

On active une alarme critique dès qu'un RAID ZFS se trouve dans un état dégradé, en échec, supprimé, hors ligne ou non disponible.

Prometheus:/# vi /etc/prometheus/rules.yml

fichier "yml" : bien respecter les aligments / toujours utiliser de vrais espaces (pas d'espace avec tabulation)

groups:
- name: nomdugroupe
  rules:
...
  - alert: NodeZpoolStateAlert
    expr: node_zfs_zpool_state{state="degraded"} == 1 or node_zfs_zpool_state{state="faulted"} == 1 or node_zfs_zpool_state{state="offline"} == 1 or node_zfs_zpool_state{state="removed"} == 1 or node_zfs_zpool_state{state="unavail"} == 1
    for: 0m
    labels:
      severity: critical
    annotations:
      summary: "DANGER, le pool '{{ $labels.zpool }}' sur '{{ $labels.instance }}' est dans l'etat '{{ $labels.state }}'"
      description: "DANGER, le pool '{{ $labels.zpool }}' est dans l'etat '{{ $labels.state }}' sur '{{ $labels.instance }}' ({{ $labels.job }})"

Prometheus:/# service prometheus restart

Prometheus Proxmox VE Exporter

Voir installation.

Surveillance Espace Disque VM/LXC

On active une alerte de niveau avertissement lorsque l'espace disque atteint, plus de 5mn, les 80% d'occupation et une autre de niveau critique lorsqu'il atteint les 90%.

Prometheus:/# vi /etc/prometheus/rules.yml

fichier "yml" : bien respecter les aligments / toujours utiliser de vrais espaces (pas d'espace avec tabulation)

groups:
- name: nomdugroupe
  rules:
...
  - alert: PxMxVMDiskWarning
    expr: pve_disk_usage_bytes / pve_disk_size_bytes *100 * on (id, instance) group_left(name) pve_guest_info > 80
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "Espace disque inferieur a 20% sur '{{ $labels.name }} ({{ $labels.id }})' serveur '{{ $labels.instance }} ({{ $labels.job}})'"
      description: "Attention. Espace disque occupe a plus de 80% sur l'hote '{{ $labels.name }} ({{ $labels.id }})' serveur '{{ $labels.instance }} ({{ $labels.job}})'"
  - alert: PxMxVMDiskCrit
    expr: pve_disk_usage_bytes / pve_disk_size_bytes *100 * on (id, instance) group_left(name) pve_guest_info > 90
    for: 5m
    labels:
      severity: critical
    annotations:
      summary: "Espace disque inferieur a 10% pour l'hote '{{ $labels.name }} ({{ $labels.id }})' serveur '{{ $labels.instance }} ({{ $labels.job}})'"
      description: "DANGER. Espace disque occupe a plus de 90% sur l'hote '{{ $labels.name }} ({{ $labels.id }})' serveur '{{ $labels.instance }} ({{ $labels.job}})'"

Prometheus:/# service prometheus restart

Surveillance Mémoire RAM VM/LXC

On active une alerte de niveau avertissement lorsque la RAM disponible est inférieur à 10% plus de 2 minutes.

Prometheus:/# vi /etc/prometheus/rules.yml

fichier "yml" : bien respecter les aligments / toujours utiliser de vrais espaces (pas d'espace avec tabulation)

groups:
- name: nomdugroupe
  rules:
...
  - alert: PxMxVMRAMWarning
    expr: (pve_memory_usage_bytes / pve_memory_size_bytes *100 * on(id, instance) group_left(name, type) pve_guest_info) > 90 and on(id, instance) pve_up == 1
    for: 2m
    labels:
      severity: warning
    annotations:
      summary: "RAM disponible inferieur a 10% sur '{{ $labels.name }} ({{ $labels.id }})' serveur '{{ $labels.instance }}'"
      description: "Attention. Memoire RAM occupee a plus de 90% sur l'hote '{{ $labels.name }} ({{ $labels.id }})' serveur '{{ $labels.instance }} ({{ $labels.job}})'"

Prometheus:/# service prometheus restart

Surveillance CPU VM/LXC

On active une alerte de niveau avertissement lorsque le processeur est occupé a plus de 80% plus de 5mn..

Prometheus:/# vi /etc/prometheus/rules.yml

fichier "yml" : bien respecter les aligments / toujours utiliser de vrais espaces (pas d'espace avec tabulation)

groups:
- name: nomdugroupe
  rules:
...
  - alert: PxMxVMCPUWarning
    expr: pve_cpu_usage_ratio *100 * on(id, instance) group_left(name, type) pve_guest_info > 80 and on(id, instance) pve_up == 1
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "Charge CPU importante sur '{{ $labels.name }} ({{ $labels.id }})' serveur '{{ $labels.instance }}'"
      description: "Attention. CPU occupe a plus de 80% depuis 5mn sur l'hote '{{ $labels.name }} ({{ $labels.id }})' serveur '{{ $labels.instance }} ({{ $labels.job}})'"

Prometheus:/# service prometheus restart

NVidia (nvidia_gpu_prometheus_exporter)

Voir installation.

Surveillance Consommation mémoire

On active une alerte (niveau "warning") lorsque la mémoire du GPU se remplit à plus de 80% plus de 3 minutes.

Prometheus:/# vi /etc/prometheus/rules.yml

fichier "yml" : bien respecter les aligments / toujours utiliser de vrais espaces (pas d'espace avec tabulation)

groups:
- name: nomdugroupe
  rules:
...
  - alert: GPUOutOfMemory
    expr: nvidia_gpu_memory_used_bytes / nvidia_gpu_memory_total_bytes *100 > 80
    for: 3m
    labels:
      severity: warning
    annotations:
      summary: "Le GPU {{ $labels.name }} remplit sa memoire dangereusement "
      description: "Le GPU {{ $labels.name }} du serveur {{ $labels.instance }} ({{ $labels.job }}) a depasse les 80% d'utilisation memoire depuis plus de 3 minutes"

Prometheus:/# service prometheus restart

Surveillance Température GPU

On active une alerte de niveau avertissement lorsque le GPU atteint les 75°c et une autre de niveau critique lorsqu'il atteint les 85°c. (Adapter selon GPU)

Prometheus:/# vi /etc/prometheus/rules.yml

fichier "yml" : bien respecter les aligments / toujours utiliser de vrais espaces (pas d'espace avec tabulation)

groups:
- name: nomdugroupe
  rules:
...
  - alert: GPUTempAlert
    expr: nvidia_gpu_temperature_celsius >= 75
    for: 0m
    labels:
      severity: warning
    annotations:
      summary: "Le GPU {{ $labels.name }} chauffe dangereusement "
      description: "Le GPU {{ $labels.name }} du serveur {{ $labels.instance }} ({{ $labels.job }}) a atteint les 75c"
  - alert: GPUTempAlertCrit
    expr: nvidia_gpu_temperature_celsius >= 85
    for: 0m
    labels:
      severity: critical
    annotations:
      summary: "Alerte. Le GPU {{ $labels.name }} atteint des niveaux de temperatures critiques"
      description: "Alerte. Le GPU {{ $labels.name }} du serveur {{ $labels.instance }} ({{ $labels.job }}) a atteint les 85c"

Prometheus:/# service prometheus restart

SyncThing

Voir installation

Surveillance Fonctionnement Instance

On active une alerte de niveau critique lorsqu'une instance de SyncThing ne fonctionne plus :

Prometheus:/# vi /etc/prometheus/rules.yml

fichier "yml" : bien respecter les aligments / toujours utiliser de vrais espaces (pas d'espace avec tabulation)

groups:
- name: nomdugroupe
  rules:
...
  - alert: SyncThingInstanceUP
    expr: syncthing_rest_system_connections_up == 0
    for: 0m
    labels:
      severity: critical
    annotations:
      summary: "L'instance SyncThing '{{ $labels.service }}' n'est plus accessible"
      description: "L'instance SyncThing '{{ $labels.service }}' ({{ $labels.instance }} {{ $labels.job }}) n'est plus accessible"

Prometheus:/# service prometheus restart

Surveillance Equipement Distant

syncthing_rest_system_connections_remote_device_is_paused == 1

Grafana

Grafana LXC Alpine Linux

Alpine Linux ne fait pas parti des distributions recommandées par Grafana. Cependant le programme est disponible dans les dépôts et Alpine sert de base pour de nombreux Docker Grafana.

Installation de base

# apk update && apk upgrade
# apk add grafana
# rc-update add grafana default
# service grafana start

Résolution de bugs (Alpine 3.13 / grafana 7.3.6)

Répertoire manquant

On répare un premier bug qui apparait dans les logs.. :

# mkdir /var/lib/grafana/provisioning/plugins
# chown grafana. /var/lib/grafana/provisioning/plugins
# service grafana restart

(Première méthode) Proxy Local

Dans cet exemple le proxy local est sécurisé, la sécurisation local n'est donc pas nécessaire

Ensuite le paquet grafana actuel outrepasse grafana.ini pour forcer l'écoute uniquement sur 127.0.0.1, donc inaccessible depuis l'extérieur. On va donc passer par un proxy Nginx local

• On édite le fichier grafana.ini :

# vi /etc/grafana.ini

On modifie les lignes suivantes :

Attention à bien supprimer le ; devant les lignes à activer!

• On bloque l'écoute extérieur en cas de MAJ qui règle le bug que nous utilisons :

# The ip address to bind to, empty will bind to all interfaces
http_addr = 127.0.0.1

• On change le port d'écoute pour conserver le port 3000 depuis l'extérieur :

# The http port  to use
http_port = 3001

# service grafana restart

On prépare le cryptage :

# mkdir -p /root/certs/grafana/ && cd /root/certs/grafana

# openssl req \
    -x509 \
    -newkey rsa:4096 \
    -nodes \
    -keyout grafana.key \
    -out grafana.crt

On créé le vhost local :

# vi /etc/nginx/http.d/grafana.conf

server {
        listen              3000 ssl;
        ssl_certificate     /root/certs/grafana/grafana.crt;
        ssl_certificate_key /root/certs/grafana/grafana.key;

        location / {

        proxy_pass http://localhost:3001/;

       }
   }

# service nginx reload

Grafana est maintenant accessible sur https://IP_GRAFANA:3000

(seconde méthode) Modification du script d'initialisation

On modifie le script de démarrage pour outrepasser la commande qui bloque l'écoute de Grafana sur "127.0.0.1"

# vi /etc/init.d/grafana

...
command="/usr/sbin/grafana-server"
command_args="$GRAFANA_OPTS cfg:server.http_addr=0.0.0.0"
...

# service grafana restart

(Optionnel) Sécurisation de Grafana

On prépare le cryptage :

# mkdir /var/lib/grafana/certs && cd /var/lib/grafana/certs/

# openssl req \
    -x509 \
    -newkey rsa:4096 \
    -nodes \
    -keyout grafana.key \
    -out grafana.crt

# chown -R grafana. /var/lib/grafana/certs

Puis on édite le fichier grafana.ini :

# vi /etc/grafana.ini

On modifie les lignes suivantes :

Attention à bien supprimer le ; devant les lignes à activer!

• On active https :

# Protocol (http, https, h2, socket)
protocol = https

• On renseigne le certificat et la clef de cryptage :

# https certs & key file                                                                                                
cert_file = /var/lib/grafana/certs/grafana.crt
cert_key = /var/lib/grafana/certs/grafana.key

# service grafana restart

Grafana ne sera plus accessible via http://IP_GRAFANA:3000 mais via https://IP_GRAFANA:3000

Exemple vhost reverse-proxy Nginx

Voir reverse proxy Nginx

server {
listen 80;
    listen [::]:80;
    server_name     grafana.exemple.net;
   # return 404;
    return 301 https://$host$request_uri;
}

server {
server_name     grafana.exemple.net;
    error_page 403  https://grafana.exemple.net;

    location / {
            proxy_set_header X-Real-IP  $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto https;
            proxy_set_header X-Forwarded-Port 443;
            proxy_set_header Host $http_host;
            proxy_pass https://IP_GRAFANA:3000; #https si grafana sécurisé
    }

    listen [::]:443 ssl; # managed by Certbot
    listen 443 ssl; # managed by Certbot

 
    ssl_certificate /etc/letsencrypt/live/grafana.exemple.net/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/grafana.exemple.net/privkey.pem;
    include /etc/letsencrypt/options-ssl-nginx.conf;
    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;
    add_header Strict-Transport-Security "max-age=31536000" always;
    ssl_trusted_certificate /etc/letsencrypt/live/grafana.exemple.net/chain.pem;
    ssl_stapling on;
    ssl_stapling_verify on;

server_tokens off;
add_header X-Frame-Options "SAMEORIGIN";
add_header X-XSS-Protection "1; mode=block";
add_header X-Content-Type-Options "nosniff";

}

Configuration

Première connexion

• Lors de la première connexion il faut se connecter avec l'utilisateur "admin" et le mot de passe par défaut "admin" :

• Grafana vous demandera de modifier le mot de passe par défaut pour d'évidentes raisons de sécurité :

• Nous voila enfin sur la page d'accueil :

Import source de donnés

• Se rendre dans "Configuration" (roue dentée) -> "Data Sources" :

• Cliquer sur "Add data source" :

Importation Source Prometheus Distant (Certificat autosigné)

• Sélectionner une source de données de type "Prometheus" :

• Renseigner les champs et options suivantes :

• Valider et tester :

• Un message doit confirmer le bon fonctionnement :

Importation Source Prometheus Locale

Par "locale" entendre que Grafana fonctionne sur le même serveur que la source Prometheus cible.

• Sélectionner une source de données de type "Prometheus" :

• Renseigner les champs et options suivantes :

• Valider et tester :

• Un message doit confirmer le bon fonctionnement :

Import "Dashboard" (Tableau de Bord)

Pour économiser du temps il est possible d'importer des "dashboards" préparées par d'autres utilisateurs et de les adapter à son installation. On peut utiliser ce moteur de recherche pour trouver son bohneur.

Nous allons utiliser le tableau de bord "Proxmox via Prometheus" (Id: 10347) dans cet exemple.

identification du tableau de bord cible

• Se rendre sur https://grafana.com/grafana/dashboards, un moteur de recherche est disponible, exemple :

• On note le numéro d'identification du tableau de bord (10347) :

Import dans Grafana

• Se rendre dans "Create" (symbole +) -> "Import" :

• Renseigner l'ID et importer :

• Il faut renseigner une source de données à attacher, il est possible de modifier le nom, etc.

Rendre un tableau de bord Multi-source

Pour cet exemple nous continuons avec le tableau de bord "Proxmox via Prometheus" (Id: 10347)

Pour ne pas importer des tableaux de bord identiques pour diverses sources, il est possible d'ajouter un onglet de sélection.

(Optionnel) Suppression de la source par défaut

Si une source à le statut "par défaut", elle apparaitra deux fois dans l'onglet de sélection, en tant que tel et en tant que "default".

• Se rendre dans "Configuration" (roue dentée) -> "Data Sources" :

• Sélectionner la base avec l'attribut "default" :

• Décocher l'attribut "default" :

• Puis sauvegarder :

Ajout de la nouvelle source

• Se rendre sur le tableau de bord à modifier et sélectionner le menu "Dashboards settings" (roue dentée) :

• Sélectionner le menu "Variables" -> "New"

• Dans "General", sélectionner un nom ("name") puis Type : Datasource, Ensuite dans "Data source options" sélectionner Type : Prometheus, enfin valider avec "Add"

• De retour sur le tableau de bord un nouvel onglet est disponible :

• Il faut encore éditer tous les panneaux du tableau de bord de la façon suivante :

• Dans "Query" remplacer la source de données sélectionnée par "$Datasource"

• Répéter l'opération pour chaque panneaux.

Le tableau de bord "Proxmox via Prometheus" (Id: 10347) est multi-instance, il faudra également éditer la variable instance pour qu'elle prenne en compte plusieurs sources. Voir ci-dessous.

Variable "Instance" (query) multi-source

Ici, la requête qui sélectionne l'instance (serveur physique ici) à pour nom choisit, par le créateur, "instance", mais cela pourrait être différend sur d'autres tableaux de bord..

• Se rendre sur le tableau de bord à modifier et sélectionner le menu "Dashboards settings" (roue dentée) :

• Dans "Variables" sélectionner la variable "Instance" :

• Modifier la source par la variable "$Datasource", confirmer la requête "Query" avec "label_values(pve_node_info, instance)"* et mettre à jour avec "Update" :

Il faudra probablement rééditer la variable après avoir confirmé le changement de la source pour renseigner de nouveau la requête "label_values(pve_node_info, instance)"

Sur des tableaux de bords plus complexes il peut avoir plusieurs variables à éditer..

Plugin AlertManager

Installation du Plugin

Sur le serveur de Grafana :

Grafana:/# grafana-cli plugins install camptocamp-prometheus-alertmanager-datasource
Grafana:/# service grafana restart

Installation de la source de données

• Se rendre dans "Configuration" (roue dentée) -> "Data Sources" :

• Cliquer sur "Add data source" :

• Sélectionner une source de données de type "Prometheus AlertManager" :

Importation Source "Prometheus AlertManager" Distant (Certificat autosigné)

• Renseigner les champs et options suivantes :

• Valider et tester :

• Un message doit confirmer le bon fonctionnement :

Importation Source "Prometheus AlertManager" Locale

Par "locale" entendre que Grafana fonctionne sur le même serveur que la source AlertManager cible.

• Renseigner les champs et options suivantes :

• Valider et tester :

• Un message doit confirmer le bon fonctionnement :

Tableau de Bord

Voir Importation de tableau de bord

Prometheus AlertManager (ID: 8010)

Les alertes peuvent être regroupées par leurs noms dans AlertManager, par défaut trois catégories sont déjà assignées ("NodeDown", "NodeMemoryUsage" et ""NodeCPUUsage"), à vous de changer/modifier/jouer avec..

Export

Prometheus Node-Exporter

Exportateur de métriques orientés matériel

Installation Exportateur

ProxMox / Debian / Ubuntu

On installe l'exportateur :

ProxMox:~# apt install prometheus-node-exporter

Pour obtenir le status des "pool ZFS" il faudra au minimum la version '1.1.0' de 'prometheus-node-exporter'

On crée un fichier de configuration avec l'adresse et port d'écoute :

ProxMox:~# echo 'ARGS=--web.listen-address=12.34.56.789:9100' > /etc/prometheus.conf

On active le fichier de configuration en modifiant le script :

ProxMox:~# vi /lib/systemd/system/prometheus-node-exporter.service

...
EnvironmentFile=/etc/prometheus.conf
...

Pour éviter que le service plante au démarrage on peut ajouter cette ligne :

...
Restart=always
RestartSec=3
User=prometheus
...

ProxMox:~# systemctl daemon-reload
ProxMox:~# service prometheus-node-exporter restart

Importation Prometheus

Prometheus:~# vi /etc/prometheus/prometheus.yml

fichier "yml" : bien respecter les aligments / toujours utiliser de vrais espaces (pas d'espace avec tabulation).

...
  - job_name: node
    static_configs:
    - targets: [12.34.56.789:9100]
      labels:
        instance: 'nomduserveur'

La partie "labels" est optionnel mais permet de remplacer l'adresse IP par un nom plus simple à identifier dans les rapports.

Prometheus:~# service prometheus restart

On vérifie que l'exportateur est "up" en se rendant sur son serveur Prometheus dans "Status" -> "Targets"

Tableau de bord Grafana

Voir Importation de tableau de bord

Node Exporter Full (ID : 1860) Attention semble buggé..

1 Node Exporter for Prometheus Dashboard EN v20201010 (ID : 11074) Le job Prometheus doit s'appeler "node" comme dans ce tuto..

AlertManager

Voir exemples d'alertes

Prometheus PVE Exporter (ProxMox)

source en français de qualitay

Exportateur de métriques orientés virtualisation

Installation Exportateur

On crée un groupe et un utilisateur avec les droits d'accès au monitoring :

ProxMox:~# pveum groupadd monitoring -comment 'Monitoring group'
ProxMox:~# pveum aclmod / -group monitoring -role PVEAuditor
ProxMox:~# pveum useradd pve_exporter@pve
ProxMox:~# pveum usermod pve_exporter@pve -group monitoring
ProxMox:~# pveum passwd pve_exporter@pve

On installe l'exportateur :

ProxMox:~# apt-get install python3-pip
ProxMox:~# pip3 install prometheus-pve-exporter

On va ensuite créer un fichier de configuration :

ProxMox:~# mkdir -p /usr/share/pve_exporter/

ProxMox:~# vi /usr/share/pve_exporter/pve_exporter.yml

fichier "yml" : bien respecter les aligments / toujours utiliser de vrais espaces (pas d'espace avec tabulation).

default:
    user: pve_exporter@pve
    password: MOTDEPASSE
    verify_ssl: false

On créé le fichier pour systemd :

ProxMox:~# vi /etc/systemd/system/pve_exporter.service

[Unit]
Description=Proxmox VE Prometheus Exporter
After=network.target
Wants=network.target

[Service]
Restart=on-failure
WorkingDirectory=/usr/share/pve_exporter
ExecStart=/usr/local/bin/pve_exporter --config.file /usr/share/pve_exporter/pve_exporter.yml --web.listen-adress 12.34.56.789:9221 

[Install]
WantedBy=multi-user.target

ip interface d'écoute:Port

ProxMox:~# systemctl daemon-reload
ProxMox:~# systemctl enable pve_exporter
ProxMox:~# systemctl start pve_exporter

Importation Prometheus

Prometheus:~# vi /etc/prometheus/prometheus.yml

fichier "yml" : bien respecter les aligments / toujours utiliser de vrais espaces (pas d'espace avec tabulation).

...
  - job_name: 'pve'
    static_configs:
      - targets: [12.34.56.789:9221]
        labels:
          instance: 'nomduserveur'
    metrics_path: /pve
    params:
      module: [default]

La partie "labels" est optionnel mais permet de remplacer l'adresse IP par un nom plus simple à identifier dans les rapports.

Prometheus:~# service prometheus restart

On vérifie que l'exportateur est "up" en se rendant sur son serveur Prometheus dans "Status" -> "Targets"

Tableau de bord Grafana

Proxmox via Prometheus (10347). Tableau de bord pris pour exemple

Astuce : Pour les jauges d'occupation disques, dans "legend" remplacer "{{name}}" par "{{storage}}" pour plus de visibilité

Astuce : Remplacer la requête CPU par " pve_cpu_usage_ratio *100 * on(id, instance) group_left(name, type) pve_guest_info and on(id, instance) pve_up == 1 "

AlertManager

Voir exemples d'alertes

Exportateur Nvidia (nvidia_gpu_prometheus_exporter)

Source

Installation Exportateur

Commandes Docker/PodMan

Testé sur Debian, adapter si besoin..

pull mindprince/nvidia_gpu_prometheus_exporter:0.1

run --name nvexport -p IP_INTERFACE_D_ECOUTE:9445:9445 -d --restart=always -e LD_LIBRARY_PATH=/usr/lib/x86_64-linux-gnu/libnvidia-ml.so.1 --volume /usr/lib/x86_64-linux-gnu/libnvidia-ml.so.1:/usr/lib/x86_64-linux-gnu/libnvidia-ml.so.1 --privileged mindprince/nvidia_gpu_prometheus_exporter:0.1

Installation type Debian

On récupère le programme :

# apt update && apt upgrade
# apt install golang
# mkdir /usr/local/nvidia_gpu_prometheus_exporter
# export GOPATH=/usr/local/nvidia_gpu_prometheus_exporter
# go get github.com/mindprince/nvidia_gpu_prometheus_exporter
# chown -R root. /usr/local/nvidia_gpu_prometheus_exporter/*

L'exportateur est maintenant disponible sous "/usr/local/nvidia_gpu_prometheus_exporter/bin/nvidia_gpu_prometheus_exporter"

Service Systemd

On crée un utilisateur pour exécuter le service :

# useradd -r nvidia_gpu_prometheus_exporter --shell=/bin/false

On crée le service :

# vi /etc/systemd/system/nvidia_gpu_prometheus_exporter.service

[Unit]
Description=NVIDIA GPU Prometheus Exporter
After=network.target

[Service]
Type=simple
User=nvidia_gpu_prometheus_exporter
Group=nvidia_gpu_prometheus_exporter
ExecStart=/usr/local/nvidia_gpu_prometheus_exporter/bin/nvidia_gpu_prometheus_exporter -web.listen-address 123.45.67.89:9445
Restart=on-failure

[Install]
WantedBy=multi-user.target

On active le service au démarrage et immédiatement:

# systemctl enable nvidia_gpu_prometheus_exporter
# systemctl start nvidia_gpu_prometheus_exporter

Importation Prometheus

Prometheus:~# vi /etc/prometheus/prometheus.yml

fichier "yml" : bien respecter les aligments / toujours utiliser de vrais espaces (pas d'espace avec tabulation).

...
  - job_name: 'nvidia'
    static_configs:
      - targets: [12.34.56.789:9445]
        labels:
          instance: 'nomduserveur'

La partie "labels" est optionnel mais permet de remplacer l'adresse IP par un nom plus simple à identifier dans les rapports.

Prometheus:~# service prometheus restart

On vérifie que l'exportateur est "up" en se rendant sur son serveur Prometheus dans "Status" -> "Targets"

Tableau de bord Grafana

Voir Importation de tableau de bord

Nvidia GPU (id: 10703)

Nécessite de modifier la jauge mémoire ("nvidia_gpu_memory_used_bytes / nvidia_gpu_memory_total_bytes *100" / instant:yes / décimales : 2), on peut facilement ajouter une jauge vitesse ventilateur & indicateur de température ("nvidia_gpu_fanspeed_percent" / instant:yes & "nvidia_gpu_temperature_celsius" / instant:yes)

AlertManager

Voir exemples d'alertes

SyncThing

f100024/syncthing_exporter

Récupération / Création de la clef API

Pour pouvoir connecter l'exportateur à votre instance SyncThing, et récupérer les données de surveillance, il faut connaitre la clef API.

• Depuis la GUI de SyncThing se rendre dans "Actions" -> "Configuration" :

• La clef est accessible, optionnellement on peut en générer une nouvelle :

Installation Exportateur

Docker (Portainer) / Open Media Vault

On utilise l'image f100024/syncthing_exporter

• Réseau du container de type "Host" :

• Dans les variables d'environnement, on renseigne l'adresse de l'instance SyncThing via "SYNCTHING_URI" et la clef API via "SYNCTHING_TOKEN". Optionnellement on peut renseigner l'IP et le port d'écoute (par défaut port '9093' sur toutes les interfaces réseaux) :

• Enfin on renseigne la politique de redémarrage sur "Unless stopped" :

Linux

On peut récupérer le programme à cette adresse.

# wget https://github.com/f100024/syncthing_exporter/releases/download/v0.3.0/syncthing_exporter-0.3.0.linux-amd64.tar.gz
# tar zxvf syncthing_exporter-0.3.0.linux-amd64.tar.gz -C /usr/local/
# mv /usr/local/syncthing_exporter-0.3.0.linux-amd64 /usr/local/syncthing_exporter
# chown root. /usr/local/syncthing_exporter/*
# rm syncthing_exporter-0.3.0.linux-amd64.tar.gz

L'exportateur est maintenant disponible dans "/usr/local/syncthing_exporter/syncthing_exporter".

Script init.d Alpine Linux

Source

On crée un utilisateur système et son groupe pour utiliser le programme :

# addgroup -S syncthing_exporter && adduser -SH -s /sbin/nologin -G syncthing_exporter syncthing_exporter

On crée le script :

# vi /etc/init.d/syncthing_exporter

#!/sbin/openrc-run
name="syncthing_exporter"
description="Syncthing metrics exporter for prometheus"
command=/usr/local/syncthing_exporter/syncthing_exporter
command_args="--syncthing.uri="https://IP_SYNCTHING:8384" \
        --syncthing.token="clef_API_SyncThing" \
        --web.listen-address="IP_D_ECOUTE:9093""
command_user="syncthing_exporter"
pidfile="/run/$RC_SVCNAME/$RC_SVCNAME.pid"
command_background="yes"                              
                       
depend() {
        need net
}

start_pre() {
        checkpath --directory --owner $command_user:$command_user --mode 0775 \
                /run/$RC_SVCNAME /var/log/$RC_SVCNAME                          
}

Le port par défaut de l'exportateur (9093) est le même que le port par défaut d'AlertManager, penser à adapter si besoin.

On rend exécutable le script :

# chmod +x /etc/init.d/syncthing_exporter

On ajoute le script au démarrage du système :

# rc-update add syncthing_exporter default

On démarre le script :

# service syncthing_exporter start

Jail OpenBSD TrueNAS

Source

On prend le contrôle du "jail" du plugin SyncThing :

# iocage console SyncThing

On récupère l'environnement "Goland" à cette adresse :

# cd /tmp
# pkg install wget

Ignore the mismatch and continue? [y/N]: y

Proceed with this action? [y/N]: y

# wget https://go.dev/dl/go1.22.0.freebsd-amd64.tar.gz
# tar zxvf go1.22.0.freebsd-amd64.tar.gz

On récupère les sources de l'exportateur à cette adresse :

# wget https://github.com/f100024/syncthing_exporter/archive/refs/tags/v0.3.6.tar.gz
# tar zxvf v0.3.6.tar.gz

On compile l'exportateur :

# cd syncthing_exporter-0.3.6
# /tmp/go/bin/go build .

On déplace le programme :

# mkdir /usr/local/syncthing_exporter
# mv syncthing_exporter /usr/local/syncthing_exporter/

On attribue les droits :

# chown root:wheel /usr/local/syncthing_exporter/syncthing_exporter

On peut nettoyer le Jail :

# cd /
# rm -r /tmp/syncthing_exporter*
# rm -r /tmp/go*
# rm -r /tmp/v0.3.6.tar.gz
# pkg delete wget libunistring libidn2 indexinfo gettext-runtime

L'exportateur est maintenant disponible sous "/usr/local/syncthing_exporter/syncthing_exporter".

Script rc.d

On crée un utilisateur pour utiliser l'exportateur :

# pw adduser syncthing_exporter -d /nonexistent -s /usr/sbin/nologin -c "syncthing_exporter user"

On crée le script :

# vi /usr/local/etc/rc.d/syncthing-exporter

#!/bin/sh
# PROVIDE: syncthing_exporter
# REQUIRE: DAEMON
# KEYWORD: shutdown

. /etc/rc.subr

name="syncthingexporter"
rcvar="syncthingexporter_enable"
syncthingexporter_user="syncthing_exporter"
syncthingexporter_group="syncthing_exporter"
syncthingexporter_command="/usr/local/syncthing_exporter/syncthing_exporter"
pidfile="/var/run/${name}.pid"
command="/usr/sbin/daemon"
command_args="-f -P ${pidfile} ${syncthingexporter_command} --syncthing.uri="https://127.0.0.1:8384" --syncthing.token="clef_API_SyncThing" --web.listen-address="0.0.0.0:9093""

load_rc_config $name
: ${syncthingexporter_enable:=no}

start_precmd=syncthingexporter_startprecmd

syncthingexporter_startprecmd()
{
       if [ ! -e ${pidfile} ]; then
               install -o ${syncthingexporter_user} -g ${syncthingexporter_group} /dev/null ${pidfile};
       fi
}

run_rc_command "$1"

0.0.0.0 indispensable si votre jail à une connexion réseau de type "bridge", il faudra également ouvrir le port dans le menu "jails" -> "MODIFIER" -> "Propriétés du réseau"

On rend exécutable le script :

# chmod +x /usr/local/etc/rc.d/syncthing-exporter

On autorise le script :

# echo 'syncthingexporter_enable="YES"' >> /etc/rc.conf

On démarre le script :

# service syncthing-exporter start

Importation Prometheus

Prometheus:~# vi /etc/prometheus/prometheus.yml

fichier "yml" : bien respecter les aligments / toujours utiliser de vrais espaces (pas d'espace avec tabulation).

...
  - job_name: 'syncthing_server'
    metrics_path: /metrics
    static_configs:
      - targets: ['IP_EXPORTATEUR:9093']
        labels:
          service: nom_serveur_syncthing

Prometheus:~# service prometheus restart

On vérifie que l'exportateur est "up" en se rendant sur son serveur Prometheus dans "Status" -> "Targets"

NextCloud

xperimental/nextcloud-exporter

(Obsolète) Méthode Utilisateur & Mot de Passe

A partir de Nextcloud 22 préférer la méthode d'authentification par jeton

Utilisateur NextCloud-Exporter

Il faut un compte administrateur sur votre NextCloud pour utiliser l'exportateur, il est conseillé d'utiliser un compte dédié :

• Se rendre dans le menu "Utilisateurs" de "admin" :

• Créer un utilisateur "nextcloud-exporter" avec un mot de passe et membre du groupe "admin" :

• Déconnecter admin et se connecter avec le nouvel utilisateur "nextcloud-exporter" pour la suite.

Intallation exportateur

On récupère la dernière version depuis cette page :

# mkdir /usr/local/nextcloud-exporter
# wget https://github.com/xperimental/nextcloud-exporter/releases/download/v0.4.0/nextcloud-exporter-0.4.0-amd64.bz2
# bunzip2 nextcloud-exporter-0.4.0-amd64.bz2
# mv nextcloud-exporter-0.4.0-amd64 /usr/local/nextcloud-exporter/nextcloud-exporter
# chmod +x /usr/local/nextcloud-exporter/nextcloud-exporter

L'exportateur est maintenant disponible sous "/usr/local/nextcloud-exporter/nextcloud-exporter".

Liaison Exportateur/NextCloud

On lance la commande suivante pour générer le lien de connexion de l'exportateur à NextCloud:

# /usr/local/nextcloud-exporter/nextcloud-exporter --login --server https://nextcloud.example.net

On obtiens un lien à rentrer dans un navigateur déjà connecté avec l'utilisateur "nextcloud-exporter" précédement créé :

INFO nextcloud-exporter 0.4.0                     
INFO Starting interactive login on: https://nextcloud.exemple.net 
INFO Please open this URL in a browser: https://nextcloud.exemple.net/login/v2/flow/********************************************************************
INFO Waiting for login ... (Ctrl-C to abort)

En utilisant le lien généré on arrive sur les pages d'autorisation :

L'exportateur affichera alors le mot de passe d'application dans la console :

...
INFO Waiting for login ... (Ctrl-C to abort)      
INFO Username: nextcloud-exporter                 
INFO Password: ***************************************************

Après avoir généré (et noté) le mot de passe d'application il est possible, par sécurité, de supprimer l'accès au gestionnaire de ficher pour l'exportateur :

• Se rendre dans le menu "Paramètres" de l'utilisateur "nextcloud-exporter" :

• Décocher "Autoriser l'accès au gestionnaire de fichiers" dans le menu "Sécurité" :

Configuration du service NextCloud-Exporter (Ubuntu/Debian)

On créé le fichier de configuration :

# vi /usr/local/nextcloud-exporter/nextcloud-exporter.yml

fichier "yml" : bien respecter les aligments / toujours utiliser de vrais espaces (pas d'espace avec tabulation)

# required
server: "https://nextcloud.exemple.net"
username: "nextcloud-exporter"
password: "************************************"
# optional
listenAddress: "IP_INTERFACE_D_ECOUTE:9205"
timeout: "5s"
tlsSkipVerify: false

On crée l'utilsateur système pour utiliser le service SystemD :

# useradd -r nextcloud-exporter --shell=/bin/false

On crée le service :

# vi /etc/systemd/system/nextcloud-exporter.service

[Unit]
Description=NextCloud Prometheus Exporter
After=network.target

[Service]
Type=simple
User=nextcloud-exporter
Group=nextcloud-exporter
ExecStart=/usr/local/nextcloud-exporter/nextcloud-exporter -c /usr/local/nextcloud-exporter/nextcloud-exporter.yml
Restart=on-failure

[Install]
WantedBy=multi-user.target

On active le service au démarrage et immédiatement:

# systemctl enable nextcloud-exporter
# systemctl start nextcloud-exporter

Méthode authentification par jeton (token)

Jeton

Il faut d'abord créer un jeton, par exemple via "openssl" :

# TOKEN=$(openssl rand -hex 32)

Puis configurer NextCloud pour l'utiliser :

# sudo -u www-data php /var/www/nextcloud/occ config:app:set serverinfo token --value "$TOKEN"

Config value token for app serverinfo set to MON_NUMERO_DE_JETON

Noter le numéro de jeton généré pour le fichier de configuration

Intallation exportateur

On récupère la dernière version depuis cette page :

# mkdir /usr/local/nextcloud-exporter
# wget https://github.com/xperimental/nextcloud-exporter/releases/download/v0.5.1/nextcloud-exporter-0.5.1-amd64.bz2
# bunzip2 nextcloud-exporter-0.5.1-amd64.bz2
# mv nextcloud-exporter-0.5.1-amd64 /usr/local/nextcloud-exporter/nextcloud-exporter
# chmod +x /usr/local/nextcloud-exporter/nextcloud-exporter

L'exportateur est maintenant disponible sous "/usr/local/nextcloud-exporter/nextcloud-exporter".

Configuration du service NextCloud-Exporter (Ubuntu/Debian)

On créé le fichier de configuration :

# vi /usr/local/nextcloud-exporter/nextcloud-exporter.yml

fichier "yml" : bien respecter les aligments / toujours utiliser de vrais espaces (pas d'espace avec tabulation)

# required
server: "https://nextcloud.exemple.net"
authToken: "MON_NUMERO_DE_JETON"
# optional
listenAddress: "IP_INTERFACE_D_ECOUTE:9205"
timeout: "5s"
tlsSkipVerify: false

On crée l'utilsateur système pour utiliser le service SystemD :

# useradd -r nextcloud-exporter --shell=/bin/false

On crée le service :

# vi /etc/systemd/system/nextcloud-exporter.service

[Unit]
Description=NextCloud Prometheus Exporter
After=network.target

[Service]
Type=simple
User=nextcloud-exporter
Group=nextcloud-exporter
ExecStart=/usr/local/nextcloud-exporter/nextcloud-exporter -c /usr/local/nextcloud-exporter/nextcloud-exporter.yml
Restart=on-failure

[Install]
WantedBy=multi-user.target

On active le service au démarrage et immédiatement:

# systemctl enable --now nextcloud-exporter

Importation Prometheus

Prometheus:~# vi /etc/prometheus/prometheus.yml

fichier "yml" : bien respecter les aligments / toujours utiliser de vrais espaces (pas d'espace avec tabulation).

...
  - job_name: 'nextcloud'
    scrape_interval: 90s
    static_configs:
      - targets: ['IP_EXPORTATEUR:9205']
        labels:
          instance: 'nomduserveurnextcloud'

La partie "labels" est optionnel mais permet de remplacer l'adresse IP par un nom plus simple à identifier dans les rapports.

Prometheus:~# service prometheus restart

On vérifie que l'exportateur est "up" en se rendant sur son serveur Prometheus dans "Status" -> "Targets"

Tableau de bord Grafana

Voir Importation de tableau de bord

Nextcloud by ochorocho (id: 9632) Très sommaire..

Nextcloud Exporter Prometheus Dashboard (id: 11033) Entièrement à reconfigurer..