Qu’est-ce que Saltstack ?

Saltstack est un outil de gestion de configuration de vos systèmes afin de la rendre pour facile à administrer.

Installation Salt

Salt est un outil qui permet d’administrer autant de serveurs que possible en quelques ligne de commande sans aucune limite.
Il vous sera possible d’installer des paquets avec une seule commande, manager différents vhost, gérer vos utilisateurs,… depuis un seul serveur.

En utilisant Salt, nous utiliserons à minima 2 serveurs dont l’un est le master (Parent) et l’autre est un minion (Enfant).
L’installation s’effectue sur les système via les commandes suivantes :

# Installation de python et mise à jour du système
apt-get install python-software-properties
apt-get update

# Système master
master:~$ apt-get install salt-master

# Système minion
minion_one:~$ apt-get install salt-minion

Le minion connaît le master par son nom d’hôte ou son adresse IP afin d’intercepter ces requêtes.
Le master connaît le minion par son nom d’hôte.
Les minions peuvent aussi être identifiés par critère (système d’exploitation, regexp, …).

Adresse IP du master.

Adresse IP du 1er minion.


Configuration Salt

On configure d’abord le minion avec l’adresse IP du master et on redémarre le service :

minion_one:~$ vim /etc/salt/minion
# Set the location of the salt master server, if the master server cannot be
# resolved, then the minion will fail to start.
master:192.168.0.10

On configure ensuite l’interface du master avec l’adresse IP du master et on dé-commente la configuration file_roots :

master:~$ vim /etc/salt/master
interface:192.168.0.10

# The file server works on environments passed to the master, each environment
#...
# Example:
file_roots:
  base:
    - /srv/salt/states

On redémarre le service sur les différents serveurs :

minion_one:~$ service salt-minion restart
master:~$ service salt-master restart

La communication entre master et minion s’effectue à partir de clé md5.
On va donc lister les clés afin d’identifier notre minion puis valider sa clé:

master:~$ salt-key -L
Accepted Keys:
Unaccepted Keys:
master
minion_one
Rejected Keys:

master:~$ salt-key -a minion_one

Valider toutes les clés sans préciser le hostname_minion.


Utilisation Salt

Salt est maintenant opérationnel et nous pouvons commencer à l’utiliser via la commande __salt_ :

# Ping vers un seul minion
master:~$ salt \minion_one test.ping
minion_one:
    True

# Récupérer l'usage des disque des mininons
master:~$ salt '*' disk.usage

# Connaître l'OS des minions
master:~$ salt '*' cmd.run 'uname -a'

Commandes utiles pour Salt

Salt dispose de commandes adaptées à une majeure partie des actions que vous serez amener à effectuer sur vos différents serveurs.
L’avantage est de pouvoir exécuter nos actions sur tous vos serveurs minions en même temps.
Voici une liste non exhaustive de commandes utiles :

# Installation d'un ou plusieurs paquets
master:~$ salt '*' pkg.install apache2
master:~$ salt '*' pkg.install pkgs='["curl", "vim"]'

# Mise à jour OS et des paquets
master:~$ salt '*' pkg.list_upgrades
master:~$ salt '*' pkg.upgrade
master:~$ salt '*' pkg.refresh_db

# Afficher la version d'un paquet
master:~$ salt '*' pkg.version

# Redémarrer un service
master:~$ salt '*' service.restart nom_service;

# Créer un fichier
master:~$ salt '*' cmd.run "touch fichier.txt"

Fichier states

Salt est un véritable gestionnaire de configuration dès que l’on commence à définir des fichiers states qui vont être sont l’empreinte de vos serveurs minions.
Ces fichiers localisés dans le dossier /srv/salt/ sont au format YAML.

Par exemple, imaginons un système avec des serveurs minion sur lequel on veut installer Apache puis démarrer ce service :

master:~$ vim /srv/salt/states/apache/init.sls
apache:
  pkg:
    - installed
  service:
    - running

ID du state.

Déclaration du module pkg.

Fonction installed du module pkg (remplaçable par pkg.installed).

Déclaration du module service.

Fonction running du module service.

Nous testons notre commande afin que les serveurs minion l’interprètent :

master:~$ salt '*' state.sls apache test=true
minion_one:
----------
          ID: apache
    Function: pkg.installed
      Result: None
     Comment: The following packages are set to be installed/updated: apache.
     Changes:   
----------
          ID: apache
    Function: service.running
      Result: False
     Comment: The named service apache is not available
     Changes:   
Summary
------------
Succeeded: 0
Failed:    1
Not Run:   1
------------
Total:     2

Le test indique qu’Apache n’est ni installé ni en service et nous pouvons relancer la commande sans faire de test :

master:~$ salt '*' state.sls apache

Voici un autre exemple pour remplacer le paquet nano par __vim___ :

master:~$ vim /etc/salt/vim/init.sls
vim:
  pkg:
    - installed
nano:
  pkg:
    - removed

On va maintenant combiner nos 2 states apache et vim :

master:~$ salt '*' state.sls apache,vim

Enfin, nous aurions pu procéder par une mise à jour globale de la configuration de nos minions.
On va donc éditer le fichier principal top.sls situé dans le dossier des __pillars_ :

master:~$ vim /srv/salt/top.sls
base:
  '*':
    - apache
 'minionnew*':
    - vim

Cette configuration exécutera le state apache pour tous les minions et le state vim pour tous les minions dont le hostname ou ID commence par minionnew.
La fonction state.highstate va permettre de lire tous les states à appliquer dans /srv/salt/top.sls :

master:~$ salt '*' state.highstate

Vote