Blog de dada

DevOps, bidouilleur et routard plein de logiciels libres

prometheus

L'alerting avec Prometheus

Rédigé par dada / 02 août 2018 / 4 commentaires


Depuis le temps que je devais l'écrire, ce billet, le voici : comment mettre en place un système d'alerting avec Prometheus !

Pour celles et ceux qui ne sont pas familiers avec ce vocabulaire : l'alerting est une notion d'administrateur système qui consiste à prévenir les équipes en charge du bon fonctionnement d'un service qu'il est en train de se casser la figure. Ou qu'il s'est déjà vautré.

En avant-propos, je vous invite à aller faire un tour du côté de mes différents billets sur Prometheus.

L'alerting, c'est une brique en plus

Prometheus est une bête idiote, les exporters sont des bêtes idiotes, Grafana est une bête idiote, l'alerting est lui aussi une bête idiote. Pour le faire fonctionner, à la manière d'un exporter, il vous faut installer l'Alertmanager.

L'installation de l'Alertmanager est identique à celle des autres exporter : téléchargez le binaire ou le conteneur Docker, lancez tout ça en lui passant en paramètre son fichier de configuration.

Toujours comme un simple exporter, ou presque, faites comprendre à Prometheus qu'il est là en ajoutant ces quelques lignes dans prometheus.yml, en dessous de la configuration globale :
alerting:
  alertmanagers:
  - static_configs:
    - targets:
      - localhost:9093
    scheme: http
    timeout: 10s

N'oubliez pas de reload la configuration de Prometheus :

curl -X POST http://localhost:9090/-/reload

Configurer la détection des problèmes

Les alertes se présentent sous forme de fichiers que vous allez placer dans le répertoire rules/ de Prometheus :
root@server /etc/prometheus/rules # ls
memory  up
Il va ensuite falloir les déclarer dans Prometheus :
# Load and evaluate rules in this file every 'evaluation_interval' seconds.
rule_files:
  - '/etc/prometheus/rules/up'
  - '/etc/prometheus/rules/memory'
Pour faire simple et rapide, voici des exemples d'alertes qui pourraient vous servir :

- Service disponible
ALERT InstanceDown
  IF up == 0
  FOR 1m
  LABELS { severity = "page" }
  ANNOTATIONS {
    summary = "Instance {{$labels.instance}} is down",
    description = "{{$labels.instance}} of job {{$labels.job}} has been down for more than 1 minutes"
  }
- L'utilisation de la RAM
ALERT MemoryUsage
  IF ((node_memory_MemTotal-node_memory_MemFree-node_memory_Cached)/(node_memory_MemTotal)*100) > 95
  FOR 10m
  LABELS { severity = "warning" }
  ANNOTATIONS {
    summary = "Instance {{$labels.instance}} is in danger",
    description = "RAM of {{$labels.instance}} has been too used for more than 10 minutes"
  }
Avant de vous lancez dans le copier/coller du code exposé ci-dessus, prenez le temps de lire les quelques lignes suivantes :

- ALERT : il s'agit d'un nom arbitraire que vous donnez à votre alerte
- IF : c'est la condition qu'il faut respecter pour déclencher l'alerte
- FOR : la durée pendant laquelle le IF doit être valide
- LABEL : ça permet de donner un poids à votre alerte (osef, warning, critical, etc)
- ANNOTATIONS : ce que vous voulez afficher quand l'alerte est déclenchée

Normalement, à ce niveau là, vous avez un Alertemanager capable de détecter si vous avez des soucis de RAM ou si vos serveurs/services sont fonctionnels ou HS. C'est bien beau, mais ça ne vous réveillera pas en cas de pépin.

Un rapide tour sur l'interface web de Prometheus devrait vous le confirmer. En exemple, voici la liste des alertes que j'utilise :

Configurer l'envoi d'emails d'alerte

Le fichier de configuration que vous passerez en paramètre au lancement de l'Alertmanager doit lui dire que faire quand une alerte est détectée. Il est possible de lui dire de vous envoyez un message sur Telegram, Mattermost, ou, simplement, de vous envoyer un mail. C'est la solution la plus simple, alors allons-y.

Les possibilités étant énormes, je ne vais vous proposer qu'un exemple de configuration simple :
global:
  smtp_smarthost: 'localhost:25'
  smtp_from: 'alertmanager@mon.email'

route:
  receiver: 'team-mails'
  group_wait: 30s
  group_interval: 5m
  repeat_interval: 3h

receivers:
- name: 'team-mails'
  email_configs:
  - to: 'ladestination@email.mail'
Avec cette configuration, vous allez recevoir un mail en cas de souci. Sans intervention de votre part, le mail sera renvoyé au bout de 3h.

Cette conf est très simple. Je n'explique pas tout. Juste, elle marche. Si vous souhaitez en savoir plus, comme l'organisation de groupes qui recevront des alertes spécifiques ou la gestion des "warning" ou des "critical", je vous encourage à prendre un peu de temps pour lire l'exemple assez complet qu'on peut trouver par ici.

Et voilà ! Je suis loin d'avoir fait le tour des possibilités de Prometheus mais les différents billets que vous trouverez sur ce blog devraient vous permettre de mettre les doigts dedans et de vous en sortir.

Des bisous !

Un Exporter Prometheus pour Mastodon

Rédigé par dada / 27 juillet 2018 / Aucun commentaire


English ? Run to my Gitlab. Comments are in english.


Mon dernier billet ne laissait pas trop de doute sur mes activités du moment : du python, Prometheus et l'API de Mastodon sont bien les signes avant-coureurs de l'arrivée d'un Exporter ! Dans cette liste, j'ai pris le temps d'ajouter un peu de Grafana et du Docker, histoire de bien faire les choses, avant de vous ouvrir l'accès à mon dépôt Git.

Le poids des mots, le choc des photos

Pour reprendre le slogan de Paris-Match, voici une capture d'écran de la bête dans Grafana :

Ce que vous voyez ci-dessus est un exemple de dashboard Grafana. Un exemple. Vous pouvez faire bien mieux, j'en suis certain, et le partager.

Ce que l'Exporter permet de récupérer

  • Les comptes actifs
  • Le nombre d'instances connues
  • Le nombre total de comptes sur l'instance
  • Le nombre total de toots
  • Le nombre d'inscriptions pour la semaine courante
  • Le nombre de toots par semaine
Alors, oui, ce n'est pas grand chose, mais ça nous permet de récupérer des statistiques publiques et d'en faire des beaux graphiques avec la stack la plus chouette du moment ! J'ai enfin viré Munin :-)

Utilisation sans Docker

Clonez les sources où bon vous semble :
git clone http://git.dadall.info/prometheus/mastodon.git
Installez les dépendances :
pip3 install -r requirements.txt
Lancez la bête en ayant bien défini l'URL de votre instance dans les sources :
python3 instance_exporter.py

Utilisation avec Docker

Il va vous falloir créer l'image Docker :
docker build -t mastodon-exporter .
Et vous pourrez lancer un conteneur en ajoutant l'URL de votre instance en paramètre :
docker run -d -e MASTODON_HOST="https://instance.url/" -p 9410:9410 mastodon-exporter
Vous trouverez un exemple de dashbord pour Grafana, histoire de tout mettre en couleur, dans le dépôt.

Vous pouvez maintenant suivre l'activité de votre instance : foncez mettre ça en place avant le prochain afflux d'utilisateurs pour voir les courbes réagir : les données qui transitent sur Mastodon sont tellement nombreuses qu'il faut vraiment qu'il y ait une vague de nouveaux pour faire visiblement bouger les lignes !

Voilà

Si vous avez des retours, n'hésitez pas à passer par les commentaires ou Mastodon, à lâcher des pouces bleus et partager la vidéo.

Des bisous,

Comment prendre un peu de Python pour faire un Exporter Prometheus

Rédigé par dada / 20 juillet 2018 / 2 commentaires



Faire un Exporter Prometheus, c'était un défi qui traînait dans ma longue-liste-des-choses-à-faire depuis longtemps. J'ai enfin mis les mains dedans. C'est moins terrifiant qu'on le croit, à condition de vouloir faire des choses simples. Voici donc quelques lignes pour vous expliquer comment s'en sortir.

Du Python 3

Il est possible de faire des Exporters dans un nombre dingue de langages. Pour des questions de curiosité et d'envie, j'ai choisi de le faire en Python, version 3. En plus, Prometheus fournit une bibliothèque qui va bien.

Une API

Un Exporter est capable d'interroger, entre autre, des API. Pour l'exemple et parce ce que j'avais envie de mieux connaître mon instance Mastodon, c'est l'API de l'alternative à Twitter que vous allez croiser ci-dessous.

La logique globale

Un Exporter, pour faire très simple, c'est un bout de code coincé dans une boucle infinie.
Oui, très simple.
Il va récupérer de l'information et la transmettre à Prometheus, puis récupérer de l'information et la transmettre à Prometheus, puis récupérer de l'information...

Exemple

Ici, on va pondre un bout de code qui va aller récupérer le nombre de comptes que je follow sur Mastodon :
r = requests.get("https://diaspodon.fr/api/v1/accounts/1")
data = json.loads(r.content.decode())
metric = Metric('following_count', 'Number of following account', 'gauge')
metric.add_sample('following_count', value=data["following_count"], labels={})
yield metric
Ce qu'il faut comprendre :
- La variable r contient le retour de l'appel à l'API Mastodon.
- La variable data contient en utilisable le JSON contenu dans r.
- La variable metric contient les données exploitables par Prometheus.

C'est la ligne qui est vraiment cruciale :
metric.add_sample('following_count', value=data["following_count"], labels={})
Les choses importantes :

- following_count sera le nom que vous pourrez retrouver dans Prometheus pour afficher la donnée
- value sera la valeur retournée quand vous appelez following_count

Lancer la boucle infinie

On va coincer ce bout de code dans une boucle :
class JsonCollector(object):
    def __init__(self):
        pass

    def collect(self):

        url = mastodon_host + 'api/v1/accounts/1'
        r = requests.get(url)
        data = json.loads(r.content.decode())
        metric = Metric('following_count', 'Number of following account', 'gauge')
        metric.add_sample('following_count', value=data["following_count"], labels={})
        yield metric

if __name__ == "__main__":
    start_http_server(9400)
    REGISTRY.register(JsonCollector())
    while True: time.sleep(1)
Et c'est tout quant à la création d'un Exporter ! Retrouvez le lien vers le code complet en fin de ce billet. Ou . Pour plus de visibilité, j'ai volontairement caché les modules à inclure.

Comment valider que ça fonctionne ?

Un curl et tout va :
root@server ~ # curl localhost:9400
# HELP following_count Number of following account
# TYPE following_count gauge
following_count 552.0

Brancher l'exporter à Prometheus

Tout va se faire, comme d'habitude, dans le prometheus.yml.

  - job_name: 'mastodon'
    static_configs:
      - targets: ['localhost:9400']
On ajoute le job, la target avec son port et on reload la bête.

Notez que j'ai utilisé le port 9400 dans mon exemple. C'est un choix personnel : vous pouvez le changer s'il est déjà utilisé par un de vos services.

Enfin, si tout s'est bien passé, vous devriez pouvoir appeler la variable following_count dans Prometheus !


Vous trouverez un snippet avec l'intégralité du code par ici.

Je retourne à mon code. Vous vous doutez bien qu'avez tout ça, il y a moyen de faire un bel Exporter complet pour Mastodon !

Des bisous,

Installer mysqld_export pour Prometheus et Grafana

Rédigé par dada / 12 février 2018 / Aucun commentaire


Grafana, c'est mon dada (!) du moment. Après l'avoir installé pour avoir une vision d'ensemble de l'état de mes serveurs, voici l'heure de se pencher sur l'état d'un service en particulier : MariaDB

Je vous redirige vers l'article pour installer Grafana, Prometheus et node_exporter si ça vous intéresse.

Installer mysqld_exporter

On va commencer par récupérer l'exporter :
wget https://github.com/prometheus/mysqld_exporter/releases/download/v0.10.0/mysqld_exporter-0.10.0.linux-amd64.tar.gz 
Et on va le placer au chaud dans l’arborescence :
mkdir /opt/prometheus_exporters
tar zxf mysqld_exporter-0.10.0.linux-amd64.tar.gz -C /opt/prometheus_exporters
L'exporter est en place. Ce n'est pas plus compliqué que ça. Passons à la configuration.

Configuration du mysqld_exporter

Il a besoin d'une seule chose : un utilisateur dédié avec les bons droits.
GRANT REPLICATION CLIENT, PROCESS ON *.* TO 'userdelexporter'@'localhost' identified by 'pwddelexporter';
GRANT SELECT ON performance_schema.* TO 'userdelexporter'@'localhost';
FLUSH PRIVILEGES;
On va ajouter ces informations dans un .my.cnf que l'on va passer en paramètre à l'exporter :
[client]
user=userdelexporter
password=pwddelexporter
J'ai choisi de placer ce .my.cnf dans /opt/prometheus_exporters pour ne pas le perdre, mais vous pouvez le mettre ou vous voulez.

Lancer l'exporter

On va déjà le tester :
root@diaspote /opt/prometheus_exporters/ # ./mysqld_exporter -config.my-cnf=".my.cnf"
INFO[0000] Starting mysqld_exporter (version=0.10.0, branch=master, revision=80680068f15474f87847c8ee8f18a2939a26196a)  source="mysqld_exporter.go:460"
INFO[0000] Build context (go=go1.8.1, user=root@3b0154cd9e8e, date=20170425-11:24:12)  source="mysqld_exporter.go:461"
INFO[0000] Listening on :9104                            source="mysqld_exporter.go:479"
Si vous avez ce retour, sans erreur, vous avez réussi l'installation de la bête.

Configurer Prometheus

Ajoutez ces quelques lignes à votre prometheus.yml pour qu'il sache récupérer les informations :
  - job_name: 'mysql'
    # If prometheus-node-exporter is installed, grab stats about the local
    # machine by default.
    static_configs:
      - targets: ['lipdemonserveuraveclexporter:9104']
Rechargez la configuration et le tour est joué :
root@dadall:/home/dada# curl -X POST http://localhost:9090/-/reload 
 Prometheus devrait signaler que tout va bien :



Il ne reste plus qu'à lancer tout ça en tâche de fond en ajoutant une esperluette à la fin de la commande précédente :
root@diaspote /opt/prometheus_exporters/ # ./mysqld_exporter -config.my-cnf=".my.cnf" &

Configurer un dashboard pour Grafana

Pour le dashbaord, sans honte, j'ai pompé sur celui de Perconna que vous pouvez trouver ici. Il est largement suffisant. Prenez quand même bien soin de vérifier que le nom de la data source corresponde bien avec la votre. Je me suis arraché les cheveux parce que la mienne s'appelle prometheus et cette du JSON s'appelle Prometheus. La majuscule, quoi.



Et voilà, le tour est joué. Amusez-vous bien !

N'hésitez pas à me suivre sur Mastodon et/ou diaspora*  pour me lire lutter avec cette stack ! :-)

Installer Grafana, Prometheus et Node Exporter

Rédigé par dada / 31 janvier 2018 / 18 commentaires




Le monitoring, j'aime à dire que c'est ce que l'administrateur a de plus pervers : surveiller, voir et savoir tout ce qui se passe sur ses machines, sans limite, et de la façon qui lui est la plus agréable possible. Un admin, c'est un stalker, en fait.

De mon côté, après avoir testé Facette, Monitorix, Netdata et Munin, je joue en ce moment avec Grafana, Prometheus et les exporters qui vont avec. C'est l'objet de ce billet, ça tombe bien, alors voyons comment faire pour installer tout ça en quelques minutes.

Comprendre l'installation en quelques lignes

Vos serveurs vont avoir un exporter simple : le Node Exporter, qui va permettre à Prometheus de récupérer les différentes métriques qu'il partage. La bonne pratique consiste à installer Prometheus sur une serveur qui sera dédié à la collecte des informations. Si vous installez tout sur une seul et même machine, vous pourrez mettre du localhost dans presque tout ce qui suit. Grafana, quant à lui, va afficher ses données avec des jolies couleurs et dans des jolis graphiques.

Installer Prometheus

Pas de piège pour une Debian Stretch :
apt install prometheus 
C'est un peu plus compliqué pour une Jessie :
apt -t jessie-backports install prometheus 
Notez qu'essayer de lancer le service sous Jessie via systemd est foireux : il faut utiliser la bonne vieille méthode :
/etc/init.d/prometheus start 
Si vous ne faites pas ça et que vous avez des soucis, genre un service qui écoute déjà sur le 9090, vous ne verrez rien dans les logs.

A partir de là, vous devriez pouvoir accéder à Prometheus en tapant sur le port 9090 de votre serveur.



Quoi ? Jamais j'ai écrit que Prometheus était sexy ;-)

Installer Node Exporter

Prometheus ne sait pas collecter d'informations tout seul. Il lui faut des exporters. Le plus simple et le plus complet pour avoir une vision global de la situation d'une machine (CPU, RAM, Load, traffic, etc) est le bien nommé Prometheus Node Exporter. Pour l'installer :
apt install prometheus-node-exporter

Configurer le Node Exporter dans Prometheus

Maintenant que les deux premiers outils sont installés, il va falloir les faire bosser ensemble. On va simplement déclarer dans la configuration de Prometheus qu'il doit se mettre d'accord avec l'exporter :
vim /etc/prometheus/prometheus.yml
scrape_configs:
  - job_name: 'prometheus'

    scrape_interval: 5s
    scrape_timeout: 5s

    static_configs:
      - targets: ['localhost:9090']

  - job_name: 'node'
    static_configs:
      - targets: ['monserveur:9100','monserveurdeux:9100']

L'exemple de configuration ci-dessus est quasiment celle de base. Il faut noter que le job_name 'prometheus' est là pour expliquer que Prometheus est en local. Quant au job_name 'node',  il fait comprendre à Prometheus que le Node Exporter est présent sur les hosts cités entre crochets.

On sauvegarde tout ça et on recharge la configuration de Prometheus avec le curl qui va bien :
curl -X POST http://localhost:9090/-/reload
Si vous n'avez pas d'erreur, on va enfin s'attaquer à la partie artistique de l'opération : les graphiques !

Installer Grafana

L'installation est, là aussi, triviale :
apt-get install grafana 
C'est 'achement difficile, tout ça, hein ?

Configurer Nginx

Pour ne pas avoir à toujours taper le port de Grafana, voici un bout de conf pour Nginx :
server {
    listen 80;

        root /var/www/html/;

        server_name grafana.monserveur.tld;

        location / {
                proxy_set_header X-Real-IP $remote_addr;
                proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
                proxy_set_header Host $http_host;
                proxy_redirect off;
                proxy_pass http://127.0.0.1:3000;
        }
}

Configurer Grafana

- Ajouter une data source

Grafana, ça marche tout seul. Une fois installé, il vit sa vie. Par contre, il va falloir le brancher à Prometheus, tout de même.
Comme blablater, c'est chiant, voici une capture d'écran de ce que vous devez faire :



En commentaire : cliquez sur le menu en haut à gauche de Grafana pour ajouter une nouvelle data source et récupérer les informations que vous voyez dans la capture.
Vous remarquerez que le port mis en place est bien celui de Prometheus et pas celui du Node Exporter : Grafana ne communique pas avec Node Exporter (sur le port 9100), mais uniquement avec Prometheus.

On arrive à la fin. Maintenant que l'exporter balance des informations, que Prometheus en est conscient et que Grafana arrive à échanger avec Prometheus, on va pouvoir mettre en place un dashboard pour profiter des graphiques !

- Installer le dashboard Node Exporter Full

Ici, c'est aussi simple (mais pourquoi est-ce que je m'emmerde à écrire ce billet si c'est si simple ?!), pour installer un dashboard, allez dans le Menu de Grafana, puis Dashboard et enfin Import. Je dis bien Import, pas New. Enfin, ajoutez le nombre 1860 dans la premier champ pour faire apparaître la fenêtre suivante :



Bon, j'ai aussi cliqué n'importe-où sur la fenêtre pour que Grafana prenne en compte la nouvelle information et, finalement, affiche la capture ci-dessus.

On a fait le tour. Tout est bon. Vous pouvez aller sur la page d'accueil de Grafana, cliquer sur le nom de votre nouveau dashboard et profiter du spectacle !