GNU/Linux >> Tutoriels Linux >  >> Ubuntu

Comment créer des images Docker avec un Dockerfile sur Ubuntu 16.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, je vais vous montrer comment créer votre propre image docker avec un dockerfile. Je vais vous expliquer en détail le script dockerfile pour vous permettre de créer vos propres scripts dockerfile.

Prérequis

  • Un serveur Linux :j'utiliserai Ubuntu 16.04 comme machine hôte et Ubuntu 16.04 comme image de base du menu fixe.
  • Privilèges racine.
  • Comprendre la commande Docker

Introduction à la commande Dockerfile

Un dockerfile est un script qui contient une collection de commandes dockerfile et de commandes du système d'exploitation (ex :commandes Linux). Avant de créer notre premier dockerfile, vous devez vous familiariser avec la commande dockerfile.

Vous trouverez ci-dessous quelques commandes dockerfile que vous devez connaître :

DE

L'image de base pour créer une nouvelle image. Cette commande doit se trouver au-dessus du dockerfile.

MAINTENEUR

Facultatif, il contient le nom du responsable de l'image.

EXÉCUTER

Utilisé pour exécuter une commande pendant le processus de construction de l'image docker.

AJOUTER

Copiez un fichier de la machine hôte vers la nouvelle image docker. Il existe une option pour utiliser une URL pour le fichier, docker téléchargera ensuite ce fichier dans le répertoire de destination.

ENV

Définir une variable d'environnement.

CMD

Utilisé pour exécuter des commandes lorsque nous construisons un nouveau conteneur à partir de l'image docker.

POINT D'ENTREE

Définissez la commande par défaut qui sera exécutée lors de l'exécution du conteneur.

REP_TRAVAIL

Ceci est une directive pour que la commande CMD soit exécutée.

UTILISATEUR

Définissez l'utilisateur ou l'UID du conteneur créé avec l'image.

VOLUME

Activer l'accès/répertoire lié entre le conteneur et la machine hôte.

Commençons maintenant à créer notre premier dockerfile.

Étape 1 - Installation de Docker

Connectez-vous à votre serveur et mettez à jour le référentiel de logiciels.

ssh [email protected]
apt-get update

Installez docker.io avec cette commande apt :

apt-get install docker.io

Une fois l'installation terminée, démarrez le service Docker et activez-le pour qu'il démarre au démarrage :

systemctl start docker
systemctl enable docker

Docker a été installé et s'exécute sur le système.

Étape 2 - Créer Dockerfile

Dans cette étape, nous allons créer un nouveau répertoire pour le dockerfile et définir ce que nous voulons faire avec ce dockerfile.

Créez un nouveau répertoire et un nouveau fichier docker vide dans ce répertoire.

mkdir ~/myimages 
cd myimages/
touch Dockerfile

Ensuite, définissez ce que nous voulons faire avec notre nouvelle image personnalisée. Dans ce didacticiel, j'installerai Nginx et PHP-FPM 7 à l'aide d'une image Docker Ubuntu 16.04. De plus, nous avons besoin de Supervisord, afin de pouvoir démarrer Nginx et PHP-FPM 7 en une seule commande.

Modifiez le 'Dockerfile' avec vim :

nano Dockerfile

En haut du fichier, ajoutez une ligne avec l'image de base (Ubuntu 16.04) que nous voulons utiliser.

#Download base image ubuntu 16.04
FROM ubuntu:16.04

Mettez à jour le référentiel de logiciels Ubuntu dans le dockerfile avec la commande "RUN".

# Update Ubuntu Software repository
RUN apt-get update

Installez ensuite les applications dont nous avons besoin pour l'image personnalisée. Installez Nginx, PHP-FPM et Supervisord à partir du référentiel Ubuntu avec apt. Ajoutez les commandes RUN pour l'installation de Nginx et PHP-FPM.

# Install nginx, php-fpm and supervisord from ubuntu repository
RUN apt-get install -y nginx php7.0-fpm supervisor && \
    rm -rf /var/lib/apt/lists/*

A ce stade, toutes les applications sont installées et nous devons les configurer. Nous allons configurer Nginx pour gérer les applications PHP en modifiant la configuration de l'hôte virtuel par défaut. Nous pouvons le remplacer par notre nouveau fichier de configuration, ou nous pouvons modifier le fichier de configuration existant avec la commande 'sed'.

Dans ce didacticiel, nous remplacerons la configuration par défaut de l'hôte virtuel par une nouvelle configuration en utilisant la commande dockerfile 'COPY'.

#Define the ENV variable
ENV nginx_vhost /etc/nginx/sites-available/default
ENV php_conf /etc/php/7.0/fpm/php.ini
ENV nginx_conf /etc/nginx/nginx.conf
ENV supervisor_conf /etc/supervisor/supervisord.conf

# Enable php-fpm on nginx virtualhost configuration
COPY default ${nginx_vhost}
RUN sed -i -e 's/;cgi.fix_pathinfo=1/cgi.fix_pathinfo=0/g' ${php_conf} && \
    echo "\ndaemon off;" >> ${nginx_conf}

Ensuite, configurez Supervisord pour Nginx et PHP-FPM. Nous allons remplacer la configuration par défaut de Supervisord par une nouvelle configuration en utilisant la commande 'COPY'.

#Copy supervisor configuration
COPY supervisord.conf ${supervisor_conf}

Créez maintenant un nouveau répertoire pour le fichier chaussette php-fpm et remplacez le propriétaire du répertoire /var/www/html et du répertoire PHP par www-data.

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

Ensuite, définissez le volume afin que nous puissions monter les répertoires répertoriés ci-dessous sur la machine hôte.

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

Enfin, configurez la commande de conteneur par défaut "CMD" et ouvrez le port pour HTTP et HTTPS. Nous allons créer un nouveau fichier start.sh pour la commande 'CMD' par défaut au démarrage du conteneur. Le fichier contient la commande 'supervisord', et nous allons copier le fichier dans la nouvelle image avec la commande 'COPY' dockerfile.

# Configure Services and Port
COPY start.sh /start.sh
CMD ["./start.sh"]

EXPOSE 80 443

Enregistrez le fichier et quittez.

Voici le Dockerfile complet en un seul morceau :

#Download base image ubuntu 16.04
FROM ubuntu:16.04
 
# Update Software repository
RUN apt-get update
 
# Install nginx, php-fpm and supervisord from ubuntu repository
RUN apt-get install -y nginx php7.0-fpm supervisor && \
    rm -rf /var/lib/apt/lists/*
 
#Define the ENV variable
ENV nginx_vhost /etc/nginx/sites-available/default
ENV php_conf /etc/php/7.0/fpm/php.ini
ENV nginx_conf /etc/nginx/nginx.conf
ENV supervisor_conf /etc/supervisor/supervisord.conf
 
# Enable php-fpm on nginx virtualhost configuration
COPY default ${nginx_vhost}
RUN sed -i -e 's/;cgi.fix_pathinfo=1/cgi.fix_pathinfo=0/g' ${php_conf} && \
    echo "\ndaemon off;" >> ${nginx_conf}
 
#Copy supervisor configuration
COPY supervisord.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
 
# Volume configuration
VOLUME ["/etc/nginx/sites-enabled", "/etc/nginx/certs", "/etc/nginx/conf.d", "/var/log/nginx", "/var/www/html"]
 
# Configure Services and Port
COPY start.sh /start.sh
CMD ["./start.sh"]
 
EXPOSE 80 443

Maintenant, dans notre répertoire "Dockerfile", créez un nouveau fichier de configuration pour l'hôte virtuel nommé "default", un fichier de configuration de superviseur "supervisord.conf" et un script de configuration de service "start.sh".

vim default

Collez la configuration de l'hôte virtuel par défaut ci-dessous :

server {
    listen 80 default_server;
    listen [::]:80 default_server;
 
    root /var/www/html;
    index index.html index.htm index.nginx-debian.html;
 
    server_name _;
 
    location / {
        try_files $uri $uri/ =404;
    }
 
    location ~ \.php$ {
        include snippets/fastcgi-php.conf;
        fastcgi_pass unix:/run/php/php7.0-fpm.sock;
    }
 
    # deny access to .htaccess files, if Apache's document root
    # concurs with nginx's one
    #
    #location ~ /\.ht {
    #    deny all;
    #}
}

Fichier de configuration du superviseur :

vim supervisord.conf

Collez la configuration ci-dessous :

[unix_http_server]
file=/dev/shm/supervisor.sock   ; (the path to the socket file)
 
[supervisord]
logfile=/var/log/supervisord.log ; (main log file;default $CWD/supervisord.log)
logfile_maxbytes=50MB        ; (max main logfile bytes b4 rotation;default 50MB)
logfile_backups=10           ; (num of main logfile rotation backups;default 10)
loglevel=info                ; (log level;default info; others: debug,warn,trace)
pidfile=/tmp/supervisord.pid ; (supervisord pidfile;default supervisord.pid)
nodaemon=false               ; (start in foreground if true;default false)
minfds=1024                  ; (min. avail startup file descriptors;default 1024)
minprocs=200                 ; (min. avail process descriptors;default 200)
user=root             ;
 
; the below section must remain in the config file for RPC
; (supervisorctl/web interface) to work, additional interfaces may be
; added by defining them in separate rpcinterface: sections
[rpcinterface:supervisor]
supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface
 
[supervisorctl]
serverurl=unix:///dev/shm/supervisor.sock ; use a unix:// URL  for a unix socket
 
; The [include] section can just contain the "files" setting.  This
; setting can list multiple files (separated by whitespace or
; newlines).  It can also contain wildcards.  The filenames are
; interpreted as relative to this file.  Included files *cannot*
; include files themselves.
 
[include]
files = /etc/supervisor/conf.d/*.conf
 
 
[program:php-fpm7.0]
command=/usr/sbin/php-fpm7.0 -F
numprocs=1
autostart=true
autorestart=true
 
[program:nginx]
command=/usr/sbin/nginx
numprocs=1
autostart=true
autorestart=true

Fichier Start.sh.

vim start.sh

Collez la configuration ci-dessous :

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

Enregistrer et quitter

Rendez start.sh exécutable avec la commande chmod :

chmod +x start.sh

Enregistrez le fichier et quittez.

Étape 3 - Créer une nouvelle image Docker et créer un nouveau conteneur basé sur celle-ci

Le Dockerfile et tous les fichiers de configuration requis ont été créés, nous pouvons maintenant créer une nouvelle image docker basée sur Ubuntu 16.04 et notre dockerfile avec la commande docker ci-dessous :

docker build -t nginx_image .

Lorsque la commande s'est terminée avec succès, nous pouvons vérifier la nouvelle image 'nginx_image' avec la commande docker ci-dessous :

docker images

Ensuite, nous pouvons essayer de créer un nouveau conteneur basé sur nginx_images. Et avant de créer un nouveau conteneur, nous pouvons créer un nouveau répertoire sur la machine hôte pour les données webroot.

mkdir -p /webroot

Exécutez maintenant le nouveau conteneur avec la commande ci-dessous :

docker run -d -v /webroot:/var/www/html -p 80:80 --name hakase nginx_image

Ensuite, nous pouvons vérifier que le nouveau conteneur avec le nom hakase basé sur 'nginx_image' est en cours d'exécution :

docker ps

Remarque :

  • --nom hakase nginx_image =Nous créons un nouveau conteneur avec le nom 'hakase', basé sur l'image docker 'nginx_images'.
  • -p 80:80 =conteneur hakase s'exécutant sur le port 80 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.

Le nouveau conteneur basé sur nginx_image s'exécute sans erreur.

Étape 4 - Tester Nginx et PHP-FPM dans le conteneur

Essayez de créer un nouveau fichier index.html dans le répertoire /webroot avec echo :

echo '<h1>Nginx and PHP-FPM 7 inside Docker Container</h1>' > /webroot/index.html

Test avec la commande curl en accédant à l'adresse IP de la machine hôte.

curl 192.168.1.250
curl -I 192.168.1.250

Nous verrons les résultats ci-dessous.

Ensuite, testez que PHP-FPM 7.0 est en cours d'exécution en créant un nouveau fichier phpinfo dans le répertoire /webroot sur la machine hôte.

echo '<?php phpinfo(); ?>' > /webroot/info.php

Ouvrez le navigateur Web et saisissez l'adresse IP de la machine hôte :

http://192.168.1.248/info.php

Vous pouvez maintenant voir la sortie du fichier phpinfo.

la nouvelle image docker 'nginx_image' a été créée avec succès, nous pouvons maintenant créer plus de conteneurs basés sur cette image.


Ubuntu

  1. Comment créer une image Docker avec Dockerfile

  2. Comment installer Docker sur Ubuntu 22.04 / 20.04 LTS

  3. Comment installer ONLYOFFICE 8.9.0 avec Docker sur Ubuntu

  4. Comment installer le serveur Gitlab avec Docker sur Ubuntu 18.04 LTS

  5. Comment créer des images Docker avec un Dockerfile sur Ubuntu 18.04 LTS

Comment installer WordPress avec Docker sur Ubuntu 16.04 LTS

Comment installer Rancher sur Ubuntu 16.04 LTS

Comment installer Docker sur Ubuntu 18.04 LTS

Comment installer Docker sur Ubuntu 20.04 LTS

Comment installer Kitematic sur Ubuntu 20.04 LTS

Comment créer une image Docker personnalisée avec Dockerfile