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 !
Be First to Comment