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
