RootsLabs

More than a tool ! GitHub Google+ LinkedIn RSS

Docker, un environnement de développement versionnable

Progi1984 - Commentaires (2)

Docker est un logiciel libre qui permet d’embarquer dans un container virtuel une application. Cela permet ainsi non plus de virtualiser un système mais de virtualiser un processus, et c’est pourquoi on parle parfois de virtualisation légère. Dans notre exemple, nous allons mettre en place Docker ainsi qu’un environnement de développement basé sur Nginx, PHP-fpm et MySQL.

Logo Docker

Pour une explication approfondie de Docker, je vous conseille l’article de Nicolargo : Virtualisation légère avec Docker.

Installation & Configuration de Docker

Sous Windows, l’installation se fait via un installeur standard. Dans mon cas, le seul truc que je n’ai pas coché est Git, car je l’avais déjà installé.
Après installation, on lance une ligne de commande, on se déplace dans dossier et on tape quelques commandes.

  1. On vérifie les machines présentes sur le système :

    Normalement, cela devrait être vide.

  2. On crée la machine par défaut :

  3. On définit les variables d’environnements :

    A ce niveau, on copie et exécute dans l’invite de commandes les lignes commençant par « SET ».

    Référence : https://docs.docker.com/machine/reference/env/

Configuration de notre environnement via Docker Compose

Notre environnement sera composé d’un fichier docker-compose.yml.

La base de notre environnement sera :

  • une base de données : MySQL
  • un serveur Web : NGinx
  • et PHP

Un article suivra pour configurer d’autres outils comme SASS, PHPMyAdmin, MailDev ou Sentry.

Configurer MySQL

Dans le fichier YAML, nous allons ajouter ces lignes :

Nous allons utiliser l’image Docker fourni officiellement : https://hub.docker.com/_/mysql/.
Pour pouvoir se connecter au port 3306 de MySQL, il faut définir le port de sortie qui sera le même.
Ensuite, l’image MySQL a des variables d’environnements que l’on peut définir :

  • MYSQL_ROOT_PASSWORD : permet de définir le mot de passe root (obligatoire) ;
  • MYSQL_DATABASE : permet de définir la base de données à créer (facultatif) ;
  • MYSQL_USER : permet de définir l’utilisateur MySQL à créer (facultatif) ;
  • MYSQL_PASSWORD : permet de définir le mot de passe de l’utilisateur MYSQL_USER (facultatif) ;

Configurer Nginx

Après MySQL, nous allons configurer le serveur Web. A la fin du fichier docker-compose.yml, nous allons ajouter ces lignes :

Pareil, nous partons sur l’image officielle fourni par Docker : https://hub.docker.com/_/nginx/.
Pour utiliser le port 80 de Nginx, il faudra que l’on définisse un port de sortie, et qui comme MySQL sera le même.
Nous allons passer aux volumes : ce sont des dossiers un peu spéciaux qui permettent de connecter un lien dans le container vers un dossier soit d’un autre container, soit sur le système hôte.
Nous allons en configurer deux :

  • Dans le container, le dossier « /var/www/local.dev » pointera vers le dossier « ./ », soit la racine de notre projet ;
  • Dans le container, le dossier « /etc/nginx/conf.d » pointera vers le dossier « ./.docker/nginx ».

Précisons que certains containers ont besoin de fichier de configuration ou emplacement de stockage. Dans notre cas, Nginx a besoin d’un fichier de configuration : default.conf qui est censé se trouver dans le dossier « /etc/nginx/conf.d » du container, soit au niveau de notre dossier : « ./.docker/nginx ».

Le fichier default.conf est simple. Je n’irais pas plus dans les détails le concernant si ce n’est le fastcgi_pass : celui pointe vers le port 9000 du container php que l’on lie via le noeud « links ».

Configurer PHP

On a notre serveur Web et une base de données : il ne nous manque plus que PHP pour pouvoir compléter notre environnement.

Pour PHP, nous allons compiler nous-même PHP afin de pouvoir utiliser les extensions que l’on souhaite.

Modifions tout d’abord le fichier docker-compose.yml :

Contrairement aux deux autres containers, nous n’allons pas passer par une image mais un build. Le noeud build a besoin du chemin, relatif à l’emplacement du fichier docker-compose.yml, du dossier où se trouvera le fichier Dockerfile pour builder le container.

Les volumes liés sont :

  • Dans le container, le dossier « /var/www/local.dev » pointera vers le dossier « ./ », soit la racine de notre projet ;
  • Dans le container, le fichier « /usr/local/etc/php » pointera vers le fichier « ./.docker/php/ini »

Le container lié est cette fois le container « db » pour que le container « php » puisse faire une requête MySQL vers celui-ci.

Il nous reste deux fichiers à définir : le fichier Dockerfile pour générer le container PHP, et le fichier php.ini (à placer dans le dossier « ./.docker/php/ini/ ») qui contiendra la configuration de PHP.

Le fichier Dockerfile de PHP est le suivant :

Avant de lancer notre serveur, nous allons générer notre container PHP. Pour cela, on lance la commande :

Je ne vous affiche pas le log car avec la génération de PHP, cela prend un nombre conséquent de lignes.

Le fichier php.ini est le suivant :

Configurer le partage avec Boot2Docker

Attention, ce chapitre est pour les utilisateurs de Windows.

On va configurer le partage entre le système hôte (votre ordinateur) et Boot2Docker.
Pour cela, il faut ajouter un partage au niveau de la machine virtuelle de Boot2Docker :

Via cette ligne de commande, on ajoute un dossier partagé à la machine virtuelle nommé « default » sous le nom « c/wamp » du dossier « C:\wamp » présent sur le système hôte.

Autoriser les ports de Boot2Docker

Attention, ce chapitre est pour les utilisateurs de Windows.

On va faire de la translation de ports en mappant le port 80 de la VM vers le port 80 sur le réseau local.

Via cette ligne de commande, on redirige le port 80 vers le port 80 de la VM.
Il faut le faire pour chaque port venant de nos containers que l’on sort sur le réseau.

Utiliser notre environnement de développement

Maintenant que tout est configuré dans notre fichier docker-compose.yml, on va lancer notre environnement.

Pour les utilisateurs de Windows, on vérifie que Boot2Docker est lancé et sinon on le lance.

On lance la commande suivante pour enregistrer les variables d’environnement :

On se connecte en SSH à Boot2Docker pour activer le partage de dossiers :

Ou en plus court :

On récupère l’IP de Boot2Docker :

Après cela, il ne manque plus qu’à lancer la machine :

Et d’aller dans votre navigateur pour tester l’IP :
Résultat final de Docker Compose

Conclusion

Les plus perspicaces d’entre vous auront remarqué le mot « versionnable » d’entre vous. Grâce au fait que notre environnement de développement n’est basé que sur des fichiers avec principalement le fichier docker-compose.yml, tout devient versionnable et vous pouvez ainsi votre les évolutions de votre environnement pour tester des outils et revenir en arrière.
Le seul souci qui me reste à traiter reste le fait de voir à chaque démarrage de Boot2Docker de de voir gèrer les variables d’environnement et monter le point de montage. Mais peut-être que Docker nous aidera dans une prochaine version, ou qu’un des lecteurs a une solution à me proposer. N’étant pas un expert Docker, je reste ouvert à tous commentaires.

Commentaires

1. Quoi de neuf Docker ? - Le blog de Jean-Mich, le 3 mars 2016 à 13:50

[…] RootsLabs nous donne un exemple assez complet d’utilisation. […]

2. RootsLabs » Docker: utiliser SASS, PHPMyAdmin, MailDev et Sentry, le 14 mars 2016 à 10:00

[…] mon précédent article, j’ai mis en place un environnement de développement basé sur des containers Docker avec Nginx, PHP-fpm et MySQL. Dans cet article, nous allons mettre en place différents containers Docker pour installer les […]

Ajouter un commentaire

Commentaire :