Skip to content

Gestion de serveurs avec SaltStack

saltstack-Quand on administre plusieurs serveurs, il y a des tâches qu’on effectue sur chacun d’eux de manière répétées. Quand on a 2 ou 3 serveurs, ça va, mais quand on gère 10, 100 ou 1000 serveurs, la tâche est impossible.

Saltstack est un gestionnaire de configuration, de provisionning, de commande à distance et de déploiement de fichier. Autant dire, il vous sauvera la vie.

Dans cet exemple, nous verrons comment déployer une configuration complète sur des serveurs Debian 8 et effectuer des tâches sur ces serveurs. Dans mon exemple, je n’utiliserai pas des centaines de serveurs, mais le principe reste le même.

Avant de commencer, il faut comprendre le fonctionnement de Salt (ou Saltstack), il fonctionne sous le mode Master (chef) et Minion (esclave), comme dans ce schéma :

diagram-basic1

Les minions et le master s’identifient par clé privée, communiquent via ZeroMQ et échange des informations chiffrées en AES. Le Master (Linux) contrôle ses Minions (Debian, Ubuntu, Windows Servers, RedHat, CentOS…). Il est également possible d’avoir plusieurs Masters ou d’utiliser salt-minion sans aucun master.

Voici les étapes :

– Installation et découverte
– Mis en place d’une configuration simple
– Allez plus loin avec Salt
– Conclusion

I – Installation et découverte de Saltstack

Il existe un script tout en un pour installer Saltstack sur n’importe quel OS, cependant, la version peut différer,  je préfère donc ajouter le dépôt à mes serveurs :

wget -O - https://repo.saltstack.com/apt/debian/latest/SALTSTACK-GPG-KEY.pub | sudo apt-key add -
echo "deb http://repo.saltstack.com/apt/debian/latest jessie main" > /etc/apt/sources.list.d/saltstack.list

On va donc installer Salt-master sur un premier serveur, puis Salt-minion sur deux autres.

apt-get update ; apt-get install salt-master # sur le Master
apt-get update ; apt-get install salt-minion # sur les Minions

On va maintenant éditer le fichier de configuration des minions, afin de leur renseigner leur master. Pour cela on ouvre le fichier /etc/salt/minion (avec Vim bien sûr).

 master: master.your-domain.io

(N’oubliez pas le premier espace avant le mot « master:« )

Faites donc ceci sur vos deux serveurs,  on peut ensuite se rendre sur notre Master afin d’accepter les clés de nos minions :

salt-key -L # liste les clés
salt-key -a minion1 # accepte minion1
salt-key -a minion2 # accepte minion2

Voici donc ce que ça devrait rendre :

Sélection_004

Maintenant que nos deux minions sont gérés par notre master, on va pouvoir commencer à s’amuser (enfin me diriez-vous) :

salt '*' test.ping # on vérifie que nos minions répondent
salt '*' cmd.run `uname -a` # lancer une commande sur tous les minions
salt '*' cmd.run `echo "Le master me controle mouahahah"`
salt minion1 network.ipaddr eth0 # donne l'IP d'eth0

salt_cmdrun

On constate donc qu’on peut déjà lancer des commandes sur nos deux minions simultanément, avoir des informations sur leurs réseaux ou vérifier qu’ils sont bien up (test.ping).

II – Mis en place d’une configuration simple

Maintenant qu’on a vu comment lancer des commandes sur nos serveurs, il est intéressant de déployer une configuration minimal sur ces serveurs afin de leur garantir un même état et une certaine cohérence (même version de paquets, même fichier de configuration, même utilisateurs admins …)

Pour cela, nous allons utiliser des States.
Il s’agit de fichier texte en YAML (Yes Another Markup Language !!) assez simple à lire et à comprendre où on décrit l’état voulu pour notre serveur.

Le placement de ses fichiers doit être structuré afin de garantir une certaine cohérence.

Ces states, de base, se trouvent dans /srv/salt. Dans ce dossier, nous allons créer notre première state, nommé server.sls.

us_locale:
  locale.present:
    - name: en_US.UTF-8
default_locale:
  locale.system:
    - name: en_US.UTF-8
    - require:
      - locale: us_locale
sshusers:
  group.present:
    - gid: 1500
    - system: True
ssh:
  service:
    - running
    - enable: True
    - watch:
      - file: /etc/ssh/sshd_config
/etc/ssh/sshd_config:
 file.managed:
    - source: salt://server/sshd_config
    - user: root
    - group: root
    - mode: 644

Je vais donc expliquer rapidement ce que fait ce fichier.
Tout d’abord, il applique la locale en_US.UTF-8 au système, il va vérifier ensuite la présence du groupe sshusers, que le service SSH est correctement démarré et se lancera au démarrage (enable: True) en vérifiant que le fichier sshd_config n’ait pas été modifié. Le dernier bloc déploie le fichier sshd_config depuis le master (source:).

Maintenant que notre fichier se trouve dans /srv/salt/server.sls, on va pouvoir tester notre configuration sur les minions. Cela se réalise avec cette commande :

salt '*' state.sls server

salt_sls

En quelques secondes, nos deux serveurs se retrouvent avec notre configuration d’appliquée. Par rapport à la commande state.sls server, on utilise « server » car on a appelé notre fichier ainsi, par exemple si on créer le fichier dans /srv/salt/configuration/server.sls, on lancera la commande suivante :

salt '*' state.sls configuration.server

J’espère avoir été clair quand au nommage des States, pour plus d’information n’hésitez pas (et vous serez sûrement obligé) de vous référer à la documentation (très bien faite).

Grâce à cette configuration minimal, on peut garantir sur nos minions (quelque sois le nombre) que SSH tourne correctement et que les locales sont bien fixés.
Cependant, l’administration d’un serveur ne se résume pas à ces deux tâches, nous allons donc voir comment aller plus loin.

III – Allez plus loin avec Salt

Actuellement, nous savons lancer des commandes sur nos minions et leur appliquer une configuration depuis un fichier texte. C’est déjà un bon début, mais pour allez plus loin nous allons voir comment « décrire son environnement Salt » grâce au fichier top.sls.

Ce fichier, placé dans /srv/salt/top.sls, permet à Salt de savoir quelle configuration appliquer à quel minion. Nous allons prendre un exemple très simple :

'*':
  - server

Le fait de renseigner cela dans top.sls permet de dire que tous nos minions (qu’elle qu’ils soient) possèdent la configuration server.

Maintenant, on peut appliquer les configurations (en se basant sur top.sls) avec cette commande :

salt '*' state.highstate

Le Highstate est en quelque sorte l’application de l’état d’écrit dans le fichier top.sls.

Une autre manière qui produit presque le même résultat est la commande state.apply.

Voici la sortie d’un Highstate qui exécute pas mal de States (c’est la configuration minimal serveur que j’utilise) :

salt_highstate

Voici mon fichier top.sls :

base: 
 '*':
 - server   # Installe une state serveur minimal
 - apt  # Configure APT
 - server.pkgbase  # Installe tout les paquets nécessaires 
 - network  # Configure le réseau sur les serveurs
 - ntp  # Configure NTP
 - postfix  # Configure Postfix
 - admins  # Ajoute les admins et leurs clés SSH
 - monit  # Configure Monit (supervision de services)
 - observium  # Configure le SNMP pour Observium
 - logs  # Installe Beaver (python-pip) pour les logs dans ELK
 - telegraf  # Installe Telegraf pour les métriques dans Grafana

Maintenant que mon serveur est correctement configuré (grâce au Highstate), je vais pouvoir déployer des services dessus, toujours grâce à Salt.

Par exemple, pour installer un serveur Web (cela implique que les States soient présentes), je lance seulement la commande suivante :

salt_apachephp

Cela a donc installé Apache, PHP-Fpm et le MOD_PHP5 d’Apache (en une commande).
On peut donc vérifier sur le serveur que tout est prêt pour déployer mon site :

salt_apacheitwork

Ce qui est pratique avec Salt, c’est que vous n’aurez pas à écrire forcément toutes vos States, vous pourrez piocher facilement entre les différentes configurations trouvables sur le Web.

Par exemple, voici quelques dépôts GitHub intéressants pour Salt :

  • http://saltstarters.org/ => Le Google des recettes Salt
  • https://github.com/eon01/SaltStackCheatSheet => Le CheatSheet de Saltstack
  • https://github.com/saltstack-formulas => Des Formulas Salt
  • https://leanpub.com/saltstackfordevops => Un super bouquin sur Saltstack
  • https://github.com/valentin2105/Salt-Recipes => Mes recettes Salt
  • https://github.com/valentin2105/Salt-Network => Gérer le réseau avec Salt
  • https://github.com/valentin2105/ELK-Salt => Installer E.L.K avec Salt
Published inCLI ToolsDevOpsLinuxSaltstackTutoriel

2 Comments

  1. Merci pour tous ces liens.
    On utilise également SaltStack dans notre DC. L’avantage est qu’il existe aussi un agent Windows.
    Je l’ai utilisé récemment pour mettre à jour notre certificat ssl sur toutes nos machines. Je ne sais pas comment j’aurais fait sans…

    • Je n’ai jamais testé Saltstack pour Windows, mais content de voir que c’est efficient ! 😉
      Je te conseille vivement le livre « Saltstack for DevOps », très bien écrit et très clair.

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Proudly hosted with Open-sources Softwares.