Utiliser Symfony dans docker

Dans ce tutorial nous allons voir comment développer un site Symfony à l’aide d’une stack docker.

On part du principe qu’il n’y a rien d’installé sur votre poste de travail, à part docker et docker-compose (et que vous êtes sous linux!) Vous trouverez le tutorial d’installation de docker sur le site officiel (par exemple si vous êtes sous Debian : https://docs.docker.com/install/linux/docker-ce/debian/)

On va donc avoir besoin :

  • Apache
  • PHP 7.1
  • PHP 7.2 (afin de tester le site dans les 2 versions)
  • Mysql 5
  • PhpmyAdmin
  • Maildev (pour l’envoi de mail smtp)
  • Composer (pour installer Symfony)

L’essentiel de la configuration va se passer dans 2 fichiers :

  • Le fichier docker-compose.yml qui va être l’élément centralisateur de la stack
  • et des fichiers Dockerfile qui vont servir à configurer chaque image

On va commencer par créer le repertoire stackSf dans notre répertoire home, il contiendra l’ensemble des fichiers de config.
On va ensuite créer à la racine de ce répertoire le fichier docker-compose.yml. C’est dans ce fichier que nous allons déclarer l’ensemble des images que nous allons avoir besoin.
Pour simplifier le process nous allons utilisé pour php et apache une image commune. Nous allons donc avoir besoin de 5 images :

  • Apache+php 7.1
  • Apache+php 7.2
  • Mysql (la dernière version 5)
  • PhpMyadmin
  • Maildev

Le gros avantage de docker c’est que vous aurez toujours les dernières versions dispos ! Après je conseille quand même de spécifier une version (surtout pour mysql et php), ce qui évite les effets de bords dû aux nouvelles versions.

On va commencer par les parties les plus simples : Mysql, PhpMyAdmin et Maildev

version: '3'
services:
    db:
      image: mysql:5
      ports:
        - "3307:3306"
      environment:
        MYSQL_ALLOW_EMPTY_PASSWORD: 'yes'
        MYSQL_USER: 'root'
      volumes:
        - /home/gponty/docker/data/mysqlSf:/var/lib/mysql

    maildev:
        image: djfarrelly/maildev
        ports:
          - "8002:80"

    phpmyadmin:
        image: phpmyadmin/phpmyadmin
        ports:
            - "8080:80"
        depends_on:
            - db
        environment:
          PMA_HOST: db

La 1ere ligne indique dans quelle version nous allons écrire notre docker-compose.

La partie db concerne Mysql.
D’abord ‘image’ est simplement le nom de l’image (que vous pouvez retrouver ici : https://hub.docker.com/_/mysql)
La 3eme ligne est un mapping du port : la partie gauche est le port qui sera utilisé sur votre local et la partie de droite sera utilisé dans le contenaire.
Les variables d’environnement (MYSQL_ALLOW_EMPTY_PASSWORD permet de ne pas mettre de mot de passe à la connexion (à ne pas refaire chez vous 🙂
La ligne volumes est un mappage d’un répertoire qui contiendra les données mysql, même principe que pour les ports, à gauche votre path local, à droite celui dans le contenaire.

Idem pour les autres images, particularités avec PhpMyAdmin qui lui a en plus « depends_on » qui permet de dire que l’image « db » doit être lancé avant celle-ci.

Une fois votre fichier enregistré, il n’y a plus qu’à le lancer :

docker-compose up -d

Et c’est tout !!

Si tout c’est bien passé, il vous suffit de vous rendre à ces 2 adresses :

  • localhost:8080 pour phpmyadmin (login root et pas de mdp)
  • localhost:8002 pour maildev

La partie qui concerne apache et php est un peu plus compliqué :

    php720:
        build: php72
        ports:
          - "9072:80"
        volumes:
            - ./vhosts:/etc/apache2/sites-enabled
            - /home/gponty/docker/www:/var/www

    php710:
        build: php71
        ports:
          - "9071:80"
        volumes:
            - ./vhosts:/etc/apache2/sites-enabled
            - /home/gponty/docker/www:/var/www

La ligne build indique dans quel répertoire va se trouver le fichier dockerfile (on reviendra dessus plus tard)

La ligne volumes, comme pour mysql, est un mapping d’un répertoire, là où sera stocké vos codes sources.
L’autre est là où se trouve vos virtual hosts.
J’en profite pour vous donnez le mien :

<VirtualHost *:80>
    ServerName stacksf.localhost

    DocumentRoot /var/www/stackSf/public
    <Directory /var/www/stackSf/web>
        AllowOverride All
        Order Allow,Deny
        Allow from All
    </Directory>

    # uncomment the following lines if you install assets as symlinks
    # or run into problems when compiling LESS/Sass/CoffeeScript assets
    # <Directory /var/www/project>
    #     Options FollowSymlinks
    # </Directory>

    ErrorLog /var/log/apache2/stackSf_error.log
    CustomLog /var/log/apache2/stackSf_access.log combined
</VirtualHost>

Là où ça se complique c’est dans le fichier Dockerfile, on va commencer par créer les répertoires (ce que vous avez mis dans la partie build) créer un fichier Dockerfile dans chaque répertoire, et copier un php.ini (vous pouvez en trouver un ici : https://github.com/php/php-src/blob/master/php.ini-production) Vous pouvez le copier dans chaque répertoire si vous pensez avoir besoin d’un php.ini différent pour chaque version.

Ce qui doit vous donner au final :

gponty@gponty-AERO-15WV8:~/docker/stackSf$ tree
.
├── docker-compose.yml
├── php71
│   ├── Dockerfile
│   └── php.ini
└── php72
    ├── Dockerfile
    └── php.ini

2 directories, 5 files

On va détailler le Dockerfile :

# image à utiliser
FROM php:7.2-apache

# On envoie le nom du serveur à apache, c'est avec ça que l'on appelera nos pages
RUN echo "ServerName localhost" >> /etc/apache2/apache2.conf

# Quelques library necessaires
RUN apt-get update \
    && apt-get install -y --no-install-recommends locales apt-utils git;

# les locales, toujours utiles
RUN echo "en_US.UTF-8 UTF-8" > /etc/locale.gen && \
    echo "fr_FR.UTF-8 UTF-8" >> /etc/locale.gen && \
    locale-gen

# On copie le php.ini du repertoire actuel dans le contenaire
COPY php.ini /usr/local/etc/php/php.ini

# on télécharge et deplace le composer
RUN curl -sSk https://getcomposer.org/installer | php -- --disable-tls && \
   mv composer.phar /usr/local/bin/composer

# On créé un utilisateur avec le même gid/uid que votre local
# cela va permettre que les fichiers qui sont créés dans le contenaire auront vos droits
RUN addgroup --system gponty --gid 1000 && adduser --system gponty --uid 1000 --ingroup gponty

# le repertoire qui contient vos sources (attention : dans le contenaire, donc le repertoire à droite du mapping du docker-compose)
WORKDIR /var/www/

La 1ere ligne est la seule (dans notre cas) qui va changer entre php71 et php72, je pense qu’il y a un moyen de ne pas dupliquer toutes les autres lignes mais je n’ai pas encore creusé.

Dans le Dockerfile de php71 vous aurez : FROM php:7.1-apache

Une fois les Dockerfile créés il faut le build, en vous mettant à la racine il va build les 2 en même temps :

docker-compose build

Une fois le build ne pas oublier de lancer les contenaires (vous pouvez ajouter un -d pour lancer en mode détaché) :

docker-compose down
docker-compose up

Une fois effectué, on va pouvoir créer notre projet symfony.
On va se connecter au bash d’un contenaire php (peu importe lequel)

docker exec -u 1000 -it $(docker ps -aqf « name=php71 ») bash;

Vous arrivez dans le répertoire www, vous pouvez donc exécuter votre commande favorite :

composer create-project symfony/website-skeleton stackSf

Surtout ne pas oublier le pack apache :

composer require symfony/apache-pack

Il n’y a plus qu’à se rendre sur stacksf.localhost:9071 et 9072, et vérifier que les version de PHP soient bien différentes.

Vous pouvez retrouver les sources complètes ici :
https://github.com/gponty/docker-symfony

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.