Code sur écran d'ordinateur

Photo de Chris Ried sur Unsplash

Commencer un nouveau projet Symfony5 avec docker-compose, Nginx , Php 7.4 et MariaDB

par

Cet article contient toutes les étapes nécessaires pour créer un projet Symfony 5 avec docker-compose, nginx et PHP 7.4.

Structure des dossiers

Pour commencer, nous allons avoir besoin d’un dossier docker qui va contenir tous les dossiers nécessaires pour chaque container. Pour notre exemple, nous allons utiliser nginx, php ainsi que MariaDB

Structure Fichier

Une fois que cela est fait, nous rajoutons les Dockerfiles pour créer notre structure.

Dockerfile structure

 

Maintenant il est nécessaire de créer le dossier qui contiendra le code de Symfony.

Pour cela, dans le terminal, la commande suivante importe tous les fichiers voulus. Dans cet exemple, je crée le dossier « symfony »

symfony new symfony --full --no-git

En utilisant –no-git, le dépôt git de Symfony ne sera pas configuré et il est possible d’ajouter les fichiers à votre repository sans problème.

Dockerfile structure

 

Commencer les fichiers Dockerfile

L’utilisation des versions alpine permet d’avoir toutes les fonctionnalités nécessaires sans le superflu.

Dossier database

Modifier le fichier Dockerfile dans le dossier database

FROM mariadb:latest

CMD ["mysqld"]

EXPOSE 3306

FROM: indique à Docker quelle image il doit utiliser, dans le format repository:version

CMD: indique quelle commande il doit lancer au départ. Dans cet exemple, il démarre le serveur de la base de données

EXPOSE: indique quels ports doivent être visibles sur le réseau interne de Docker. Les autres containers peuvent utiliser ces informations pour se connecter à celui-ci.

Dans le dossier nginx

Le fichier Dockerfile dans le dossier nginx

FROM nginx:alpine

CMD ["nginx"]

EXPOSE 80 443

Dans le dossier php-fpm

FROM php:fpm-alpine

RUN docker-php-ext-install pdo_mysql

CMD ["php-fpm"]

EXPOSE 9000

Afin de pouvoir utiliser une base de données, nous installons aussi l’extension pdo_mysql.

Création du fichier docker-compose

À la racine du dossier docker, créer un fichier nommé docker-compose.yml. C’est dans celui-ci que nous configurons et connectons tous les containers entre eux.

version: '3.8'

services:
  php-fpm:

  nginx:

  database:

Le Build context

Pour pouvoir atteindre les autres containers, il est nécessaire de définir le build context avec un chemin relatif à celui-ci. Par exemple

services:
  database:
    build:
      context: ./database

Configuration de la base de données

Pour la base de données, certains attributs sont obligatoires: le mot de passe root ainsi qu’une base de données.

C’est dans la section environment que l’on peut indiquer des variables à Docker. Dans la nôtre: le nom de la base de données, le mot de passe ainsi qu’un utilisateur par exemple. Dans notre exemple, cela ressemble à cela:

database:
  build:
    context: ./database
  environment:
    - MYSQL_DATABASE=symfonydb
    - MYSQL_USER=user
    - MYSQL_PASSWORD=secret
    - MYSQL_ROOT_PASSWORD=docker

Configuration du php-fpm

Par défaut Docker ne peut ni voir nos fichiers ni y accéder. Pour ce faire on utilise la section volume dans notre fichier docker-compose.yml

php-fpm:
  build:
    context: ./php-fpm
  volumes:
    - ../symfony:/var/www/symfony

le format est – host:container

Configuration du serveur nginx

Pour le serveur nginx l’accès au fichier est aussi nécessaire

nginx:
  build:
    context: ./nginx
  volumes:
    - ../symfony:/var/www/symfony

Malheureusement cela ne suffit pas pour faire fonctionner un serveur, nous avons aussi besoin d’exposer les ports et d’avoir des fichiers de configuration.

Exposer les ports

La section ports permet de définir quels ports doivent être accessibles depuis notre machine. Pour nginx il s’agit de 80 et 443

nginx:
  build:
    context: ./nginx
  volumes:
    - ../symfony:/var/www/symfony
  ports:
    - "80:80"
    - "443:443"

Par défaut, nginx ne permet que de charger des fichiers HTML. Pour Symfony nous avons besoin de php-fpm.

Fichiers de configuration

Pour commencer nous allons avoir besoin de nouveaux fichiers de configuration

Nginx config

Comme notre service php-fpm est dans son propre container, nous devons indiquer à Nginx où le trouver. Dans le fichier conf.d/default.conf il suffit d’ajouter ces lignes

#conf.d/default.conf

upstream php-upstream {
    server php-fpm:9000;
}

Ensuite dans le dossier site, nous pouvons créer le fichier de configuration nécessaire pour Symfony. Il s’agit d’une variante de celui trouvé sur le site de Symfony.

#sites/default.conf

server {

    listen 80 default_server;
    listen [::]:80 default_server ipv6only=on;

    server_name localhost;
    root /var/www/symfony/public;
    index index.php index.html index.htm;

    location / {
         try_files $uri /index.php$is_args$args;
    }

    location ~ ^/index.php(/|$) {
        fastcgi_pass php-upstream;
        fastcgi_split_path_info ^(.+.php)(/.*)$;
        include fastcgi_params;

        fastcgi_param SCRIPT_FILENAME $realpath_root$fastcgi_script_name;
        fastcgi_param DOCUMENT_ROOT $realpath_root;
        
        internal;
    }

    location ~ .php$ {
        return 404;
    }

}

Dans le fichier on peut voir fastcgi_pass php-upstream; qui correspond à notre container; il s’agit de la référence à celui créé dans conf.d/default.conf

Maintenant il faut aussi changer le fichier de configuration nginx.conf

#nginx.conf 

user  nginx;
worker_processes  4;
daemon off;

error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;

events {
    worker_connections  1024;
}

http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    access_log  /var/log/nginx/access.log;
    # Switch logging to console out to view via Docker
    #access_log /dev/stdout;
    #error_log /dev/stderr;

    sendfile        on;
    keepalive_timeout  65;
    
    include /etc/nginx/conf.d/*.conf;
    include /etc/nginx/sites-available/*.conf;
}

Les deux lignes include configurent nginx avec les deux autres fichiers créés.

Maintenant il est nécessaire de rajouter tous ces fichiers dans le container en modifiant la section nginx dans docker-compose.yml

 

nginx:
  build:
    context: ./nginx
  volumes:
    - ../symfony:/var/www/symfony
    - ./nginx/nginx.conf:/etc/nginx/nginx.conf
    - ./nginx/sites/:/etc/nginx/sites-available
    - ./nginx/conf.d/:/etc/nginx/conf.d
  depends_on:
    - php-fpm
  ports:
    - "80:80"
    - "443:443"

En ajoutant depends_on on indique qu’il faut démarrer php-fpm avant nginx.

 

docker-compose.yml final

Lorsque l’on met toutes les pièces ensemble, le fichier ressemble à cela:

version: '3.8'

services:
  php-fpm:
    build:
      context: ./php-fpm
    volumes:
      - ../symfony:/var/www/symfony

  nginx:
    build:
      context: ./nginx
    volumes:
      - ../symfony:/var/www/symfony
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf
      - ./nginx/sites/:/etc/nginx/sites-available
      - ./nginx/conf.d/:/etc/nginx/conf.d
    depends_on:
      - php-fpm
    ports:
      - "80:80"
      - "443:443"

  database:
    build:
      context: ./database
    environment:
      - MYSQL_DATABASE=symfonydb
      - MYSQL_USER=user
      - MYSQL_PASSWORD=secret
      - MYSQL_ROOT_PASSWORD=docker

Ensuite dans le terminal dans le dossier docker:

docker-compose up

Ensuite on peut appeler l’URL: http://localhost/

Et voilà, votre Symfony est prêt:

 

Symfony52

Laisser un commentaire