Catégorie : site web

  • Configuration optimisée et sécurisée de Nginx

    Configuration optimisée et sécurisée de Nginx

    Dans le dernier article, nous avions vu comment mettre en place le chiffrement TLS.

    C’était le premier pas d’une longue série de paramètre pour sécuriser notre application web. Dans cet article, nous allons voir comment mettre en place une configuration optimisée et sécurisée de Nginx.

    Un outil pour les configurer tous

    Nginx est un outil très puissant. Et qui dit très puissant, dit également beaucoup de paramètre à prendre en compte.

    Heureusement nous pouvons trouver des générateurs de configuration pour Nginx.

    Par exemple vous en trouverez un sur le site de DigitalOcean : https://www.digitalocean.com/community/tools/nginx?global.app.lang=fr

    Vous pouvez le configurer comme ci-après, qui devrait s’adapter à presque toutes les configurations.

    Configuration de Nginx

    Dans la partie Pré-configurations, cliquez sur WordPress. Remplissez l’onglet Serveur.

    La partie Chemin est très importante car c’est le chemin que Nginx empruntera pour accéder au site. Si vous hébergez un seul site, la configuration par défaut devrait suffire. Par contre si vous en hébergez plusieurs, chaque application devra avoir un chemin unique.

    démonstration pour un chemin unique pour nginx

    On laisse l’onglet HTTPS par défaut.

    Dans la partie PHP, on vérifie que activer PHP et activer les règles spécifiques à Wordress sont bien cochés. Dans serveur PHP, on définira les noms d’hôtes comme dans l’article précédent.

    pré-configuration php, on personnalise le serveur php et on active les règles WordPress

    On laisse les autres onglets par défaut. On active ou non le logging.

    Dans la partie Configuration globale, il faudra cocher limit_req et bien vérifier que server_tokens est décoché. Le premier agira comme une protection contre les attaques de type flood et le deuxième, cachera l’identité de notre serveur Nginx.

    On en profitera également pour modifier le Referrer-Policy en same-origin, pour protéger la vie privée de nos utilisateurs.

    modification du referrer-policy et activation du limit_req

    Vérifiez dans l’onglet Logs qu’ils sont bien activés en warn ou error.

    Dans l’onglet Docker on cliquera sur Configurer pour Docker et on décochera les deux cases. Le but étant de passer le user en nginx et le pid en /var/run/nginx.pid dans l’onglet NGINX.

    De plus, nous avons déjà nos propres fichiers dockerfile.

    En descendant la page nous trouvons nos fichiers de configuration.

    Harmonisation des fichiers Nginx

    Nous remarquons que les fichiers ont été configurés avec un chemin d’accès.

    Nous allons donc modifier notre fichier docker-compose.yml, pour y introduire ces nouvelles données.

    Dans la partie Nginx dans la sous-partie volumes, nous allons modifier comme ci-dessous :

        volumes:
          - ${WORDPRESS_LOCAL_HOME}:/var/www/html/nginx.laclefdigitale.fr
    #      - ${NGINX_CONF_DEFAULT}:/etc/nginx/conf.d/default.conf 
    
    # generale conf
    
          - ${NGINX_CONF}:/etc/nginx/nginx.conf
          - ${NGINX_MIME}:/etc/nginx/mime.types
          - ${NGINX_SITES_ENABLED}:/etc/nginx/sites-enabled/:ro
          - ${NGINX_CONFIG_IO}:/etc/nginx/nginxconfig.io/:ro

    Vous remarquerez que nous utilisons sites-enabled et non site-available. Nginx permet de faire un lien entre les deux. Nous grâce à Docker, nous lions directement le chemin vers sites-enabled.

    Il faudra également modifier la partie SSL du fichier /etc/nginx/sites-enabled/exemple.conf, avec les répertoires que nous avons déterminé précédemment.

    # SSL
    /etc/nginx/ssl/live/example.conf/fullchain.pem; 
    /etc/nginx/ssl/live/example.conf/privkey.pem; 
    /etc/nginx/ssl/live/example.conf/chain.pem;

    Voici le contenu du fichier mime.types

    
    types {
        text/html                                        html htm shtml;
        text/css                                         css;
        text/xml                                         xml;
        image/gif                                        gif;
        image/jpeg                                       jpeg jpg;
        application/javascript                           js;
        application/atom+xml                             atom;
        application/rss+xml                              rss;
    
        text/mathml                                      mml;
        text/plain                                       txt;
        text/vnd.sun.j2me.app-descriptor                 jad;
        text/vnd.wap.wml                                 wml;
        text/x-component                                 htc;
    
        image/avif                                       avif;
        image/png                                        png;
        image/svg+xml                                    svg svgz;
        image/tiff                                       tif tiff;
        image/vnd.wap.wbmp                               wbmp;
        image/webp                                       webp;
        image/x-icon                                     ico;
        image/x-jng                                      jng;
        image/x-ms-bmp                                   bmp;
    
        font/woff                                        woff;
        font/woff2                                       woff2;
    
        application/java-archive                         jar war ear;
        application/json                                 json;
        application/mac-binhex40                         hqx;
        application/msword                               doc;
        application/pdf                                  pdf;
        application/postscript                           ps eps ai;
        application/rtf                                  rtf;
        application/vnd.apple.mpegurl                    m3u8;
        application/vnd.google-earth.kml+xml             kml;
        application/vnd.google-earth.kmz                 kmz;
        application/vnd.ms-excel                         xls;
        application/vnd.ms-fontobject                    eot;
        application/vnd.ms-powerpoint                    ppt;
        application/vnd.oasis.opendocument.graphics      odg;
        application/vnd.oasis.opendocument.presentation  odp;
        application/vnd.oasis.opendocument.spreadsheet   ods;
        application/vnd.oasis.opendocument.text          odt;
        application/vnd.openxmlformats-officedocument.presentationml.presentation
                                                         pptx;
        application/vnd.openxmlformats-officedocument.spreadsheetml.sheet
                                                         xlsx;
        application/vnd.openxmlformats-officedocument.wordprocessingml.document
                                                         docx;
        application/vnd.wap.wmlc                         wmlc;
        application/wasm                                 wasm;
        application/x-7z-compressed                      7z;
        application/x-cocoa                              cco;
        application/x-java-archive-diff                  jardiff;
        application/x-java-jnlp-file                     jnlp;
        application/x-makeself                           run;
        application/x-perl                               pl pm;
        application/x-pilot                              prc pdb;
        application/x-rar-compressed                     rar;
        application/x-redhat-package-manager             rpm;
        application/x-sea                                sea;
        application/x-shockwave-flash                    swf;
        application/x-stuffit                            sit;
        application/x-tcl                                tcl tk;
        application/x-x509-ca-cert                       der pem crt;
        application/x-xpinstall                          xpi;
        application/xhtml+xml                            xhtml;
        application/xspf+xml                             xspf;
        application/zip                                  zip;
    
        application/octet-stream                         bin exe dll;
        application/octet-stream                         deb;
        application/octet-stream                         dmg;
        application/octet-stream                         iso img;
        application/octet-stream                         msi msp msm;
    
        audio/midi                                       mid midi kar;
        audio/mpeg                                       mp3;
        audio/ogg                                        ogg;
        audio/x-m4a                                      m4a;
        audio/x-realaudio                                ra;
    
        video/3gpp                                       3gpp 3gp;
        video/mp2t                                       ts;
        video/mp4                                        mp4;
        video/mpeg                                       mpeg mpg;
        video/quicktime                                  mov;
        video/webm                                       webm;
        video/x-flv                                      flv;
        video/x-m4v                                      m4v;
        video/x-mng                                      mng;
        video/x-ms-asf                                   asx asf;
        video/x-ms-wmv                                   wmv;
        video/x-msvideo                                  avi;
    }
    

    Une fois nos répertoires et nos fichiers créés, il ne reste qu’à redémarrer notre projet docker.

    Maintenant en scannant votre site sur Moz observatory, nous obtenons un rang B+. Plutôt pas mal, pour une config générée par défaut 🙂

    rang B+ sur moz obs.

    Pour conclure

    Nous avons harmonisé notre arborescence de répertoire de travail sur Nginx. L’outil Nginx config, nous a facilité la mise en place d’une configuration optimisée et sécurisée de Nginx. Notre site web affiche désormais un B+ sur l’outil de protection de moz Observatory.

    D’ailleurs nous nous apercevons que seule la partie CSP fait baisser le rang de notre application. Nous verrons lors d’un prochain article comment rajouter le CSP pour atteindre le rang A+ en sécurité.

  • Mise en place d’un serveur HTTPS

    Mise en place d’un serveur HTTPS

    Dans le dernier article, nous avions vu comment installer Nginx.

    Même si la configuration initiale était fonctionnelle, elle n’est pas des plus sécurisées. Néanmoins elle est essentielle pour l’obtention du certificat let’s encrypt et la mise en place du protocole https.

    Je vous propose ainsi dans cet article, de faire la mise en place d’un serveur HTTPS.

    Mise en place du certificat let’s encrypt

    Le certificat let’s encrypt, nous permet de sécuriser la connexion à notre site web. Cela se traduit par une URL en https et le petit cadenas sur votre navigateur.

    En cliquant sur le cadenas, on y apprend que le certificat permet un chiffrement de la connexion ce qui rend très difficile la visualisation de cette page pendant son transit.

    Ainsi même si un attaquant détournait la connexion, les informations reçues seraient chiffrées et inutilisables.

    Pour générer ce certificat, nous utiliserons certbot.

    Si vous avez suivi mon premier article : Installation de WordPress sous Docker, il vous suffira de le compléter.

    Nous allons rajouter ces quelques lignes dans notre fichier docker-compose.yml

      certbot:
        image: certbot/certbot:latest
        container_name: certbot
        depends_on:
          - nginx
        command: >-
          certonly --webroot --webroot-path=/var/www/certbot/ --email [votre_email] --agree-tos --no-eff-email -d mamourhome.duckdns.org
    
        volumes:
          - ${CERTBOT_WWW}:/var/www/certbot/:rw
          - ${CERTBOT_CONF}:/etc/letsencrypt/:rw
          - ${CERTBOT_LOGS}:/var/log/letsencrypt/
    

    Pensez à rajouter les volumes commun dans votre service nginx dans le fichier docker-compose.yml.

    Soit :

    - ${CERTBOT_WWW}:/var/www/certbot/:ro
    - ${CERTBOT_CONF}:/etc/nginx/ssl/:ro

    Puis déclarer les variables dans le fichier .env

    #certbot setting
    export CERTBOT_WWW=./certbot/www
    export CERTBOT_CONF=./certbot/letsencrypt
    export CERTBOT_LOGS=./logs/certbot
    

    Il faudra également indiquer le chemin d’accès au certificat dans le fichier default.conf.

    Ajouter dans le fichier default.conf :

    include nginxconfig.io/letsencrypt.conf

    Puis créer le fichier letsencrypt.conf dans le répertoire nginxconfig.io

    Puis ajouter à ce fichier :

    location ~ /.well-known/acme-challenge {
         allow all;
         root /var/www/certbot;
    }
    

    Modifier votre fichier docker-compose.yml, et rajouter toujours dans le service Nginx le volume qui gérera le repertoire nginxconfig.io.

    - ${NGINX_CONFIG_IO}:/etc/nginx/nginxconfig.io/:ro

    Puis mettre à jour le fichier .env avec les dernieres instructions :

    export NGINX_CONFIG_IO=./nginx/nginxconfig.io

    Une fois toutes ces mises à jour effectuées, vous pourrez lancer l’obtention du certificat en lançant cette commande.

    sudo docker compose run certbot

    Et si tout se passe bien, vous verrez dans votre terminal ce petit message :

    Do you want to expand and replace this existing certificate with the new
    certificate?
    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    (E)xpand/(C)ancel: E
    Renewing an existing certificate for www.laclefdigitale.fr and 5 more domains
    
    Successfully received certificate.
    

    Maintenant que nous avons le certificat, nous allons indiquer à notre serveur web, qu’il faudra toujours emprunter le protocole https

    Nous allons donc modifier le fichier default.conf comme ceci :

    
    server {
        listen                  443 ssl;
        http2                   on;
        listen                  [::]:443 ssl;
        server_name             mamourhome.duckdns.org;
        set                     $base /var/www/html/mamour;
        root                    $base;
    
        index index.php;
        # SSL
        ssl_certificate         /etc/nginx/ssl/live/mamourhome.duckdns.org/fullchain.pem;
        ssl_certificate_key     /etc/nginx/ssl/live/mamourhome.duckdns.org/privkey.pem;
        ssl_trusted_certificate /etc/nginx/ssl/live/mamourhome.duckdns.org/chain.pem;
    
            location / {
               proxy_pass http://backnginx;
               proxy_set_header Host $host;
               proxy_set_header X-Real-IP $remote_addr;
               proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
               proxy_set_header X-Forwarded-Proto $scheme;
               proxy_next_upstream error timeout http_500;
            }
    
    }
    
    server{
            listen 80;
            listen [::]:80;
    
            server_name mamourhome.duckdns.org;
    
            include nginxconfig.io/letsencrypt.conf;
    
       location / {
            return 301 https://mamourhome.duckdns.org$request_uri;
        }
    }

    Et maintenant en tapant : https://mamourhome.duckdns.org, nous avons bien notre connexion chiffrée et notre petit cadenas.

    Conclusion

    Ainsi grâce aux certificats TLS de let’s encrypt et à Certbot, nous avons pu faire la mise en place d’un serveur HTTPS. C’est le premier pas pour sécuriser nos applications sur internet.

    Dans le prochain article, nous modifierons la structure de notre Nginx pour y rajouter la possibilité d’héberger plusieurs site web.

  • Installation de Nginx sous Docker

    Installation de Nginx sous Docker

    Nous avions vu lors d’un précédent article, comment installer WordPress sous Docker. C’est toujours sympa d’avoir un site web à la maison. Mais çà serait tout de même bien plus génial si nous pouvions l’ouvrir au reste du monde.

    Nous allons donc voir comment cela est possible grâce à l’installation de Nginx sous Docker.

    Mise en place d’un nom de domaine gratuitement

    Sans trop développer le sujet, le web tel que nous le connaissons est accessible grâce à des adresses ip. En faisant un ping vers Google ou un autre site, le serveur nous répondra avec son adresse IP.

    Naturellement, pour des humains retenir une suite de nombre pour accéder à nos site préférés est un peu compliqué.

    C’est à ce moment où le nom de domaine intervient. Il va translater les adresses IP en une translation plus simple et compréhensible pour nous tous.

    Pour cet article nous utiliserons le service de Duckdns qui nous permet de bénéficier d’un nom de domaine gratuitement de la forme : XXXXXXX.duckdns.org

    Nous pouvons donc commencer par créer un compte sur https://www.duckdns.org/

    Une fois celui-ci créé, il nous suffira de choisir un sub domain et d’y attacher les adresses IP de notre serveur.

    Dans mon cas, j’ai choisi mamourhome qui pointe sur L’IP de mon serveur.

    Installation de Nginx sous Docker

    Bien, maintenant que nous avons un nom de domaine, nous allons pouvoir installer Nginx sous docker.

    On se crée un répertoire de travail. Et on y crée notre fichier docker compose.

    service:
      
      nginx:
      image: nginx
        container_name: nginx
        env_file:
          - .env
        restart: unless-stopped
        networks:
    - nt_nginx
    
    depends on:
    - wordpress
    
    ports:
    - 80:80
    - 443:443
    
    volumes:
    - ${WORDPRESS_LOCAL_HOME}:/var/www/html/:ro
    - ${NGINX_CONF_DEFAULT}:/etc/nginx/conf.d/default.conf 
    - ${NGINX_LOGS}:/var/log/nginx

    Vous pouvez rajouter à la suite le contenu du docker compose sur l’article traitant de l’installation de WordPress docker. N’oubliez néanmoins de rajouter le bon nom de réseau entre Nginx et WordPress.

    Nous allons ensuite créer le fichier .env

    ${WORDPRESS_LOCAL_HOME}: ./wordpress
    ${NGINX_CONF_DEFAULT}: ./nginx/conf.d/default.conf
    ${NGINX_LOGS}: ./logs

    La configuration de notre serveur Web est actuellement en version minimum.

    Une fois que nous aurons récupérer les certificats let’s encrypt, nous rajouterons les modules manquants pour Nginx (la sécurité, le CSP, un peu d’optimisation, etc).

    Création du fichier de configuration default.conf

    Pour que notre Nginx puisse fonctionner correctement avec notre nom de domaine nous allons créer un fichier default.conf dans le répertoire ./nginx/conf.d/

    Ce fichier indiquera ainsi l’emplacement du répertoire de travail du nom de domaine demandé.

    Notre fichier default.conf ressemblera donc à ceci :

    server{
            listen 80;
            listen [::]:80;
    
            server_name mamourhome.duckdns.org;
    
            set     $base /var/www/html/mamour;
            root    $base;
            index index.php;
    
    
    
            location / {
    
               proxy_pass http://backnginx;
               proxy_set_header Host $host;
               proxy_set_header X-Real-IP $remote_addr;
               proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
               proxy_set_header X-Forwarded-Proto $scheme;
               proxy_next_upstream error timeout http_500;
            }
    
    
    }
    

    Une fois le fichier default.conf créé, vous devrez redémarrer votre service Nginx pour qu’il soit pris en compte.

    sudo docker compose restart nginx

    Puis en tapant l’URL : http://mamourhome.duckdns.org, vous devriez arriver sur votre instance WordPress 🙂

    Conclusion

    Nous avons vu comment faire l’installation de Nginx sous docker. Celle-ci nous permet mettre en place un serveur pour appeler nos applications, tout en les rendant public grâce à un nom de domaine.

    Le prochain article traitera de la mise en place des cetificats let’s encrypt grâce à Certbot, puis nous commencerons à optimiser et à sécuriser nos applications web.

  • Installation de WordPress sous Docker

    Installation de WordPress sous Docker

    Cet article concernant l’installation de WordPress sous docker est le premier d’une longue série. L’objectif sera de concevoir un site avec toutes les fonctionnalités de performance et sécurité.

    C’est quoi WordPress ?

    WordPress est un CMS (content manager system), soit un logiciel en ligne grâce auquel il est possible de créer, de gérer et de modifier facilement un site web sans pour autant connaitre tous les langages de programmation associés.

    Il s’agit d’un logiciel gratuit, libre et open source, distribué par WordPress.org.

    Il est écrit en PHP et permet de facilement mettre en place un site vitrine, blog, portfolio …

    Les pré-requis

    WordPress a besoin d’une base de donnée pour fonctionner.

    Nous utiliserons Mariadb pour notre projet, qui est également un logiciel gratuit, libre et open source.

    MariaDB Server est l’une des bases de données relationnelles open source les plus populaires.

    Il repose sur les valeurs de performance, de stabilité et d’ouverture.;

    Création du réseau MacVlan

    Avant toute chose nous allons créer un réseau MacVlan sous docker.

    Ce réseau permettra d’identifier les containers en leur donnant une mac adresse, ce qui nous permettra de les faire entrer dans une plage du type 192.168.x.x.

    sudo docker network create -d macvlan --subnet=192.168.1.0/24 --gateway=192.168.1.254 --ip-range=192.168.1.0/24 -o parent=eth0 mcvlan_nw

    Création du docker compose

    Comme à notre habitude nous allons créer notre répertoire de travail et nous y déplacer dedans.

    mkdir wordpress && cd wordpress

    Puis nous allons créer notre fichier docker-compose.

    sudo nano docker-compose.yml

    Nous commencerons par indiquer nos services et les images à utiliser :

    services:
      wordpress:
          build:
          image: wordpress
        container_name: wordpress
        hostname: wordpress

    Pour plus de sécurité, nous allons utiliser un fichier de variable d’environnement qui stockera toutes les informations des chemins de répertoire, nom d’utilisateur, mot de passe, nom de serveur …

        env_file:
          - .env
        restart: unless-stopped

    Nous déclarons notre container WordPress dans deux réseaux, le premier dans le réseau mcvlan précédemment créé et nous lui définissons une adresse IP. Puis nous indiquons à docker d’utiliser le réseau bridge pour communiquer avec la base de donnée.

        networks:
          mcvlan_nw:
            ipv4_address: "192.168.1.1"
          net_wordpress:

    WordPress a besoin de Mariadb pour fonctionner. Nous allons l’indiquer :

          depends_on:
            - bdd   #bdd est le nom du container qui hébergera Mariadb

    Puis nous allons indiquer tous les volumes et les environnements nécessaires en variable.

        volumes:
          - ${WORDPRESS_LOCAL_HOME}:/var/www/html
          - ${WORDPRESS_UPLOADS_CONFIG}:/usr/local/etc/php/conf.d/uploads.ini
          - ${WORDPRESS_MUPLUGINS}:/var/www/html/test/wp-content/mu-plugins
    
        environment:
          - WORDPRESS_DB_HOST=${WORDPRESS_DB_HOST}
          - WORDPRESS_DB_NAME=${MYSQL_DATABASE}
          - WORDPRESS_DB_USER=${MYSQL_USER}
          - WORDPRESS_DB_PASSWORD=${MYSQL_PASSWORD}
          - WORDPRESS_TABLE_PREFIX=${DB_PREFIX}

    Nous procéderons de la même manière pour créer notre container MariaDB.

      bdd:
        # default port 3306
        image: 'mariadb'
        hostname: bdd
        container_name: bdd
        env_file:
          - .env
        restart: unless-stopped
        networks:
          - nt_wordpress
        environment:
          - MYSQL_DATABASE=${MYSQL_DATABASE}
          - MYSQL_USER=${MYSQL_USER}
          - MYSQL_PASSWORD=${MYSQL_PASSWORD}
          - MYSQL_ROOT_PASSWORD=${MYSQL_ROOT_PASSWORD}
        volumes:
          - ${MYSQL_LOCAL_HOME}:/var/lib/mysql

    Puis nous finirons par déclarer les réseaux. nt_wordpress sera créé en mode bridge, et nous indiquons que le réseau mcvlan_nw est déjà créé et que le container doit s’y connecter.

    networks:
      nt_wordpress:
        name: nt_wordpress
        driver: bridge
    
      mcvlan_nw:
        external: true

    Ce qui donne à la fin :

    services:
    
      wordpress:
        image: 'wordpress'
        container_name: wordpress
        hostname: wordpress
        env_file:
          - .env
        restart: unless-stopped
    
        networks:
          mcvlan_nw:
            ipv4_address: "192.168.1.1"
          nt_wordpress:
    
        depends_on:
          - bdd
        volumes:
          - ${WORDPRESS_LOCAL_HOME}:/var/www/html
          - ${WORDPRESS_UPLOADS_CONFIG}:/usr/local/etc/php/conf.d/uploads.ini
          - ${WORDPRESS_MUPLUGINS}:/var/www/html/test/wp-content/mu-plugins
    
        environment:
          - WORDPRESS_DB_HOST=${WORDPRESS_DB_HOST}
          - WORDPRESS_DB_NAME=${MYSQL_DATABASE}
          - WORDPRESS_DB_USER=${MYSQL_USER}
          - WORDPRESS_DB_PASSWORD=${MYSQL_PASSWORD}
          - WORDPRESS_TABLE_PREFIX=${DB_PREFIX}
    
      bdd:
        # default port 3306
        image: 'mariadb'
        hostname: bdd
        container_name: bdd
        env_file:
          - .env
        restart: unless-stopped
        networks:
          - nt_wordpress
        environment:
          - MYSQL_DATABASE=${MYSQL_DATABASE}
          - MYSQL_USER=${MYSQL_USER}
          - MYSQL_PASSWORD=${MYSQL_PASSWORD}
          - MYSQL_ROOT_PASSWORD=${MYSQL_ROOT_PASSWORD}
        volumes:
          - ${MYSQL_LOCAL_HOME}:/var/lib/mysql
    
    networks:
      nt_wordpress:
        name: nt_wordpress
        driver: bridge
    
      mcvlan_nw:
        external: true

    Il nous manque maintenant le fichier des variables. On va créer le fichier .env

    sudo nano .env

    Puis nous indiquons les variables et les valeurs.

    #variable wordpress
    
    export WORDPRESS_LOCAL_HOME=./wordpress
    export WORDPRESS_UPLOADS_CONFIG=./config/uploads.ini
    export WORDPRESS_MUPLUGINS=./mu-plugins
    
    #variable mariadb
    
    export WORDPRESS_DB_HOST=bdd   
    export MYSQL_LOCAL_HOME=./mariadb
    export MYSQL_DATABASE=wordpress 
    export MYSQL_USER=NOM_USER  
    export MYSQL_PASSWORD=mot_de_passe_fort
    export MYSQL_ROOT_PASSWORD=mot_de_passe_encore_plus_fort
    
    export DB_PREFIX=mywp_

    Une fois toutes ces étapes réalisées, il suffira de lancer notre programme.

    sudo docker compose up -d

    Finalement il n’y aura plus qu’à renseigner l’IP du réseau macvlan pour s’y connecter.

    Dans notre exemple, il s’agira de http://192.168.1.1

    Conclusion

    Nous avons vu comment effectuer l’installation de WordPress sous docker.

    Encore une fois, Docker nous permet d’installer facilement un ensemble d’application très facilement.

    Lors d’un prochain article nous verrons comment rajouter Nginx, créer un nom de domaine gratuitement, et la mise en place du certificat https.