Comment installer et utiliser Docker sur Ubuntu 20.04/22.04 LTS

Introduction

La fonction de Docker en tant qu’application est de simplifier le processus de gestion des processus d’application dans des conteneurs, ce qui vous permet d’exécuter vos applications via des processus isolés de ressources. Ils présentent des similitudes avec les machines virtuelles, mais les conteneurs sont plus portables, respectueux des ressources et plus dépendants en termes de système d’exploitation hôte.

Dans ce guide, vous allez installer et utiliser Docker Community Edition (CE) sur Ubuntu 20.04 et 22.04 LTS. Vous allez installer Docker lui-même, manipuler les conteneurs et les images, puis placer une image dans un Référentiel Docker.

Prérequis

Vous aurez besoin des éléments suivants pour suivre ce guide:

• Configurer un serveur Ubuntu 20.04 et 22.04 LTS.
• Avoir un compte sur Docker Hub si vous préférez créer des images vous-même et les pousser vers Docker Hub comme vous le verrez aux étapes 7 et 8 de ce guide.

Étape 1 : Installer Docker

Le package d’installation de Docker disponible dans le référentiel officiel Ubuntu n’est probablement pas une version récente. Pour nous assurer que nous obtiendrons cette dernière, nous allons installer Docker à partir du référentiel Docker officiel. Pour cela, nous allons ajouter une nouvelle source de package, donc installez le package après avoir ajouté la clé GPG de Docker pour garantir la validité des téléchargements.

Avant de commencer, vous devrez mettre à jour votre liste de packages existante :

$ sudo apt-get update

Ensuite, pour permettre à apt d’utiliser des packages via HTTPS, vous devrez installer quelques packages prérequis :

$ sudo apt install apt-transport-https ca-certificates curl software-properties-common

Ajoutez maintenant la clé GPG au référentiel Docker officiel de votre système :

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

Ajoutez maintenant le référentiel Docker aux sources APT:

$ 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

Allez-y maintenant et mettez à jour la base de données de packages à l’aide des packages Docker du référentiel nouvellement ajoutés :

$ sudo apt-get update

Vérifiez que vous allez installer à partir du référentiel Docker et non à partir du référentiel Ubuntu par défaut :

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

Docker est maintenant installé, le démon a démarré et le processus activé afin qu’il puisse démarrer au démarrage. Vérifiez qu’il est en cours d’exécution :

$ sudo systemctl status docker

L’output doit montrer que le service est actif et en cours d’exécution et doit ressembler à ceci:

root@ServerB:/home/ubuntu# systemctl status docker
● docker.service - Docker Application Container Engine
     Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled)
     Active: active (running) since Thu 2022-07-28 09:49:02 UTC; 8min ago
TriggeredBy: ● docker.socket
       Docs: https://docs.docker.com
   Main PID: 6958 (dockerd)
      Tasks: 8
     Memory: 30.2M
        CPU: 1.276s
     CGroup: /system.slice/docker.service
             └─6958 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock

Maintenant que vous avez installé Docker, vous ne disposez pas uniquement du service Docker (démon), mais également de l’utilitaire de ligne de commande docker ou du client Docker. Nous apprendrons à utiliser la commande docker plus loin dans ce guide.

Étape 2 – Exécuter la commande Docker sans Sudo (Non Obligatoire)

Par défaut, la commande docker ne peut pas être exécutée par un autre utilisateur que l’utilisateur root ou un utilisateur du groupe docker, qui est créé par défaut lors du processus d’installation de Docker. Si vous essayez d’exécuter la commande docker sans la préfixer ou être dans le groupe docker, le résultat sera un output similaire à ce qui suit :

Got permission denied while trying to connect to the Docker daemon socket at unix:///var/run/docker.sock: Get "http://%2Fvar%2Frun%2Fdocker.sock/v1.24/containers/json": dial unix /var/run/docker.sock: connect: permission denied

Pour éviter d’avoir à taper sudo chaque fois que vous exécutez la commande docker, vous devez ajouter votre nom d’utilisateur au groupe docker:

$ sudo usermod -aG docker ${USER}

Déconnectez-vous du serveur et reconnectez-vous ou saisissez ce qui suit pour appliquer la nouvelle affiliation au groupe:

$ su - ${USER}

Pour continuer, il vous sera demandé de saisir le mot de passe de votre utilisateur:

Tapez ce qui suit pour confirmer que votre utilisateur est maintenant ajouté au groupe docker:

$ id -nG

ubuntu adm cdrom sudo dip plugdev lxd docker

Si nécessaire, vous pouvez déclarer explicitement le nom d’utilisateur de l’utilisateur que vous devez ajouter au groupe docker avec lequel vous n’êtes pas connecté, en utilisant:

$ sudo usermod -aG docker username

Le reste de ce guide est basé sur le fait que vous exécutez la commande docker en tant qu’utilisateur dans le groupe docker. Si vous préférez ne pas le faire, allez-y et ajoutez les commandes avec sudo.

Étape 3 – Utiliser la commande Docker

L’utilisation de docker signifie le passer sur une chaîne d’options et de commandes après quoi viendront des arguments. La syntaxe ressemble à ce qui suit:

$ docker [option] [command] [arguments]

$ docker -v

ubuntu@ServerB:~$ docker -v
Docker version 20.10.17, build 100c701

Pour visualiser toutes les sous-commandes disponibles, tapez:

$ docker

La liste complète de toutes les sous-commandes possibles comprend :

Commands:
  attach      Attach local standard input, output, and error streams to a running container
  build       Build an image from a Dockerfile
  commit      Create a new image from a container's changes
  cp          Copy files/folders between a container and the local filesystem
  create      Create a new container
  diff        Inspect changes to files or directories on a container's filesystem
  events      Get real time events from the server
  exec        Run a command in a running container
  export      Export a container's filesystem as a tar archive
  history     Show the history of an image
  images      List images
  import      Import the contents from a tarball to create a filesystem image
  info        Display system-wide information
  inspect     Return low-level information on Docker objects
  kill        Kill one or more running containers
  load        Load an image from a tar archive or STDIN
  login       Log in to a Docker registry
  logout      Log out from a Docker registry
  logs        Fetch the logs of a container
  pause       Pause all processes within one or more containers
  port        List port mappings or a specific mapping for the container
  ps          List containers
  pull        Pull an image or a repository from a registry
  push        Push an image or a repository to a registry
  rename      Rename a container
  restart     Restart one or more containers
  rm          Remove one or more containers
  rmi         Remove one or more images
  run         Run a command in a new container
  save        Save one or more images to a tar archive (streamed to STDOUT by default)
  search      Search the Docker Hub for images
  start       Start one or more stopped containers
  stats       Display a live stream of container(s) resource usage statistics
  stop        Stop one or more running containers
  tag         Create a tag TARGET_IMAGE that refers to SOURCE_IMAGE
  top         Display the running processes of a container
  unpause     Unpause all processes within one or more containers
  update      Update configuration of one or more containers
  version     Show the Docker version information
  wait        Block until one or more containers stop, then print their exit codes

Pour visualiser les options possibles pour une commande spécifique, tapez:

$ docker docker-subcommand --help

Pour visualiser les informations à l’échelle du système concernant Docker, tapez:

$ docker info

Dans cette prochaine étape, nous explorerons certaines de ces images.

Étape 4 : Gérer les Images Docker

Les images Docker sont utilisées pour créer des conteneurs Docker. Docker extrait ces images de Docker Hub par défaut, qui est un registre Docker géré par Docker. Il est possible pour n’importe qui d’utiliser Docker Hub pour héberger ses images, donc la grande majorité des applications et des distributions Linux dont vous aurez besoin y auront des images hébergées.

Pour vérifier si vous avez accès et pouvez télécharger les images trouvées sur Docker Hub, tapez:

$ docker run hello-world

La sortie suivante vous indiquera que Docker fonctionne correctement :

ubuntu@ServerB:~$ docker run hello-world
Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
2db29710123e: Pull complete
Digest: sha256:53f1bbee2f52c39e41682ee1d388285290c5c8a76cc92b42687eecf38e0af3f0
Status: Downloaded newer image for hello-world:latest
Hello from Docker!
This message shows that your installation appears to be working correctly.
...

Docker n’a d’abord pas été en mesure de trouver l’image hello-world localement, il a donc procédé à la télécharger à partir de Docker Hub, qui est le référentiel par défaut. Une fois l’image téléchargée, Docker a créé un conteneur à partir de celle-ci et a exécuté l’application à l’intérieur du conteneur, tout en affichant finalement le message.

Vous pouvez trouver les images disponibles sur Docker Hub à l’aide de la commande docker et de la sous-commande de recherche. Par exemple, pour trouver l’image Ubuntu, vous devez taper:

$ docker search ubuntu

Le script ira sur Docker Hub et affichera une liste de toutes les images dont le nom correspond à la requête de recherche. Dans ce cas, l’output ressemblera à ceci :

ubuntu@ServerB:~$ docker search ubuntu
NAME                             DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
ubuntu                           Ubuntu is a Debian-based Linux operating sys…   14664     [OK]
websphere-liberty                WebSphere Liberty multi-architecture images …   286       [OK]
ubuntu-upstart                   DEPRECATED, as is Upstart (find other proces…   112       [OK]
neurodebian                      NeuroDebian provides neuroscience research s…   92        [OK]
ubuntu/nginx                     Nginx, a high-performance reverse proxy & we…   55
open-liberty                     Open Liberty multi-architecture images based…   53        [OK]
ubuntu-debootstrap               DEPRECATED; use "ubuntu" instead                46        [OK]
ubuntu/apache2                   Apache, a secure & extensible open-source HT…   39
ubuntu/mysql                     MySQL open source fast, stable, multi-thread…   36
kasmweb/ubuntu-bionic-desktop    Ubuntu productivity desktop for Kasm Workspa…   31
...

Une fois que vous avez sélectionné l’image que vous allez utiliser, vous pouvez la télécharger sur votre ordinateur à l’aide de la sous-commande pull.

$ docker pull ubuntu

L’output que vous obtiendrez ressemblera à ceci :

ubuntu@ServerB:~$ docker pull ubuntu
Using default tag: latest
latest: Pulling from library/ubuntu
405f018f9d1d: Pull complete
Digest: sha256:b6b83d3c331794420340093eb706a6f152d9c1fa51b262d9bf34594887c2c7ac
Status: Downloaded newer image for ubuntu:latest
docker.io/library/ubuntu:latest

Une fois qu’une image a été téléchargée, vous pouvez exécuter un conteneur en utilisant l’image téléchargée avec la sous-commande run. Comme vous l’avez vu avec l’exemple hello-world, si une image n’a pas été téléchargée lorsque docker est exécuté avec la sous-commande run, le client Docker téléchargera d’abord l’image, puis exécutera un conteneur en l’utilisant.

Pour afficher les images téléchargées sur votre ordinateur, saisissez ce qui suit:

$ docker images

L’output ressemblera à ceci :

ubuntu@ServerB:~$ docker images
REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
ubuntu        latest    27941809078c   7 weeks ago     77.8MB
hello-world   latest    feb5d9fea6a5   10 months ago   13.3kB

Vous verrez plus tard dans ce tutoriel comment vous pouvez modifier les images que vous utilisez pour exécuter des conteneurs et les utiliser pour générer de nouvelles images qui peuvent ensuite être insérées (push est le terme technique) dans Docker Hub ou d’autres registres Docker.

Étape 5 : Exécuter un Conteneur dans Docker

Le conteneur hello-world que vous avez exécuté dans la dernière étape est un exemple de conteneur qui, après avoir émis un message de test, s’exécutera et se fermera. Les conteneurs peuvent être plus utiles que cela, ainsi qu’interactifs. Ils fonctionnent un peu comme des machines virtuelles, la seule différence est qu’elles sont plus respectueuses des ressources.

À titre d’exemple, exécutons un conteneur et utilisons l’image la plus récente d’Ubuntu. La combinaison des switch -i et -t vous donnera un accès shell interactif dans le conteneur:

$ docker run -it ubuntu

Votre invite de commande doit être reformulée pour montrer que vous travaillez maintenant à l’intérieur du conteneur et devrait ressembler à ceci :

ubuntu@ServerB:~$ docker run -it ubuntu
root@a9bb67c47592:/#

Regardez attentivement l’ID du conteneur dans l’invite de commande qui est d9b100f2f636 ici. Cet ID de conteneur est ultérieurement nécessaire pour identifier le conteneur lorsque vous souhaitez le supprimer.

Vous pouvez maintenant exécuter n’importe quelle commande à l’intérieur du conteneur. Par exemple, lors de la mise à jour de la base de données du package à l’intérieur du conteneur, vous n’aurez pas besoin de préfixer une commande avec sudo, car vous travaillez à l’intérieur du conteneur en tant qu’utilisateur root:

root@a9bb67c47592:/# apt update

Maintenant, allez-y et installez n’importe quelle application dedans, Node.js par exemple:

root@a9bb67c47592:/# apt install nodejs

Cela installera Node.js dans le conteneur trouvé dans le référentiel officiel Ubuntu. Une fois installé, vérifiez-le via:

root@a9bb67c47592:/# node -v

Le numéro de version sera affiché dans votre terminal :

v12.22.9

Toutes les modifications que vous apportez à l’intérieur du conteneur ne s’appliqueront qu’à ce conteneur.

Tapez exit dans l’invite pour quitter le conteneur.

Étape 6 – Gérer les Conteneurs dans Docker

Une fois que vous êtes sur Docker depuis un certain temps, vous remarquerez qu’il existe de nombreux conteneurs actifs (en cours d’exécution) et inactifs sur votre ordinateur. Pour visualiser les actifs, utilisez:

$ docker ps

L’output que vous obtiendrez est similaire à celui-ci :

ubuntu@ServerB:~$ docker ps
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES

Vous avez commencé deux conteneurs jusqu’à présent dans les étapes précédentes; un de l’image hello-world et le second de l’image ubuntu. Les deux ne fonctionnent plus, mais ils sont toujours sur votre système.

Pour visualiser les conteneurs actifs et inactifs, exécutez docker ps avec le switch -a:

$ docker ps -a

Vous obtiendrez un output similaire:

ubuntu@ServerB:~$ docker ps -a
CONTAINER ID   IMAGE         COMMAND    CREATED          STATUS                        PORTS     NAMES
a9bb67c47592   ubuntu        "bash"     6 minutes ago    Exited (127) 27 seconds ago             magical_shirley
ee421c96d926   hello-world   "/hello"   30 minutes ago   Exited (0) 30 minutes ago               wonderful_raman

Passez le switch -l pour visualiser le dernier conteneur que vous avez créé:

$ docker ps -l

ubuntu@ServerB:~$ docker ps -l
CONTAINER ID   IMAGE     COMMAND   CREATED          STATUS                        PORTS     NAMES
a9bb67c47592   ubuntu    "bash"    15 minutes ago   Exited (127) 10 minutes ago             magical_shirley

Utilisez docker start pour démarrer un conteneur arrêté, suivi de l’ID du conteneur ou de son nom. Commençons celui qui est basé sur Ubuntu avec l’ID de a9bb67c47592:

$ docker start a9bb67c47592

Vous pouvez utiliser docker ps pour voir l’état du conteneur une fois qu’il démarre :

ubuntu@ServerB:~$ docker ps
CONTAINER ID   IMAGE     COMMAND   CREATED          STATUS              PORTS     NAMES
a9bb67c47592   ubuntu    "bash"    23 minutes ago   Up About a minute             magical_shirley

Utilisez docker stop pour arrêter un conteneur en cours d’exécution, suivi de son ID ou de son nom. Cette fois, nous utiliserons le nom que Docker a attribué au conteneur, à savoir quizzical_mcnulty:

$ docker stop magical_shirley

Lorsque vous n’avez plus besoin d’un conteneur, vous pouvez le supprimer avec la commande docker rm, cette fois également en utilisant soit l’ID du conteneur, soit son nom. Utilisez la commande docker ps -a pour trouver le nom ou l’ID du conteneur associé à l’image hello-world et supprimez-le.

$ docker rm wonderful_raman

Vous pouvez créer un nouveau conteneur et le nommer à l’aide du switch –name. Il est également possible d’utiliser le switch –rm pour démarrer un conteneur qui se supprime lorsqu’il est arrêté. Consultez la commande docker run help pour plus d’informations sur ces options et d’autres.

Les conteneurs peuvent être transformés en images qui peuvent être utilisées pour créer de nouveaux conteneurs.

Étape 7 : Apporter des Modifications à l’intérieur d’un Conteneur à une Image sur Docker

Vous pouvez créer, modifier et supprimer des fichiers comme avec une machine virtuelle lorsque vous démarrez une image Docker. Les modifications que vous apportez s’appliqueront à ce seul conteneur. Vous pouvez le démarrer et l’arrêter, mais une fois que vous utilisez la commande docker rm pour le détruire, les modifications seront définitivement perdues.

Cette partie vous montrera comment enregistrer l’état d’un conteneur en tant que nouvelle image Docker.

Une fois que vous avez installé Node.js dans le conteneur Ubuntu, vous en avez maintenant un qui s’exécute à partir d’une image, mais le conteneur n’est pas le même que l’image que vous avez utilisée pour le créer. Mais vous voudrez peut-être utiliser ce conteneur Node.js une autre fois comme base pour de nouvelles images plus tard.

Ensuite, apportez les modifications à une nouvelle instance d’image Docker avec la commande suivante.

$ docker commit -m "What you did to the image" -a "Author Name" container_id repository/new_image_name

Le Switch -m est lié au message de validation qui vous aide, ainsi que les autres, à identifier les modifications que vous avez apportées, cependant -a est utilisé pour spécifier l’auteur.container_id est celui que vous avez vu plus haut dans ce guide lorsque vous avez lancé la session Docker interactive. référentiel est généralement votre nom d’utilisateur Docker Hub, sauf si vous avez créé de nouveaux référentiels sur Docker Hub.

Par exemple, pour l’utilisateur Ubuntu dont l’ID de conteneur est a9bb67c47592, la commande serait :

$ docker commit -m "added Node.js" -a "ubuntu" a9bb67c47592 ubuntu/ubuntu-nodejs

Une fois que vous avez validé une image, la nouvelle est enregistrée localement sur votre ordinateur. Vous apprendrez plus tard dans ce guide comment pousser une image vers un registre Docker tel que Docker Hub afin que d’autres personnes puissent y avoir accès.

Répertorier les images Docker visualisera à la fois les nouvelles et les anciennes dont elles proviennent:

$ docker images

Vous verrez l’output suivant :

ubuntu@ServerB:~$ docker images
REPOSITORY             TAG       IMAGE ID       CREATED         SIZE
ubuntu/ubuntu-nodejs   latest    45f8857f0719   9 seconds ago   197MB
...

Dans ce cas, ubuntu-nodejs est la nouvelle image qui a été extraite de l’image ubuntu existante de Docker Hub. La différence de taille reflète les modifications apportées. Et ici, le changement est que Node.js a été installé. La prochaine fois que vous devrez exécuter un conteneur avec Ubuntu avec Node.js préinstallé, vous pourrez simplement utiliser cette image.

Vous pouvez également créer des images à partir d’un Dockerfile qui vous permet d’automatiser l’installation du logiciel dans une nouvelle image. Cependant, cela n’a aucun rapport avec ce guide.

Étape 8 : Pousser une Image Docker vers un Référentiel Docker

La prochaine étape évidente après la création d’une nouvelle image à partir d’une image existante est de la partager avec quelques personnes que vous sélectionnez, le grand public sur Docker Hub ou un autre registre Docker auquel vous pouvez accéder. Pour pousser une image vers Docker Hub ou tout autre registre Docker, vous devez y avoir un compte.

Pour ce faire, vous devez d’abord vous connecter à Docker Hub.

$ docker login -u docker-registry-username

Vous serez invité à vous authentifier à l’aide de votre mot de passe Docker Hub.

Remarque: Si votre nom d’utilisateur du registre Docker diffère du nom d’utilisateur local que vous avez utilisé pour créer l’image, vous devrez identifier votre image avec votre nom d’utilisateur du registre. Dans le cas du dernier exemple, vous saisiriez:

$ docker tag ubuntu/ubuntu-nodejs docker-registry-username/ubuntu-nodejs

Ensuite, vous pourrez pousser votre propre image en utilisant:

$ docker push docker-registry-username/docker-image-name

Pour pousser l’image ubuntu-nodejs dans le référentiel Ubuntu, utilisez la commande suivante :

$ docker push ubuntu/ubuntu-nodejs

Soyez patient, car le processus prend du temps pendant le téléchargement des images, mais une fois terminé, l’output sera similaire à ceci :

The push refers to a repository [docker.io/ubuntu/ubuntu-nodejs]
e3fbbfb44187: Pushed
5f70bf18a086: Pushed
a3b5c80a4eba: Pushed
7f18b442972b: Pushed
3ce512daaf78: Pushed
7aae4540b42d: Pushed
...

S’il y a une erreur de ce type, c’est peut-être parce que vous ne vous êtes pas connecté :

The push refers to a repository [docker.io/ubuntu/ubuntu-nodejs]
e3fbbfb44187: Preparing
5f70bf18a086: Preparing
a3b5c80a4eba: Preparing
7f18b442972b: Preparing
3ce512daaf78: Preparing
7aae4540b42d: Waiting
unauthorized: authentication required

Connectez-vous avec l’identifiant Docker et redémarrez le processus de poussée. Vérifiez ensuite qu’il se trouve bien sur votre page de référentiel Docker Hub.

Il vous est maintenant possible d’utiliser docker pull ubuntu/ ubuntu-nodejs pour extraire l’image vers une nouvelle machine et l’exécuter.