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

Cet article contiendra toutes les étapes nécessaires pour créer un projet symfony5 avec docker-compose, nginx et php 7.4.

Structures des dossiers

Pour commencer, nous allons avoir besoin d’un dossier docker qui va contenir tous les dossier nécessaire 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 fichiers Dockerfiles pour créer notre structure.

Dockerfile structure

 

Maintenant il 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éer le dossier “symfony”

symfony new symfony --full --no-git

En utilisant –no-git, le git de symfony ne sera pas configurer 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écessaire 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 demarre le serveur de la base de donnée

EXPOSE: indique quel ports doit être visible au réseau interne de Docker. Les autres containers peuvent utiliser ces informations pour ce 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ée, nous installons aussi l’extension pdo_mysql.

Création du fichier docker-compose

A 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 a celui-ci. Par exemple

services:
  database:
    build:
      context: ./database

Configuration de la base de donnée

Pour la base de donnée, certain attribut sont obligatoire, le mot de passe root ainsi qu’une base de donnée.

C’est dans la section environment que l’on peut indiquer der variables à Docker. Dans notre, le nom de la base de donnée, 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 pas voir nos fichier ni les 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 server nginx

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

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

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

Exposer les ports

la section ports, permet de définir quel ports doivent être accessible 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 configurations

Nginx config

Comme notre service php-fpm est son propre container, nous devons indiquer à Nginx ou trouver celui-ci. 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-vi trouver 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éference à celui créer 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 includes configure nginx avec les deux autres fichiers crées.

Maintenant il est nécessaire de rajouter tous ces fichiers dans le container en modifiant la section nginx dans docker-composer.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 commencer le php-fpm avant le nginx.

 

docker-composer.yml final

Lorsque l’on met toutes les pièces ensemble, le fichier ressemble a 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 fichier docker:

docker-compose up
Publicités

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

et voilà, votre symfony est prêt:

 

Symfony52

Publicités

Laisser un commentaire