Docker avec Salt

Docker est une technologie très en vogue en ce moment et qui bouleverse le déploiement traditionnel d’application. Ce nouveau concept, basé sur LXC, permet de créer des containers qui assurent la compatibilité de l’application entre le laptop du développeur et le serveur une fois en production.

La gestion de containers peut vite s’avérer complexe, surtout si on a une application qui en nécessite plusieurs. Nous allons voir dans cet article comment gérer des Dockers avec Saltstack afin de simplifier et d’automatiser le déploiement d’une application.

I – Installer Saltstack sur le serveur

Le but de ce tutoriel est de simuler le fait qu’on déploie une application sur un serveur virtuel de type Cloud (AWS, DigitalOcean …).

Salt sera utilisé en mode standalone, c’est-à-dire sans salt-master (cf Gestion de serveurs avec Saltstack). On va donc commencer en installant Salt sur notre serveur (salt-minion) afin qu’il s’occupe de notre déploiement.

Une fois le code Salt écrit, on pourra potentiellement déployer cette application sur des dizaines d’autres serveurs.

On va utiliser Salt-Bootstrap pour récupérer Salt peut importe la distribution choisie. C’est un script automatisé qui va installer la dernière version stable de Saltstack.

wget -O install_salt.sh https://bootstrap.saltstack.com
sudo sh install_salt.sh

(On évite les pipes depuis Internet ^^)

Salt devrait s’installer et se lancer tout seul en quelques minutes.

On va maintenant lui indiquer dans sa configuration qu’il va être utilisé en mode solo et qu’il devra utiliser des fichiers situés localement.

Pour cela on édite le fichier /etc/salt/minion :

file_client: local

Nous pouvons ensuite redémarrer Salt :

service salt-minion restart

Salt fonctionne alors en mode standalone, on peut par exemple se pinguer soit-même :

salt-call test.ping

II – Création de notre configuration Docker

Une fois que Salt est  correctement installé sur notre VPS, serveur, droplet, instance ou quoi que ce soit, on va devoir créer notre configuration pour déployer notre application Docker.

Je pars sur le principe que vous connaissez à minima le principe de Docker, pour en savoir plus, rendez-vous ici.

On va créer le fichier /srv/salt/docker.sls :

import-docker-key:
  cmd.run:
    - name: apt-key adv --keyserver hkp://p80.pool.sks-keyservers.net:80 --recv-keys 58118E89F3A912897C070ADBF76221572C52609D
    - creates: /etc/apt/sources.list.d/docker.list
/etc/apt/sources.list.d/docker.list:
  file.managed:
    - source: salt://docker.list

docker:
  pkg.installed:
    - name: docker-engine
service.running:
  - name: docker
  - require:
    - pkg: docker-engine

Cette première State permet d’installer Docker et de vérifier que son service est démarré.

On doit créer le fichier docker.list (dans /srv/salt) et le remplir avec la bonne ligne, exemple pour Debian 8 :

echo "deb https://apt.dockerproject.org/repo debian-jessie main" > /srv/salt/docker.list

On va maintenant créer la state app.sls qui va déployer notre application Docker :

repo/mon_app:
  dockerng.image_present:
    - force: true
    - name: repo/mon_app:latest

mon_app:
  dockerng.running:
    - name: mon_app
    - image: repo/mon_app:latest
    - port_bindings: 80:80

Cette state récupère dans un premier temps l’image souhaitée (docker pull repo/mon_app) en dernière version (latest). Dans un second temps il lance le container, le nomme mon_app et expose le port 80.

Mon exemple est très simple, mais on peut facilement compliquer la chose, en lançant plusieurs containers, en précisant plusieurs ports, des limites de ressources et également de build sa propre image (DockerFile) directement depuis Salt.
Pour cela, je vous invite à suivre la doc de Saltstack.

Maintenant que notre configuration semble correcte, on va pouvoir la tester.
Il faut cependant attribuer les deux states à notre serveur, cela se fait dans le fichier /srv/salt/top.sls :

base:  
  '*':
    - docker
    - app

III – Déploiement de notre application

Notre serveur est maintenant fin prêt à recevoir notre déploiement.

Nous allons utiliser le module state.highstate afin qu’il applique nos deux states, la première qui va installer puis vérifier que Docker tourne correctement puis la seconde qui va se charger de déployer notre container.

salt-call state.highstate

Si vous voulez tester d’abord, rajouter l’argument test=True afin de simuler le highstate.

Le premier lancement devrait prendre un peu de temps, n’oubliez pas qu’il installe également Docker. Si tout s’est bien passé, vous devriez avoir une confirmation que Docker est installé et que votre container est bien lancé :

On peut vérifier avec le CLI de Docker si notre container est bien lancé (dans mon cas, j’ai utilisé tutum/lamp) :

Et voilà, mon application web est déployé et grâce à la State écrite plus haute, plus besoin de lancer manuellement le déploiement sur tous les serveurs qui doivent l’accueillir.

Le top serait de créer un dépot Git(hub?) contenant vos States afin d’avoir seulement à cloner le repo avec dans lancer le highstate.

Vous pouvez également automatiser l’application d’un Highstate de manière périodique , ce qui garantira le bon fonctionnement de Docker et que votre application est toujours lancée.

Exemple de cron (tous les jours à minuit) :

00 00 * * * salt-call state.highstate

Docker c’est bien, mais Docker managé par Saltstack, c’est mieux !