Dockeriser une application Symfony sous Windows 10 Pro - Partie 2

Installation de Docker

Suite à la première partie de l'article première partie, où nous avons fait un bref aperçu de Docker, voici venu le moment tant entendu, l'installation de l'outil.

 

Il faut donc se rendre sur la plateforme docker.com et installer le docker desktop ici https://www.docker.com/products/docker-desktop

Pour faciliter la gestion de docker, vous pouvez utiliser trois outils :

  • Windows Terminal qui permettra de gérer l’arrêt et le redémarrage de docker, ainsi que l’exécution de commandes dans le conteneur.
  • Windows PowerShell, un terminal bien pratique pour lancer ses commandes
  • Portainer.io qui est une interface graphique qui peut être installé depuis le site officiel https://www.portainer.io/ et qui permet de manager les conteneurs depuis une interface graphique

 

Dockeriser l’application Symfony

Nous allons donc prendre un cas pratique,

Passer une application Symfony en Docker.

 

1-/ Dresser l’inventaire des technologies utilisées et les versions

A l’aide d’une extension chrome, Wappalyzer

Nous allons faire un tableau qui nous dit quelle technologie est utilisée et leur version exacte en production.

 

 Technologie

 Version en production

 PHP

 7.0.33

 MySQL

 5.7.28

 Nginx

 1.10.3

 

2-/ Définir l’architecture

L’architecture de notre application Symfony actuelle est celle-ci :

La première chose est de définir une architecture claire, la mienne est la suivante :

  • apps :  le répertoire qui contient le code de l’application à Dockeriser
  • docker : Le répertoire qui contient tous les dockerfiles et les répertoires par technologie
  • data : répertoire pour mémoriser les données comme une bdd de façon à ne pas les perdre à chaque rebuild de notre stack applicative
  • .env :  Le fichier d’environnement va contenir les variables nécessaires au bon fonctionnement de Docker, par exemple les variables de connexion à la base de données.

Création du fichier docker-compose.yml

L’objectif sera d’obtenir quelque chose qui ressemble au schéma ci-dessus.

C’est le fichier docker-compose.yml qui va définir cette infrastructure.

C’est ce fichier YAML qui décrit comment docker va construire les conteneurs qu’on va lui indiquer.

Il s’écrit en respectant les règles d’écriture détaillant dans la documentation officielle de l’api de docker.

La principale règle à respecter pour bien découper son application est 1-service 1-conteneur.

Nous reviendrons vers la fin pour écrire le docker-compose.

Avant, il faut créer chacun de ces conteneurs à l’aide d’images et de Dockerfiles.

 

Nous allons donc le faire en commençant par le serveur web.

 

Nginx :

Pour le serveur nginx, nous avons besoin de sa version 1.10.3.

Nous allons donc nous rendre dans hub.docker.com, créer un compte.

Ensuite, une fois connecté, dans la barre de recherche ci-dessous, taper nginx

Plusieurs résultats vont s’afficher mais on va choisir l’image officielle nginx.

Le 1er résultat est l’image officielle, ça se voit au logo Nginx reconnaissable comme logo de profil.

En cliquant dessus, on arrive sur un menu avec 3 onglets la description de l’image et les reviews (avis utilisateurs) et les tags.

Ce qui nous intéresse ici ce sont les tags, nous allons donc rechercher le tag 1.10.3 celui qui est actuellement utilisé sur notre environnement de production.

On arrive sur cette page ou on peut voir un champ qui permet de filtrer par tags.

On saisit donc 1.10.3, on choisit nginx :1.10.3

 

Cependant, pour faire tourner le serveur web nginx, il faut faire quelques retouches comme décrit dans l’onglet description.

Ces retouches sont principalement le fichier de configuration globale nginx.conf et la définition de l’hôte virtuel site1.conf.

On se rend dans le répertoire docker et on crée un sous-répertoire nginx.

Il y aura 3 fichiers dedans :

  • Dockerfile
  • nginx.conf
  • site1.conf
server {
  listen 1000;
  server_name site1.local;
  index index.php;
  root /var/www/html/public;
  access_log /var/log/nginx/site1_access.log;
  error_log /var/log/nginx/site1_error.log;
  location / {
    # try to serve file directly, fallback to index.php
   # try_files $uri /index.php?$args;
     try_files $uri $uri/ /index.php?$query_string;
             gzip_static on;
  }
  location ~ .php$ {
    #fastcgi_index index.php;
    #fastcgi_pass php:9000; # address of a fastCGI server
    #fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
    #fastcgi_param PATH_INFO $fastcgi_path_info;
    #include fastcgi_params;
    try_files $uri =404;
    fastcgi_split_path_info ^(.+.php)(/.+)$;
    fastcgi_pass 127.0.0.1:9001;
    fastcgi_index index.php;
    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
    include fastcgi_params;
  }
}

site1.conf

De même, pour nginx.conf :

 

user www-data;
worker_processes 4;
pid /run/nginx.pid;
events {
  worker_connections  2048;
  multi_accept on;
  use epoll;
}
http {
  server_tokens off;
  sendfile on;
  tcp_nopush on;
  tcp_nodelay on;
  keepalive_timeout 15;
  types_hash_max_size 2048;
  include /etc/nginx/mime.types;
  default_type application/octet-stream;
  access_log off;
  error_log off;
  gzip on;
  gzip_disable "msie6";
  include /etc/nginx/conf.d/*.conf;
  include /etc/nginx/sites-enabled/*;
  open_file_cache max=100;
}
daemon off;

nginx.conf

Le Dockerfile devrait ressembler à ça :

 

FROM nginx:1.10.3  
MAINTAINER Kevin Minkolminganga
ADD nginx.conf /etc/nginx/
ADD extranet.conf /etc/nginx/sites-available/
RUN mkdir -p /etc/nginx/sites-enabled
RUN ln -s /etc/nginx/sites-available/extranet.conf /etc/nginx/sites-enabled/extranet
RUN rm -rf /etc/nginx/sites-enabled/default
RUN echo "upstream php-upstream { server 127.0.0.1:9000; }" > /etc/nginx/conf.d/upstream.conf
RUN usermod -u 1000 www-data
CMD ["nginx"]
EXPOSE 80
EXPOSE 443

Tous les mots clés en bleu sont des instructions docker pour composer son image.

FROM :  instruction qui dit à docker de télécharger l’image nginx :1.10.3

Celle-ci sera notre première couche.

MAINTAINER : c’est l’auteur de l’image

ADD : cette instruction permet d’ajouter des fichiers ou des répertoires à un emplacement définir sur le conteneur lié au dockerfile.

RUN : permet de lancer une commande linux basique pendant la construction de l’image

CMD :  cette instruction permet de définir la commande de démarrage par défaut du conteneur , on peut aussi utiliser entrypoint

 

Voilà, pour Nginx, dans la troisième et dernière partie de cet article , nous verrons comment mettre en place ce qu'il faut pour gérer  les autres conteneurs PHP-FPM, MySQL et PhpMyAdmin.

 

 

 

 

Restez informés sur notre actualité

Inscrivez-vous à notre newsletter pour recevoir les dernières évolutions de notre produit