Catégorie : site web

  • 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.