Laravel Docker · 19 min read · Sep 23, 2025

Comment installer Laravel avec Docker sur Ubuntu 22.04

Laravel est un framework PHP gratuit et open-source qui fournit un ensemble d’outils et de ressources pour construire des applications PHP modernes. Avec une grande variété de packages et d’extensions compatibles, Laravel est devenu populaire, de nombreux développeurs l’adoptant comme leur framework de choix. Laravel fournit des outils de base de données puissants, y compris un ORM (Object Relational Mapper) appelé Eloquent et des mécanismes intégrés pour créer des migrations de base de données. Il est livré avec un outil en ligne de commande Artisan, grâce auquel les développeurs peuvent initialiser de nouveaux modèles, contrôleurs et autres composants d’application, ce qui accélère le développement global de l’application.

Containeriser une application fait référence au processus d’adaptation d’une application et de ses composants pour pouvoir l’exécuter dans des environnements légers connus sous le nom de conteneurs. Ce guide utilisera Docker Compose pour containeriser une application Laravel pour le développement.

Nous allons créer trois conteneurs Docker pour notre application Laravel.

  • Un service app exécutant PHP 8.2-FPM
  • Un service db exécutant MySQL 8.0
  • Un service nginx qui utilise le service app pour analyser le code PHP avant de servir l’application Laravel à l’utilisateur

Nous allons également créer un certificat SSL pour notre site Web Laravel en utilisant Let’s Encrypt.

Prérequis

  • Un serveur exécutant Ubuntu 22.04.
  • Un utilisateur non-root avec des privilèges sudo.
  • Un nom de domaine entièrement qualifié (FQDN) pointant vers votre serveur. Pour nos besoins, nous utiliserons example.com comme nom de domaine.
  • Assurez-vous que tout est à jour. $ sudo apt update
  • Installez des packages utilitaires de base. Certains d’entre eux peuvent déjà être installés. $ sudo apt install wget curl nano software-properties-common dirmngr apt-transport-https gnupg gnupg2 ca-certificates lsb-release ubuntu-keyring unzip -y

Étape 1 - Configurer le pare-feu

La première étape consiste à configurer le pare-feu. Ubuntu est livré avec ufw (Uncomplicated Firewall) par défaut.

Vérifiez si le pare-feu est en cours d’exécution.

$ sudo ufw status

Vous devriez obtenir la sortie suivante.

Status: inactive

Autorisez le port SSH afin que le pare-feu ne rompe pas la connexion actuelle lors de son activation.

$ sudo ufw allow OpenSSH

Autorisez également les ports HTTP et HTTPS.

$ sudo ufw allow http
$ sudo ufw allow https

Activez le pare-feu

$ sudo ufw enable
La commande peut perturber les connexions ssh existantes. Poursuivre l'opération (y|n)? y
Le pare-feu est actif et activé au démarrage du système

Vérifiez à nouveau l’état du pare-feu.

$ sudo ufw status

Vous devriez voir une sortie similaire.

Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
80/tcp                     ALLOW       Anywhere
443                        ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
80/tcp (v6)                ALLOW       Anywhere (v6)
443 (v6)                   ALLOW       Anywhere (v6)

Étape 2 - Installer SSL

Avant de continuer, créons d’abord un certificat SSL pour notre domaine. Nous allons créer cela en dehors de Docker car il est facile à maintenir. Nous synchroniserons plus tard les certificats avec le conteneur qui sera renouvelé et rafraîchi régulièrement.

Nous devons installer Certbot pour générer le certificat SSL. Vous pouvez soit installer Certbot en utilisant le dépôt d’Ubuntu, soit obtenir la dernière version en utilisant l’outil Snapd. Nous utiliserons la version Snapd.

Ubuntu 22.04 est livré avec Snapd installé par défaut. Exécutez les commandes suivantes pour vous assurer que votre version de Snapd est à jour. Assurez-vous que votre version de Snapd est à jour.

$ sudo snap install core
$ sudo snap refresh core

Installez Certbot.

$ sudo snap install --classic certbot

Utilisez la commande suivante pour vous assurer que la commande Certbot s’exécute en créant un lien symbolique vers le répertoire /usr/bin.

$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

Exécutez la commande suivante pour générer un certificat SSL.

$ sudo certbot certonly --standalone --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d example.com

La commande ci-dessus téléchargera un certificat dans le répertoire /etc/letsencrypt/live/example.com sur votre serveur.

Générez un certificat Diffie-Hellman group.

$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096

Faites un essai à blanc du processus pour vérifier si le renouvellement SSL fonctionne correctement.

$ sudo certbot renew --dry-run

Si vous ne voyez pas d’erreurs, vous êtes prêt. Votre certificat sera renouvelé automatiquement.

Après avoir configuré Docker et installé Laravel, le processus de renouvellement devra être modifié. Nous le couvrirons dans une section ultérieure.

Étape 3 - Installer Docker et Docker Compose

Ubuntu 22.04 est livré avec une version plus ancienne de Docker. Pour installer la dernière version, commencez par importer la clé GPG de Docker.

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

Créez un fichier de dépôt Docker.

$ echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Mettez à jour la liste des dépôts du système.

$ sudo apt update

Installez la dernière version de Docker.

$ sudo apt install docker-ce docker-ce-cli containerd.io docker-compose-plugin

Vérifiez qu’il fonctionne.

$ sudo systemctl status docker
? docker.service - Docker Application Container Engine
     Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled)
     Active: active (running) since Sat 2023-01-14 10:41:35 UTC; 2min 1s ago
TriggeredBy: ? docker.socket
       Docs: https://docs.docker.com
   Main PID: 2054 (dockerd)
      Tasks: 52
     Memory: 22.5M
        CPU: 248ms
     CGroup: /system.slice/docker.service
             ??  2054 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock

Par défaut, Docker nécessite des privilèges root. Si vous souhaitez éviter d’utiliser sudo chaque fois que vous exécutez la commande docker, ajoutez votre nom d’utilisateur au groupe docker.

$ sudo usermod -aG docker $(whoami)

Vous devrez vous déconnecter du serveur et vous reconnecter en tant que même utilisateur pour activer ce changement ou utiliser la commande suivante.

$ su - ${USER}

Confirmez que votre utilisateur est ajouté au groupe Docker.

$ groups
navjot wheel docker

Étape 4 - Télécharger Laravel et installer les dépendances

La première étape consiste à télécharger la dernière version de Laravel et à installer les dépendances, y compris Composer, le gestionnaire de packages PHP.

Créez le répertoire de l’application Laravel.

$ mkdir ~/laravel

Passez au répertoire.

$ cd ~/laravel

Clonez la dernière version de Laravel dans le répertoire. N’oubliez pas le . à la fin de la commande, ce qui signifie que Git clonera les fichiers dans le répertoire actuel.

$ git clone https://github.com/laravel/laravel.git .

Utilisez l’image Compose de Docker pour monter les répertoires dont vous avez besoin pour votre projet Laravel. Cela évite la nécessité d’installer Composer globalement.

$ docker run --rm -v $(pwd):/app composer install

La commande ci-dessus crée un conteneur éphémère qui est monté en liaison avec votre répertoire actuel avant d’être supprimé. Il copie le contenu de votre répertoire Laravel dans le conteneur et s’assure que le dossier vendor que Composer crée à l’intérieur du conteneur est copié dans le répertoire actuel.

Définissez les permissions sur le répertoire Laravel afin qu’il soit possédé par l’utilisateur actuellement connecté.

$ sudo chown -R $USER:$USER ~/laravel

Étape 5 - Créer le fichier Docker Compose

Créez et ouvrez le fichier Docker compose pour l’édition.

$ nano docker-compose.yml

Collez le code suivant dedans. Ici, nous définissons trois services : app, webserver et db. Remplacez MYSQL_ROOT_PASSWORD sous le service db par un mot de passe fort de votre choix.

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    image: howtoforge/app
    container_name: app
    restart: unless-stopped
    tty: true
    environment:
      SERVICE_NAME: app
      SERVICE_TAGS: dev
    working_dir: /var/www
    volumes:
      - ./:/var/www
      - ./php/local.ini:/usr/local/etc/php/conf.d/local.ini
    networks:
      - app-network

  webserver:
    container_name: webserver
    image: nginx:alpine
    restart: unless-stopped
    tty: true
    ports:
        - 80:80
        - 443:443
    volumes:
        - ./:/var/www
        - ./nginx/conf.d:/etc/nginx/conf.d
        - ./nginx/logs:/var/log/nginx
        - /etc/ssl/certs/dhparam.pem:/etc/ssl/certs/dhparam.pem
        - /etc/letsencrypt:/etc/letsencrypt
    logging:
        options:
            max-size: "10m"
            max-file: "3"
    networks:
      - app-network

  db:
    image: mysql:latest
    container_name: db
    restart: unless-stopped
    tty: true
    ports:
      - "3306:3306"
    environment:
      MYSQL_DATABASE: laravel
      MYSQL_ROOT_PASSWORD: MYSQL_ROOT_PASSWORD
      MYSQL_USER: laraveluser
      MYSQL_PASSWORD: password
      SERVICE_TAGS: dev
      SERVICE_NAME: mysql
    volumes:
      - dbdata:/var/lib/mysql
      - ./mysql/my.cnf:/etc/mysql/my.cnf
    networks:
      - app-network

volumes:
  dbdata:
    driver: local

networks:
  app-network:
    driver: bridge

Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.

Passons en revue les services en détail.

  • app - Ce service définit l’application Laravel et exécute une image Docker personnalisée intitulée howtoforge/app. Nous créerons cette image à l’étape suivante. Le répertoire de travail pour Laravel à l’intérieur du conteneur est défini à /var/www, qui est mappé au répertoire actuel sur l’hôte. Nous montons également un fichier de configuration PHP qui est copié dans le conteneur PHP. Nous configurerons cela dans une étape ultérieure.
  • webserver - Ce service crée un conteneur en utilisant l’image Docker Nginx et expose les ports 80 et 443 à l’hôte. Nous montons également des volumes pour les journaux Nginx, la configuration personnalisée, le répertoire de l’application Laravel et les certificats SSL.
  • db - Ce service crée un conteneur en utilisant l’image Docker MySQL et définit des variables d’environnement configurant le nom de la base de données et le mot de passe root MySQL. Vous pouvez nommer la base de données comme vous le souhaitez et remplacer MYSQL_ROOT_PASSWORD par un mot de passe fort de votre choix. De plus, définissez le nom d’utilisateur MySQL (MYSQL_USER_NAME) et le mot de passe (MYSQL_USER_PASSWORD) qui auront accès à la base de données que vous avez choisie. Ce service mappe également le port 3306 du conteneur au port 3306 de l’hôte. Nous montons également un volume pour la configuration MySQL personnalisée et un volume local pour les données MySQL. Cela vous permet de redémarrer le service db sans perdre les données.

Pour permettre aux services de communiquer entre eux, nous avons créé un réseau Docker appelé app-network. Il est défini comme un réseau de pont. Cela permet aux conteneurs qui y sont connectés de communiquer entre eux. Le pilote de réseau de pont installe des règles sur la machine hôte afin que les conteneurs sur différents réseaux de pont ne puissent pas communiquer directement entre eux.

Étape 6 - Créer le Dockerfile

Un Dockerfile est utilisé pour créer des images personnalisées. Il n’existe pas d’image standard pour Laravel, c’est pourquoi nous devons définir un Dockerfile pour créer une image personnalisée pour Laravel. Il contient des commandes pour installer des packages et configurer l’environnement Linux en fonction des besoins de votre application. Vous pouvez également publier votre image personnalisée sur Docker Hub ou tout registre Docker privé. Vous pouvez en savoir plus dans notre tutoriel Dockerfile.

Créez et ouvrez le Dockerfile pour l’édition.

$ nano Dockerfile

Collez le code suivant dedans.

FROM php:8.2-fpm

# Copier composer.lock et composer.json
COPY composer.lock composer.json /var/www/

# Définir le répertoire de travail
WORKDIR /var/www

# Installer les dépendances
RUN apt-get update && apt-get install -y \
    build-essential \
    libpng-dev \
    libjpeg62-turbo-dev \
    libfreetype6-dev \
    locales \
    zip \
    jpegoptim optipng pngquant gifsicle \
    vim \
    libzip-dev \
    unzip \
    git \
    curl \
    libonig-dev

# Effacer le cache
RUN apt-get clean && rm -rf /var/lib/apt/lists/*

# Installer les extensions
RUN docker-php-ext-install pdo_mysql mbstring zip exif pcntl
RUN docker-php-ext-configure gd --enable-gd --with-freetype --with-jpeg
RUN docker-php-ext-install gd

# Installer composer
RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer

# Copier le contenu du répertoire d'application existant dans le répertoire de travail
COPY . /var/www

# Attribuer les permissions du répertoire de travail à l'utilisateur www-data
RUN chown -R www-data:www-data \
        /var/www/storage \
        /var/www/bootstrap/cache

# Attribuer les permissions d'écriture aux journaux et aux répertoires de framework
RUN chmod 775 storage/logs \
        /var/www/storage/framework/sessions \
        /var/www/storage/framework/views

# Exposer le port 9000 et démarrer le serveur php-fpm
EXPOSE 9000
CMD ["php-fpm"]

Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.

Voyons ce qui se passe ici. Tout d’abord, nous créons notre image personnalisée sur la base de l’image php:8.2-fpm Docker. Il s’agit d’une image basée sur Debian qui a PHP 8.2-FPM installé. Le Dockerfile utilise diverses directives pour effectuer des opérations, la directive RUN spécifie les commandes pour mettre à jour, installer et configurer les paramètres à l’intérieur du conteneur, la directive COPY pour copier des fichiers dans le conteneur, la directive EXPOSE pour exposer un port dans le conteneur, et la directive CMD pour exécuter une commande.

Tout d’abord, nous copions les fichiers Composer du répertoire Laravel sur l’hôte à l’intérieur du conteneur dans le répertoire /var/www. Nous définissons également le répertoire de travail pour le conteneur à /var/www. Ensuite, nous installons divers prérequis et packages nécessaires au fonctionnement de Laravel, y compris les extensions PHP telles que mbstring, gd, exif, zip, pdo_mysql et pcntl. Ensuite, nous installons le gestionnaire de packages Composer.

Ensuite, nous copions tous les fichiers du répertoire Laravel dans le conteneur et définissons les permissions sur le répertoire de travail pour l’utilisateur www-data. C’est l’utilisateur que PHP utilise par défaut sur la plateforme Debian. Ensuite, nous définissons les bonnes permissions d’écriture pour les journaux, les sessions et les répertoires de vues de Laravel.

Et enfin, nous exposons le port 9000 pour le service PHP-FPM qui sera utilisé par le serveur Nginx, et exécutons la commande PHP pour démarrer le conteneur.

Étape 7 - Configurer PHP

Créez le répertoire PHP.

$ mkdir ~/laravel/php

Créez et ouvrez le fichier local.ini pour l’édition.

$ nano local.ini

Collez le code suivant dedans.

upload_max_filesize=40M
post_max_size=40M

Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité. Ces directives définissent la taille maximale téléchargée pour les fichiers téléchargés. Changez la valeur selon vos besoins. Vous pouvez mettre n’importe quelle configuration spécifique à PHP pour remplacer les directives par défaut.

Étape 8 - Configurer Nginx

Créez le répertoire Nginx pour la configuration du site.

$ mkdir ~/laravel/nginx/conf.d -p

Nous devons créer un fichier de configuration Nginx pour utiliser PHP-FPM comme serveur FastCGI pour servir Laravel.

Créez et ouvrez le fichier app.conf pour l’édition.

$ nano ~/laravel/nginx/conf.d/app.conf

Collez le code suivant dedans.

server {
    # Rediriger toutes les requêtes http vers https
    listen 80;
    listen [::]:80;
    server_name example.com;
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    index index.php index.html;

    error_log  /var/log/nginx/error.log;
    access_log /var/log/nginx/access.log;

    root /var/www/public;
    client_max_body_size 40m;

    ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
    ssl_trusted_certificate /etc/letsencrypt/live/example.com/chain.pem;
    ssl_session_timeout 1d;
    ssl_session_cache shared:SSL:10m;
    ssl_session_tickets off;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
    ssl_prefer_server_ciphers off;
    ssl_ecdh_curve secp384r1;
    ssl_dhparam /etc/ssl/certs/dhparam.pem;

    # OCSP stapling
    ssl_stapling on;
    ssl_stapling_verify on;
    resolver 8.8.8.8 8.8.4.4 valid=300s;
    resolver_timeout 5s;

    location ~ \.php$ {
        try_files $uri =404;
        fastcgi_split_path_info ^(.+\.php)(/.+)$;
        fastcgi_pass app:9000;
        fastcgi_index index.php;
        include fastcgi_params;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        fastcgi_param PATH_INFO $fastcgi_path_info;
    }
    location / {
        try_files $uri $uri/ /index.php?$query_string;
        gzip_static on;
    }
}

Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.

Le fichier ci-dessus configure Nginx pour servir à la fois les versions HTTP et HTTPS du site Laravel et redirige automatiquement toute requête HTTP vers HTTPS. Assurez-vous que la valeur de la variable client_max_body_size correspond à la taille de téléchargement définie à l’étape précédente.

Dans le bloc de localisation PHP, la directive fastcgi_pass spécifie que le service app écoute sur un socket TCP sur le port 9000. Le serveur PHP-FPM peut également écouter sur un socket Unix, ce qui a un avantage par rapport à un socket TCP. Mais cela ne fonctionne pas si les services s’exécutent sur des hôtes différents, ce qui est le cas ici, car le conteneur app s’exécute sur un hôte différent de votre conteneur webserver.

Étape 9 - Configurer MySQL

Nous allons configurer MySQL pour activer le journal des requêtes générales et spécifier le fichier journal correspondant.

Créez le répertoire MySQL.

$ mkdir ~/laravel/mysql

Créez et ouvrez le fichier my.cnf pour l’édition.

$ nano ~/laravel/my.cnf

Collez le code suivant dedans.

[mysqld]
general_log = 1
general_log_file = /var/lib/mysql/general.log

Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.

Étape 10 - Configuration du fichier d’environnement

Maintenant que nous avons créé et configuré tous les services, il est temps de démarrer les conteneurs. Mais avant de le faire, nous devons configurer les variables d’environnement pour Laravel. Laravel est livré avec un fichier d’environnement par défaut, .env.example.

Créez une copie du fichier d’environnement exemple.

$ cp .env.example .env

Ouvrez le fichier .env pour l’édition.

$ nano .env

Trouvez le bloc commençant par DB_CONNECTION et mettez à jour les valeurs des variables selon vos besoins.

DB_CONNECTION=mysql
DB_HOST=db
DB_PORT=3306
DB_DATABASE=laravel
DB_USERNAME=laraveluser
DB_PASSWORD=your_laravel_db_password

La valeur de DB_HOST sera le service db. Les valeurs DB_NAME, DB_USERNAME et DB_PASSWORD seront le nom de la base de données, le nom d’utilisateur et le mot de passe que vous avez choisis à l’étape 4 dans le fichier Docker compose.

Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.

Étape 11 - Démarrer les conteneurs et terminer l’installation de Laravel

Il est enfin temps de démarrer les conteneurs.

$ docker compose up -d

Cette commande, lorsqu’elle est exécutée pour la première fois, téléchargera les images Nginx, MySQL et créera l’image app en utilisant le Dockerfile que nous avons créé. Une fois le processus terminé, vous pouvez vérifier l’état de vos conteneurs en utilisant la commande suivante.

$ docker ps

Vous verrez une sortie similaire.

CONTAINER ID   IMAGE            COMMAND                  CREATED       STATUS       PORTS                                                                      NAMES
a57be976c0fa   mysql:latest     "docker-entrypoint.s…"   6 hours ago   Up 6 hours   0.0.0.0:3306->3306/tcp, :::3306->3306/tcp, 33060/tcp                       db
85e515c4a404   howtoforge/app   "docker-php-entrypoi…"   6 hours ago   Up 6 hours   9000/tcp                                                                   app
8418bbc83bd3   nginx:alpine     "/docker-entrypoint.…"   6 hours ago   Up 6 hours   0.0.0.0:80->80/tcp, :::80->80/tcp, 0.0.0.0:443->443/tcp, :::443->443/tcp   webserver

Une fois que les conteneurs sont en cours d’exécution, il est temps de terminer l’installation de Laravel en utilisant la commande docker compose exec pour exécuter des commandes à l’intérieur du conteneur.

Générez une clé d’application et copiez-la dans votre fichier .env pour sécuriser les sessions utilisateur et chiffrer les données utilisateur.

$ docker compose exec app php artisan key:generate

Créez le cache de l’application Laravel.

$ docker compose exec app php artisan config:cache

Cette commande chargera les paramètres de configuration dans le fichier /var/www/bootstrap/cache/config.php.

Visitez https://example.com dans votre navigateur et vous verrez la page suivante impliquant l’installation réussie de Laravel.

Page d'accueil de Laravel

Étape 12 - Configurer le renouvellement SSL

Maintenant que le site Laravel est actif, il est temps de revenir sur les paramètres SSL pour configurer le renouvellement. Pour cela, nous devrons créer des scripts pour arrêter le service webserver avant de commencer le renouvellement et redémarrer le service une fois le certificat renouvelé. Certbot fournit deux hooks, pre_hook et post_hook à cet effet.

Créez le répertoire SSL pour stocker les scripts.

$ mkdir ~/laravel/ssl

Créez le script server-stop.sh.

$ sh -c 'printf "#!/bin/sh\ndocker stop webserver\n" > ~/laravel/ssl/server-stop.sh'

Créez le script server-start.sh.

$ sh -c 'printf "#!/bin/sh\ndocker start webserver\n" > ~/laravel/ssl/server-start.sh'

Rendez les scripts exécutables.

$ chmod +x ~/laravel/ssl/server-*.sh

Maintenant, nous devons dire à Certbot d’utiliser ces scripts. Ouvrez le fichier /etc/letsencrypt/renewal/example.com.conf pour l’édition.

$ sudo nano /etc/letsencrypt/renewal/example.com.conf

Collez les lignes suivantes à la fin du fichier.

pre_hook = /home//laravel/ssl/server-stop.sh
post_hook = /home//laravel/ssl/server-start.sh

Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.

Testez le processus de renouvellement du certificat en effectuant un essai à blanc.

$ sudo certbot renew --dry-run

Vous obtiendrez une sortie similaire confirmant le succès.

Saving debug log to /var/log/letsencrypt/letsencrypt.log

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Processing /etc/letsencrypt/renewal/example.com.conf
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Account registered.
Hook 'pre-hook' ran with output:
 webserver
Simulating renewal of an existing certificate for example.com

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Congratulations, all simulated renewals succeeded:
  /etc/letsencrypt/live/example.com/fullchain.pem (success)
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Hook 'post-hook' ran with output:
 webserver

Vos certificats SSL seront désormais renouvelés automatiquement et utilisés par le conteneur Docker pour servir votre application Laravel.

Étape 13 - Migration des données et console Tinker

Maintenant que l’application fonctionne, vous pouvez migrer vos données et expérimenter avec la commande tinker. Tinker est un REPL (Read-Eval-Print Loop) pour Laravel. La commande tinker initie une console PsySH préchargée avec Laravel. PsySH est une console de développeur à l’exécution et un débogueur interactif pour PHP. La commande tinker vous permet d’interagir avec l’application Laravel depuis la ligne de commande dans un shell interactif.

Testez la connexion MySQL en utilisant la commande artisan migrate sur le conteneur. Cela créera une table migrations dans la base de données.

$ docker compose exec app php artisan migrate

Vous obtiendrez la sortie suivante.

 INFO  Preparing database.

  Creating migration table .............................................................................................. 32ms DONE

 INFO  Running migrations.

  2014_10_12_000000_create_users_table .................................................................................. 184ms DONE
  2014_10_12_100000_create_password_resets_table ......................................................................... 259ms DONE
  2019_08_19_000000_create_failed_jobs_table ............................................................................ 102ms DONE
  2019_12_14_000001_create_personal_access_tokens_table .................................................................. 46ms DONE

Ensuite, démarrez la console PsySH en utilisant la commande tinker.

$ docker compose exec app php artisan tinker

Vous obtiendrez l’invite suivante.

Psy Shell v0.11.10 (PHP 8.2.1 — cli) by Justin Hileman
>

Testez la connexion MySQL en récupérant les données que vous venez de migrer en exécutant la commande suivante à l’invite de la console.

> \DB::table('migrations')->get();

Vous obtiendrez la sortie suivante.

= Illuminate\Support\Collection {#3670
    all: [
      {#3679
        +"id": 1,
        +"migration": "2014_10_12_000000_create_users_table",
        +"batch": 1,
      },
      {#3681
        +"id": 2,
        +"migration": "2014_10_12_100000_create_password_resets_table",
        +"batch": 1,
      },
      {#3682
        +"id": 3,
        +"migration": "2019_08_19_000000_create_failed_jobs_table",
        +"batch": 1,
      },
      {#3683
        +"id": 4,
        +"migration": "2019_12_14_000001_create_personal_access_tokens_table",
        +"batch": 1,
      },
    ],
  }

Tapez exit pour sortir de la console.

> exit
   INFO  Goodbye.

Vous pouvez utiliser tinker pour interagir avec vos bases de données et expérimenter avec des services et des modèles. Vous pouvez maintenant commencer à utiliser Laravel pour un développement ultérieur.

Conclusion

Cela conclut notre tutoriel, où vous avez containerisé et installé l’application Laravel en utilisant Docker, MySQL et PHP. Vous avez également servi l’application sur un nom de domaine sécurisé. Si vous avez des questions, postez-les dans les commentaires ci-dessous.

Share: X/Twitter LinkedIn
#Laravel Docker

Recevez de nouveaux articles dans votre boîte de réception.

Aucun spam. Désabonnez-vous à tout moment.