Comment créer des images Docker avec un Dockerfile sur Ubuntu 20.04 LTS

Docker est une virtualisation au niveau du système d'exploitation principalement destinée aux développeurs et aux administrateurs système. Docker facilite la création et le déploiement d'applications dans un environnement isolé.

Un Dockerfile est un script qui contient des collections de commandes et d'instructions qui seront automatiquement exécutées en séquence dans l'environnement Docker pour créer une nouvelle image Docker.

Dans ce tutoriel, nous allons vous montrer comment créer votre propre image Docker avec un Dockerfile. Nous expliquerons les détails liés au Dockerfile pour vous permettre de créer votre propre image Docker.

Prérequis

Pour ce guide, nous utiliserons Ubuntu 20.04 avec 1 Go de RAM, 25 Go d'espace disque libre et 2 processeurs. De plus, nous utiliserons Ubuntu 20.04 comme image de base pour créer l'image Docker personnalisée.

Introduction à la commande Dockerfile

Un Dockerfile est un script qui contient toutes les commandes permettant de créer une image Docker. Le Dockerfile contient toutes les instructions qui seront utilisées pour créer l'image Docker avec la commande 'docker build'.

Avant de créer votre premier Dockerfile, vous devez vous familiariser avec l'instruction Dockerfile. Ci-dessous quelques instructions Dockerfile que vous devez connaître.

Définissez l'image de base pour la nouvelle image que vous souhaitez créer. L'instruction FROM initialisera la nouvelle étape de construction et doit être située en haut du Dockerfile.

ÉTIQUETTE

Avec cette instruction, vous pouvez ajouter des informations supplémentaires sur votre image Docker, telles que la version, la description, le responsable, etc. L'instruction LABEL est une paire clé-valeur qui vous permet d'ajouter plusieurs étiquettes et valeurs multilignes.

EXÉCUTER

Cette instruction est utilisée pour exécuter la commande pendant le processus de construction de l'image docker. Vous pouvez installer des packages supplémentaires nécessaires pour vos images Docker.

AJOUTER

L'instruction ADD est utilisée pour copier des fichiers, des répertoires ou des fichiers distants de l'URL vers vos images Docker, du 'src' au chemin absolu 'dest'. Vous pouvez également configurer la propriété par défaut de votre fichier.

ENV

L'instruction ENV est utilisée pour définir une variable d'environnement qui peut être utilisée pendant l'étape de construction et peut également être remplacée en ligne dans plusieurs.

CMD

L'instruction CMD permet de définir la commande par défaut à exécuter lors de l'exécution du conteneur. Et le Dockerfile ne doit contenir qu'une seule instruction CMD, et s'il y a plusieurs CMD, la dernière instruction CMD sera exécutée.

EXPOSER

Cette instruction est utilisée pour exposer le port de conteneur sur les ports réseau spécifiques lors de l'exécution. Le protocole par défaut exposé est TCP, mais vous pouvez spécifier s'il s'agit de TCP ou d'UDP.

ARG

L'instruction ARG est utilisée pour définir une variable que l'utilisateur peut passer au moment de la construction. Vous pouvez utiliser cette instruction dans le docker 'build command' pendant la construction en utilisant l'option '--build-arg variable=value' et vous pouvez passer par le Dockerfile. En outre, vous pouvez utiliser plusieurs ARG dans le Dockerfile.

POINT D'ENTREE

L'instruction ENTRYPOINT est utilisée pour définir la première commande par défaut qui sera exécutée lorsque le conteneur est en cours d'exécution. Définissez la commande pour démarrer votre application avec l'instruction ENTRYPOINT.

REP_TRAVAIL

L'instruction WORKDIR est utilisée pour définir le répertoire de travail par défaut de votre image Docker. Les instructions RUN, CMD, ENTRYPOINT et ADD suivent l'instruction WORKDIR. Vous pouvez ajouter plusieurs instructions WORKDIR sur votre Dockerfile, et s'il n'y en a pas, il sera créé automatiquement.

UTILISATEUR

L'instruction USER est utilisée pour définir l'utilisateur ou gid par défaut lors de l'exécution de l'image. RUN, CMD et ENTRYPOINT suivent les instructions USER dans le Dockerfile.

VOLUME

L'annonce d'instruction VOLUME utilisée pour activer l'accès/le répertoire lié entre le conteneur et la machine hôte.

Commençons maintenant à créer le premier Dockerfile.

Étape 1 - Installer Docker sur Ubuntu 20.04

Avant de créer un Dockerfile, nous allons installer le Docker sur notre système Ubuntu 20.04, qui est disponible par défaut sur le référentiel Ubuntu FocalFossa.

Mettez à jour la liste de tous les packages sur le référentiel Ubuntu et installez Docker à l'aide de la commande apt ci-dessous.

mise à jour sudo apt
sudo apt install docker.io

Une fois l'installation terminée, démarrez le service Docker et ajoutez-le au démarrage du système.

systemctl start docker
systemctl enable docker

Vérifiez maintenant le service Docker à l'aide de la commande ci-dessous.

menu fixe d'état systemctl

Le service Docker est opérationnel sur Ubuntu 20.04.

Ensuite, exécutez la commande docker ci-dessous pour vous assurer que l'installation est correcte.

docker lance hello-world

Vous trouverez ci-dessous le résultat que vous obtiendrez.

Bonjour de Docker !
Ce message indique que votre installation semble fonctionner correctement.

Pour générer ce message, Docker a suivi les étapes suivantes :
1. Le Docker client a contacté le démon Docker.
2. Le démon Docker a extrait l'image "hello-world" du hub Docker.
    (amd64)
3. Le démon Docker a créé un nouveau conteneur à partir de ce image qui exécute l'exécutable
    qui produit la sortie que vous êtes en train de lire.
4. Le démon Docker a transmis cette sortie au client Docker, qui l'a envoyée
    à votre terminal.

Pour essayer quelque chose de plus ambitieux, vous pouvez exécuter un conteneur Ubuntu avec :
$ docker run -it ubuntu bash

Partagez des images, automatisez les workflows et bien plus encore avec un ID Docker gratuit :
https://hub.docker.com/

Pour plus d'exemples et d'idées, visitez :
https://docs.docker.com/get-started/

Comme on peut le voir, vous recevez le message Hello World de Docker et l'installation de Docker sur Ubuntu 20.04 s'est terminée avec succès.

Étape 2 - Créer Dockerfile et d'autres configurations

Dans cette étape, nous allons vous montrer comment créer une image Docker personnalisée pour votre application à l'aide de Dockerfile. Nous allons créer une nouvelle image Docker personnalisée basée sur l'image Ubuntu 20.04, pour les services PHP-FPM et Nginx, puis exécuter le nouveau conteneur avec un simple script phpinfo.

Tout d'abord, créez un nouveau répertoire de projet et créez un Dockerfile vide.

mkdir -p nginx-image ; cd nginx-image/
toucher Dockerfile

Modifiez maintenant le script 'Dockerfile' à l'aide de votre propre éditeur (pour cet exemple, nous utilisons vim).

vim Dockerfile

En haut de la ligne, ajoutez l'image de base Ubuntu 20.04 en utilisant l'instruction FROM comme ci-dessous.

#Télécharger l'image de base ubuntu 20.04
DEPUIS ubuntu:20.04

Ajoutez maintenant des informations détaillées sur l'image personnalisée à l'aide de l'instruction LABEL.

# LABEL à propos de l'image personnalisée
LABEL mainteneur="[email protected]"
LABEL version="0.1"
LABEL description="Ceci est une image Docker personnalisée pour \
les services PHP-FPM et Nginx."

Pour l'installation des packages apt, nous sauterons toute étape post-installation interactive à l'aide de la variable d'environnement 'DEBIAN_FRONTEND=noninteractive'.

# Désactiver l'invite lors de l'installation des packages
ARG DEBIAN_FRONTEND=noninteractive

Ensuite, exécutez la commande 'apt update' avant d'installer des packages.

# Mettre à jour le dépôt du logiciel Ubuntu
EXÉCUTER la mise à jour apt

Installez maintenant les packages Nginx, PHP-FPM et superviseur. Une fois l'installation terminée, supprimez le cache de tous les packages pour réduire la taille de l'image personnalisée.

# Installez nginx, php-fpm et superviseurd depuis le référentiel ubuntu
EXÉCUTEZ apt install -y nginx php-fpm superviseur &&\
    rm -rf /var/lib/apt/lists/* &&\ 
    apt propre

Définissez une nouvelle variable d'environnement pouvant être transmise à l'image personnalisée.

#Définir la variable ENV
ENV nginx_vhost /etc/nginx/sites-available/default
ENV php_conf /etc/php/7.4/fpm/php.ini
ENV nginx_conf /etc /nginx/nginx.conf
ENV superviseur_conf /etc/supervisor/supervisord.conf

Copiez maintenant la configuration par défaut de Nginx dans la variable 'nginx_vhost', remplacez la configuration PHP 'cgi.fix_pathinfo=1' par 'cgi.fix_pathinfo=0' dans le fichier de configuration php.ini, puis ajoutez l'option 'daemon off' au variable 'nginx_conf' par défaut.

# Activer PHP-fpm sur la configuration de l'hôte virtuel nginx
COPIER par défaut ${nginx_vhost}
RUN sed -i -e 's/;cgi.fix_pathinfo=1/cgi.fix_pathinfo=0/g' ${php_conf} &&\
    echo "\ndaemon désactivé ;">> ${nginx_conf}

Copiez la configuration de superviseur personnalisée dans la variable 'supervisor_conf'.

#Copier la configuration du superviseur
COPIER superviseurd.conf ${supervisor_conf}

Créez un nouveau répertoire pour le fichier sock PHP-FPM, modifiez la propriété du répertoire racine Web '/var/www/html' et du répertoire PHP-FPM '/run/php' en l'utilisateur par défaut 'www-data'.

RUN mkdir -p /run/php &&\
    chown -R www-data:www-data /var/www/html &&\
    chown -R www-data:www-data / lancer/php

Définissez le volume de l'image personnalisée afin que nous puissions monter tous ces répertoires sur la machine hôte.

# Configuration du volume
VOLUME ["/etc/nginx/sites-enabled", "/etc/nginx/certs", "/etc/nginx/conf.d", "/var/log/nginx ", "/var/www/html"]

Ajoutez maintenant le script 'start.sh' et définissez la commande de conteneur par défaut à l'aide de l'instruction CMD ci-dessous.

# Copier le script start.sh et définir la commande par défaut pour le conteneur
COPIER start.sh /start.sh
CMD ["./start.sh"]

Et le dernier, ouvrez les ports HTTP et HTTPS par défaut sur le conteneur à l'aide de l'instruction EXPOSE.

# Port d'exposition pour l'application 
EXPOSE 80 443

Enregistrez et fermez.

Vous trouverez ci-dessous le script Dockerfile complet que nous venons de créer.

# Télécharger l'image de base ubuntu 20.04
DEPUIS ubuntu :20.04

# LABEL à propos de l'image personnalisée
LABEL mainteneur="[email protected]"
LABEL version ="0.1"
LABEL description="Ceci est une image Docker personnalisée pour \
les services PHP-FPM et Nginx."

# Désactiver l'invite lors de l'installation des packages
 ARG DEBIAN_FRONTEND=noninteractive

# Mettre à jour le référentiel du logiciel Ubuntu
EXÉCUTER la mise à jour apt

# Installer nginx, php-fpm et superviseurd depuis le référentiel ubuntu
EXÉCUTER apt install -y nginx php-fpm superviseur &&\
    rm -rf /var/lib/apt/lists/* &&\
    apt clean
    
# Définir la variable ENV
ENV nginx_vhost /etc/nginx/sites-available/default
ENV php_conf /etc/php/7.4/fpm/php.ini
ENV nginx_conf /etc/nginx/nginx.conf
 ENV superviseur_conf /etc/supervisor/supervisord.conf

# Activer PHP-fpm sur la configuration de l'hôte virtuel nginx
COPIER par défaut ${nginx_vhost}
RUN sed -i -e 's/;cgi.fix_pathinfo=1/ cgi.fix_pathinfo=0/g' ${php_conf} &&\
    echo "\ndaemon désactivé ;">> ${nginx_conf}
    
# Copier la configuration du superviseur
COPIER superviseurd.conf ${supervisor_conf}

RUN mkdir -p /run/php &&\
    chown -R www-data:www-data /var/www/html &&\
    chown -R www-data:www-data /run/php
    
# Configuration du volume
VOLUME ["/etc/nginx/sites-enabled", "/etc/nginx/certs", "/etc/nginx/conf.d", "/var/log/nginx", "/var/www /html"]

# Copier le script start.sh et définir la commande par défaut pour le conteneur
COPIER start.sh /start.sh
CMD ["./start.sh" ]

# Port d'exposition pour l'application 
EXPOSE 80 443

Ensuite, nous allons créer une nouvelle configuration supplémentaire pour Nginx, superviseurd et le script start.sh.

La configuration "par défaut" de l'hôte virtuel Nginx contiendra la section pour le PHP-FPM. En effet, vous pouvez exécuter le script PHP en utilisant l'image personnalisée sans aucune modification.

Créez une nouvelle configuration d'hôte virtuel "par défaut" Nginx avec votre éditeur.

vim par défaut

Collez-y la configuration suivante.

serveur {
    écouter 80 default_server ;
 
    racine /var/www/html ;
    index index.html index.htm index.nginx-debian.html ;
 
    nom_serveur _ ;
 
    emplacement / {
        try_files $uri $uri/ =404 ;
    }
 
    emplacement ~ \. php$ {
        include snippets/fastcgi-php.conf ;
        fastcgi_pass unix:/run/php/php7.4-fpm.sock ;
    }
}

Enregistrez et fermez.

Ensuite, nous allons créer la configuration 'supervisrod.conf' qui contient à la fois les programmes Nginx et PHP-FPM qui s'exécuteront automatiquement.

Créez le fichier 'supervisrod.conf' à l'aide de votre éditeur.

vim superviseurd.conf

Collez-y la configuration suivante.

[unix_http_server]
file=/dev/shm/supervisor.sock  ; (le chemin vers le fichier socket)
 
[superviseur]
logfile=/var/log/supervisord.log; (fichier journal principal ; valeur par défaut $CWD/supervisord.log)
logfile_maxbytes=50 Mo                   ; (nombre maximal d'octets du fichier journal principal b4 rotation ; 50 Mo par défaut)
logfile_backups=10              ; (nombre de sauvegardes de rotation du fichier journal principal ; 10 par défaut)
loglevel=info                         ; (niveau de journal ; informations par défaut ; autres :débogage, avertissement, trace)
pidfile=/tmp/supervisord.pid ; (pidfile superviseur;default superviseurd.pid)
nodaemon=false              ; (débuter au premier plan si vrai ; faux par défaut)
minfds=1024                                      ; (min. descripteurs de fichiers de démarrage avail ; valeur par défaut 1 024)
minprocs=200                             ; (min. descripteurs de processus de disponibilité ; 200 par défaut)
user=root            ;

[rpcinterface:supervisor]
supervisor.rpcinterface_factory =superviseur.rpcinterface:make_main_rpcinterface
 
[supervisorctl]
serverurl=unix:///dev/shm/supervisor.sock ; utiliser une URL unix:// pour un socket unix
 
[include]
files =/etc/supervisor/conf.d/*.conf
 
[programme :php-fpm7.4]
command=/usr/sbin/php-fpm7.4 -F
numprocs=1
autostart=true
autorestart=true
 
[program:nginx]
command=/usr/sbin/nginx
numprocs=1
autostart=true
autorestart=true

Enregistrez et fermez.

Créez maintenant le script 'start.sh' en utilisant t=votre éditeur, il contiendra la commande superviseurd pour démarrer.

vim start.sh

Collez-y la configuration suivante.

#!/bin/sh
/usr/bin/supervisord -n -c /etc/supervisor/supervisord.conf

Enregistrez et fermez.

Rendre le script 'start.sh' exécutable.

chmod +x start.sh

En conséquence, toute la configuration de notre image Docker personnalisée a été créée. Vous trouverez ci-dessous toutes les configurations que nous avons créées.

arbre .

Nous sommes maintenant prêts à créer une nouvelle image personnalisée basée sur ces configurations.

Étape 3 - Créer un nouveau conteneur personnalisé et exécuter un nouveau conteneur

Pour créer l'image personnalisée Docker, accédez au répertoire du projet "nginx-image" et exécutez la commande "docker build" comme ci-dessous.

docker build -t nginx-image .

La commande téléchargera l'image de base Ubuntu 20.04 et créera une nouvelle image personnalisée avec le nom 'nginx-image.

Une fois tous les processus terminés, vérifiez la liste des images Docker disponibles sur votre système à l'aide de la commande suivante.

image docker ls

Vous trouverez ci-dessous le résultat que vous obtiendrez.

Comme on peut le voir, la nouvelle image Docker personnalisée 'nginx-image' a été créée.

Ensuite, nous exécuterons le nouveau conteneur Docker basé sur le "nginx-image".

Sur votre ordinateur local, créez un nouveau répertoire nommé 'webroot' qui sera utilisé pour stocker tous les fichiers Web.

mkdir -p /webroot

Créez maintenant un nouveau conteneur nommé test-container à l'aide de la commande docker run ci-dessous.

docker run -d -v /webroot:/var/www/html -p 8080:80 --name test-container nginx-image

Remarque :

--name test-container nginx-image =Nous créons un nouveau conteneur avec le nom 'test-container', basé sur l'image docker 'nginx-image'.
-p 8080:80 =conteneur test-container s'exécutant sur le port 8080 sur la machine hôte.
-v /webroot:/var/www/html =répertoire /webroot sur la machine hôte réécrivez le répertoire /var/www/html sur le conteneur.

Après cela, vérifiez tous les conteneurs en cours d'exécution sur votre système à l'aide de la commande suivante.

docker ps

Vous trouverez ci-dessous le résultat que vous obtiendrez.

En conséquence, le nouveau conteneur nommé 'test-container' basé sur 'nginx-image' et expose le port 8080 est opérationnel.

Étape 4 - Tester

Pour nous assurer que le conteneur fonctionne correctement, nous allons créer un nouveau fichier index.html et phpinfo dans le répertoire racine '/webroot' sur la machine hôte. Parce que le répertoire '/webroot' est monté dans le répertoire conteneur '/var/www/html'.

Créez le fichier index.html dans le répertoire '/webroot' à l'aide de la commande suivante.

echo 'Nginx et PHP-FPM 7.4 dans le conteneur Docker avec l'image de base Ubuntu 20.04
'> /webroot/index.html

Testez maintenant l'accès à votre conteneur avec la commande curl sur le port 8080.

adresse IP du serveur curl :8080
adresse IP du serveur curl -I :8080

En conséquence, vous obtiendrez la page index.html par défaut que nous venons de créer.

Ensuite, créez un nouveau fichier PHP 'info.php' dans le répertoire '/webroot' pour vous assurer que le service PHP-FPM est en cours d'exécution.

Créez le fichier 'info.php' en utilisant la commande suivante.

echo ''> /webroot/info.php

Ensuite, ouvrez votre navigateur Web et tapez l'adresse IP de votre serveur avec le port '8080' suivi du chemin du fichier 'info.php'.

http://server-ip:8080/info.php

Vous obtiendrez maintenant la page phpinfo comme ci-dessous.

Comme on peut le voir, le 'test-container' a chargé avec succès le script PHP.

Et par conséquent, nous avons réussi à créer une nouvelle image Docker personnalisée et à exécuter le nouveau conteneur basé sur celle-ci avec n'importe quelle erreur.