Gérer un système n'est jamais simple, en gérer plusieurs devient plus compliqué, et la difficulté augmente avec le nombre. En plus de prendre du temps lors de l'installation initiale, et lors de la modification de la configuration, gérer des systèmes manuellement facilite l'apparition de nombreux problèmes : erreurs de manipulation, oublis, etc.

Je décris ici la manière dont je mets en place Salt, un gestionnaire de configuration, sur un système Debian. Les gestionnaires de configuration permettent d'automatiser en grande partie, et d'uniformiser, la configuration d'un parc de machines. Cette configuration des machines est ainsi décrite dans des fichiers de manière centralisée, et déployée automatiquement sur tous les systèmes dont ils ont la gestion.

Note : Il est aussi possible de l'utiliser sans configuration écrite, juste comme outil d'exécution de commandes. Salt permet de lancer l'exécution des commandes sur un ou plusieurs systèmes depuis le master.

Prérequis

Salt étant encore assez jeune, il n'est disponible dans les dépôts standard de Debian que depuis Jessie. Des paquets sont présents dans les dépôts squeeze-backports-sloppy et wheezy-backports, mais comme ce sont des versions peu avancées, je préfère utiliser le dépôt de Salt directement, qui dispose des dernières versions. Afin d'uniformiser la version de Salt utilisée sur toutes les machines, j'utilise aussi ce dépôt pour les systèmes Debian Jessie.

$ # Ajout de la clé GPG du dépôt de Salt
$ wget -O - http://debian.saltstack.com/debian-salt-team-joehealy.gpg.key | sudo apt-key add -
$ # Ajout du dépôt de Salt
$ echo "deb http://debian.saltstack.com/debian <RELEASE>-saltstack main" | sudo tee /etc/apt/sources.list.d/salt.list
$ sudo apt-get update

Note : Sous Debian Squeeze, il est aussi nécessaire d'activer les dépôts backports, afin de satisfaire les dépendances des paquets de Salt.

Note : Les fichiers de configuration de Salt sont tous au format YAML.

Mise en place du serveur central : le Master

Installation

Sous Debian, il faut installer le paquet salt-master. Comme ma configuration est gérée dans un dépôt git, je dois aussi installer le paquet python-git.

$ sudo apt-get install --no-install-recommends salt-master python-git

Configuration

Salt permet de gérer la configuration dans des fichiers supplémentaires, situés dans le répertoire /etc/salt/master.d/. Cela évite de modifier le fichier de configuration installé par le paquet.

Je crée donc un fichier nommé /etc/salt/master.d/local.conf, dans lequel je déclare que la configuration est gérée dans un dépôt git, dont je définis l'adresse. D'autres paramètres sont aussi définis, comme le répertoire dans lequel se trouvent les configurations (states) dans le dépôt, et le dépôt git contenant les données spécifiques de chaque système (pillars).

# Define the provider to be used for gitfs
gitfs_provider: gitpython

# Define git as fileserver backend
fileserver_backend:
  - git

# Define git configuration repository URL
gitfs_remotes:
  - git@git.example.com:salt/states

# Define the root directory of the states inside the git repository
gitfs_root: <states/dir>

# Define the pillar git repository URL and the root directory where to find pillars inside the repository
ext_pillar:
  - git: master git@git.example.com:salt/pillar root=pillar

Le master va réglièrement vérifier les mises à jour sur le dépôt git. Lorsqu'une modification est poussée sur le dépôt git, il n'est donc pas obligatoire de se connecter sur le serveur Salt pour que sa configuration soit mise à jour. Si nécessaire, la mise à jour manuelle du cache git du serveur salt peut être forcée en utilisant cette commande :

$ sudo salt-run fileserver.update

Mise en place du client sur les autres systèmes : le Minion

Définition de l'identifiant et du master

Dès l'installation du paquet, le démon salt-minion est lancé, et s'inscrit sur le master en lui envoyant son certificat. L'identifiant par défaut est le nom de domaine (FQDN) du système. Il est possible de définir un identifiant spécifique avant l'installation, dans le fichier /etc/salt/minion_id.

Si le nom salt n'est pas résolu depuis le système à gérer, ou s'il ne correspond pas à la machine hébergeant le master, il est possible de définir un autre nom à utiliser, dans le fichier /etc/salt/minion.d/local.conf.

master: salt.example.com

Installation

Pour le minion de Salt, le paquet à installer est salt-minion. Le paquet python-apt est nécessaire pour permettre au minion de gérer les paquets du système Debian.

$ sudo apt-get install --no-install-recommends salt-minion python-apt

Les grains

Les grains sont des valeurs spécifiques données par le minion au master. Elles peuvent être utilisées dans les states pour définir l'application, ou non, de certains paramètres.

Les valeurs de grains spécifiques peuvent être définies dans le fichier /etc/salt/grains. Par exemple :

roles:
  - <role_name_1>
  - <role_name_2>

Configuration

Gestion de la liste des minions

Depuis le master, il est possible de lister, accepter, ou supprimer, des minions de la liste. Accepter un minion est nécessaire pour autoriser le master de communiquer avec lui.

$ sudo salt-key -l all # Lister les minions
$ sudo salt-key -a <minion-name> # Accepter un minion
$ sudo salt-key -A # Accepter tous les minions en attente
$ sudo salt-key -r <minion-name> # Refuser un minion
$ sudo salt-key -d <minion-name> # Supprimer un minion de la liste

Configuration du firewall

Pour autoriser l'accès au master dans le firewall, il suffit d'ouvrir les ports 4505 et 4506 en TCP.

Par exemple, avec iptables :

-A INPUT -m state --state new -m tcp -p tcp --dport 4505 -j ACCEPT
-A INPUT -m state --state new -m tcp -p tcp --dport 4506 -j ACCEPT

Écriture des States

La plus grosse partie du travail de mise en place de Salt est la configuration des states. Cette configuration est spécifique à chaque parc de machines, et évoluera nécessairement au cours du temps.

Le seul fichier obligatoire dans le répertoire des states est nommé top.sls. C'est le seul fichier chargé par Salt lors du déploiement des configurations. Il est est utilisé pour charger d'autres states, qui contiendront, eux, les configurations à appliquer aux machines.

base:
  '*':
    - common
  '*-master':
    - master

Note: Dans cet exemple, le state common (donc le fichier common.sls ou common/init.sls, selon l'organisation du répertoire), est chargé pour toutes les machines. Le state master est par contre chargé uniquement pour les machines dont l'identifiant termine par -master.

Les autres states sont des fichiers avec l'extension .sls présents dans le répertoire des states, ou ses sous-répertoires.

Un répertoire de states doit obligatoirement contenir un fichier nommé init.sls.

La configuration des states est expliquée en détail dans la documentation officielle de Salt.

Diffusion automatique des configurations

Il est possible de paramétrer une tâche planifiée, pour diffuser automatiquement les configurations à intervalle régulier. De cette manière, on peut juste modifier le dépôt git de configuration, et les modifications sont appliquées automatiquement sur les systèmes gérés par Salt.

Depuis le master, je force la mise à jour du dépôt de configuration, et des pillars avant de lancer la mise à jour de tous les minions.

0 * * * * /usr/bin/salt-run fileserver.update ; /usr/bin/salt '*' saltutil.refresh_pillar ; /usr/bin/salt '*' state.highstate

Depuis les minion qui ne fonctionnent pas en mode démon, on peut aussi lancer la mise à jour du pillar de ce minion, puis de la configuration du système complet.

0 * * * * /usr/bin/salt-call saltutil.refresh_pillar ; /usr/bin/salt-call state.highstate

Versionner les configurations utilisateur

dim. 01 sept. 2013 by Marmotte

J'utilise régulièrement plusieurs ordinateurs. Avec le temps, je configure donc ces machines selon mes habitudes, afin de rendre leur utilisation plus simple et efficace pour moi.

Comme pour les notes d'installation, j'ai donc dupliqué les fichiers de configuration d'un ordinateur à l'autre, faisant des corrections sur chacun, sans forcément toujours …

read more