samedi 21 décembre 2013

Monitoring des CPU de plusieurs serveurs Linux dans un seul et même shell : initiation à l'administration serveur sous SALT

Si vous suivez ce blog, vous connaissez ma passion pour le monitoring, que ce soit sous Windows, Linux ou Mac.

J’adore avoir un bureau qui ressemble à un centre de contrôle spatial avec 4 écrans qui affichent des graphiques et htop à gogo ! ;-)

Seulement voilà, lorsque l’on est en voyage, difficile de se balader avec suffisamment d’écran que pour pouvoir afficher l’état des CPU de chaque serveur.

Si le monitoring réseau de tous les serveurs peut fort bien se centraliser dans une seule console, c’est nettement plus compliqué d’avoir un visuel sur le consommation CPU de tous les serveurs.

Nous allons donc aujourd’hui mettre en place un système d’alerte visuelle qui va nous informer des montées en charge anormale d’un parc serveurs.

Le but est à la fois pratique (car c’est utile quand même [^_*]), mais aussi ludique et éducatif, puisque l’on va un peu apprendre à coder en shell bash Linux et à installer Salt, qui permet la gestion d’un parc via une console centrale.



Première étape le bash de monitoring du CPU


Bon, d’abord je vous mets en garde : je ne suis pas un Dieu du code bash Linux ni de l'administration réseau/système.

Que les puristes me pardonnent, je suis un humble geek qui bidouille quand il a besoin et pour se détendre, mais sans plus.

L’idée ici est donc de recevoir une alerte visuelle en cas de vraie montée anormale.

Pas besoin de visualiser une alerte à chaque fois que le serveur chauffe un peu.

L’idée est que si on a une montée réelle pendant +/- 2 minutes, vous voyez apparaitre une info, qui vous donnera :
  • Le nom du serveur
  • Les 3 processus qui sont la source de cette consommation anormale

Voici donc le script :

#!/bin/bash
#cpu_moni.sh
# Auteur: Brice Cornet http://www.ihaveto.be
#Visualiser les montées en charge d'un CPU via des alertes

#Initiatisation de la limite du CPU

cpumax=80

#Initialisation du compteur de débordement du CPU
cpt=0

#Initialisation du compteur limite de débordement du CPU
#Car cela ne sert à rien d'alerter à chaque montée encharge
: on alerte juste si c'est répétitif
limite=5

#On boucle en continu
while true
   do
    #Tant que le CPU n'a pas été testé plafonnant à la limite CPU pendant +/- 2 minutes
    while test $cpt != $limite;
        do   
            #Pause pour ne pas fatiguer le CPU ;-)           
            sleep 25
            #Si limite CPU atteinte on incrémente le compteur
            if ! ps -e -o pcpu | awk '{c+=$1} END {if(c>$cpumax) exit 1;}'; then
             cpt=$((cpt+1))   
            fi
            #Mais on vérifie ensuite que ce n'était pas une montée temporaire
            sleep 5
            if ! ps -e -o pcpu | awk '{c+=$1} END {if(c<$cpumax) exit 1;}'; then
            #Si montée temporaire on remet le compteur de limite à 0
             cpt=0   
            fi
        done

       #Si alerte, on récupère le nom du serveur
           srv=$(uname -n)
      
       #Et on affiche le message avec les infos
       echo
       echo ---------- CPU alert on server [ $srv ] ------------------------------
       echo
       date
       echo  
       ps aux | sort -k 3,3 | tail -n 3
      
           #Enfin, on remet le compteur à zéro
       cpt=0
   
   done

Salt : la console de gestion centralisée des serveurs Linux / Unix


Salt est composé de deux éléments :
  • Salt-master : qui est le serveur centrale qui pilote les serveurs escalves
  • Salt-minion : les esclaves qui sont tout migons #lol #jAiMangéUnClown

Donc côté console centrale nous installons via :
sudo apt install salt-master

et côté esclave
sudo  apt install salt-minion

Ensuite, nous allons configurer le minion pour lui indiquer qui est son maître.

Le fichier de configuration est bien entendu : /etc/salt/minion
master : Hostname_du_Master
id : Hostname_du_Minion


Il est à noter que vous pouvez définir plusieur Master, ce qui pratique pour pouvoir administrer depuis son laptop :
master :
-    Hostname_premier_Master
-    Hostname_deuxième


Ensuite : roulez jeunesse côté Master via
/etc/init.d/salt-master start

Et côté Minion via:
/etc/init.d/salt-minion start

Nous avons donc ici un Master qui entend des Minion l’appeler.

Pour visualiser cela (et les autoriser à se connecter), nous lançons :
sudo salt-key –L

Et bing : on voit la liste des Minion en attente :-)

Pour accepter ces mignons Minions :
sudo salt-key  –A

Voilà ! C’est fini !

Bon, on va quand même tester si ça marche via la commande:
salt ‘*’ test.ping

et devant vos yeux remplis de joie, vous verrez chaque Minion répondre True.

Utiliser Salt pour voir les résultats de notre script sur tous les Minion

Simple comme bonjour, à condition d’avoir placé notre script sur tous les Minion :
salt '*' cmd.run 'sh /tmp/cpu_moni.sh'

Bon, si on est malin, on va d’ailleurs utiliser Salt pour déployer cpu_moni.sh sur tous les mignons. Puisqu’il faut être malin, j’avoue que j’ai un peu galéré ;-)

La première étape est de distribuer le script que nous avions créé sur tous les Minion.

Il faut donc d’abord éditer le fichier de configuration du Master pour définir un dossier de partage. C’est dans ce dossier que nous placerons le script à transmettre aux Minion.

Donc, éditer : /etc/salt/master

file_roots :
base :
-    home/salt/share2minion


Ensuit placez le script cpu_moni.sh, puis déployez le sur tous les Minions :

Pour ce faire on utilise :

cat copy_cpumoni.sls
/tmp/cpu_moni.sh :
file :
-    managed
-    source : salt://cpu_moni.sh

Conclusion

Vous avez vu les bases : à vous de jouer.

Pour ce faire, cfr la doc officielle de Salt sur http://docs.saltstack.com/topics/installation/debian.html

Bonne bidouille à tous et toutes ! 

Aucun commentaire:

Publier un commentaire