Docker · 13 min read · Oct 05, 2025

Comment configurer un registre Docker privé sur Ubuntu 22.04

Si vous travaillez pour une organisation et souhaitez garder vos images Docker en interne pour un déploiement rapide, alors héberger un dépôt Docker privé est parfait. Avoir un registre Docker privé vous permet de posséder votre pipeline de distribution d’images et d’avoir un contrôle plus strict sur le stockage et la distribution des images. Vous pouvez intégrer votre registre avec votre système CI/CD, améliorant ainsi votre flux de travail.

Ce tutoriel vous apprendra à configurer et à utiliser un registre Docker privé sur un serveur Ubuntu 22.04 en utilisant Amazon S3 comme emplacement de stockage.

Prérequis

  • Deux serveurs Linux avec Ubuntu 22.04. Un serveur agira comme hôte du registre, tandis que l’autre sera utilisé comme client pour envoyer des requêtes et recevoir des images de l’hôte.
  • Un nom de domaine enregistré pointant vers le serveur hôte. Nous utiliserons registry.example.com pour notre tutoriel.
  • Un utilisateur non-root avec des privilèges sudo sur les deux machines.
  • Assurez-vous que tout est à jour. 
    $ sudo apt update
$ sudo apt upgrade
  • Quelques paquets dont votre système a besoin. 
    $ sudo apt install wget curl nano software-properties-common dirmngr apt-transport-https gnupg2 ca-certificates lsb-release ubuntu-keyring unzip -y
    Certains de ces paquets peuvent déjà être installés sur votre système.

É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
Command may disrupt existing ssh connections. Proceed with operation (y|n)? y
Firewall is active and enabled on system startup

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 Docker et Docker Compose

Cette étape est requise sur les serveurs et les machines clientes.

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 Thu 2023-04-13 09:37:09 UTC; 3min 47s ago
TriggeredBy: ? docker.socket
       Docs: https://docs.docker.com
   Main PID: 2106 (dockerd)
      Tasks: 7
     Memory: 26.0M
        CPU: 267ms
     CGroup: /system.slice/docker.service
             ??2106 /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 3 - Configurer le registre Docker

Créer des répertoires d’utilisateur

Créez un répertoire pour la configuration du registre.

$ mkdir ~/docker-registry

Passez au répertoire docker-registry.

$ cd ~/docker-registry

Créez un répertoire pour stocker le mot de passe d’authentification HTTP, les fichiers de configuration Nginx et les certificats SSL.

$ mkdir auth

Créez un autre répertoire pour stocker les journaux Nginx.

$ mkdir logs

Créer un bucket Amazon S3

Vous pouvez stocker les données du registre et les images sur votre serveur ou utiliser un service d’hébergement cloud. Pour notre tutoriel, nous utiliserons le service cloud Amazon S3.

L’étape suivante consiste à configurer le fichier de configuration avec quelques paramètres importants. Ces paramètres peuvent également être définis dans le fichier docker-compose.yml, mais avoir un fichier séparé est bien mieux.

Créez un bucket avec les paramètres suivants.

  • L’ACL doit être désactivée.
  • L’accès public au bucket doit être désactivé.
  • La version du bucket doit être désactivée.
  • Activez le chiffrement du bucket en utilisant les clés gérées par Amazon S3. (SSE-S3)
  • Le verrouillage des objets doit être désactivé.

Créez un utilisateur IAM avec la politique suivante.

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "s3:ListBucket",
        "s3:GetBucketLocation",
        "s3:ListBucketMultipartUploads"
      ],
      "Resource": "arn:aws:s3:::S3_BUCKET_NAME"
    },
    {
      "Effect": "Allow",
      "Action": [
        "s3:PutObject",
        "s3:GetObject",
        "s3:DeleteObject",
        "s3:ListMultipartUploadParts",
        "s3:AbortMultipartUpload"
      ],
      "Resource": "arn:aws:s3:::S3_BUCKET_NAME/*"
    }
  ]
}

Remplacez S3_BUCKET_NAME par le nom de votre bucket S3.

Notez la clé secrète, la valeur secrète et la région du bucket à utiliser plus tard.

Créer un fichier Docker Compose

Créez le fichier docker-compose.yml et ouvrez-le pour l’édition.

$ nano docker-compose.yml

Collez le code suivant dedans.

services:
  registry:
    image: registry:2
    restart: always
    environment:
      - REGISTRY_STORAGE=s3
      - REGISTRY_STORAGE_S3_REGION=us-west-2
      - REGISTRY_STORAGE_S3_BUCKET=hf-docker-registry
      - REGISTRY_STORAGE_S3_ENCRYPT=true
      - REGISTRY_STORAGE_S3_CHUNKSIZE=5242880
      - REGISTRY_STORAGE_S3_SECURE=true
      - REGISTRY_STORAGE_S3_ACCESSKEY=AKIA3FIG4NVFNXKQXMSJ
      - REGISTRY_STORAGE_S3_SECRETKEY=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
      - REGISTRY_STORAGE_S3_V4AUTH=true
      - REGISTRY_STORAGE_S3_ROOTDIRECTORY=/image-registry
      - REGISTRY_STORAGE_CACHE_BLOBDESCRIPTOR=inmemory
      - REGISTRY_HEALTH_STORAGEDRIVER_ENABLED=false
  nginx:
    image: "nginx:alpine"
    ports:
      - 443:443
    links:
      - registry:registry
    volumes:
      - ./auth:/etc/nginx/conf.d
      - ./auth/nginx.conf:/etc/nginx/nginx.conf:ro
      - ./logs:/var/log/nginx
      - /etc/letsencrypt:/etc/letsencrypt

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

Passons en revue ce que nous avons configuré dans notre fichier compose.

  1. La première étape consiste à récupérer la dernière image de la version 2 du registre Docker depuis le hub. Nous n’utilisons pas le tag latest car cela peut causer des problèmes en cas de mise à niveau majeure. Le définir sur 2 vous permet de récupérer toutes les mises à jour 2.x tout en évitant d’être automatiquement mis à niveau vers la prochaine version majeure, ce qui peut introduire des changements incompatibles.
  2. Le conteneur de registre est configuré pour redémarrer toujours en cas de défaillance ou d’arrêt inattendu.
  3. Nous avons défini diverses variables d’environnement pour le stockage Amazon S3. Passons rapidement en revue.
    • REGISTRY_STORAGE définit le type de stockage. Nous avons sélectionné s3 puisque nous utilisons Amazon S3.
    • REGISTRY_STORAGE_S3_REGION définit la région de votre bucket S3.
    • REGISTRY_STORAGE_S3_BUCKET définit le nom de votre bucket S3.
    • REGISTRY_STORAGE_S3_ENCRYPT - définissez-le sur true si vous avez activé le chiffrement du bucket.
    • REGISTRY_STORAGE_S3_CHUNKSIZE définit la taille des morceaux de téléchargement. Elle doit être supérieure à 5 Mo (5 1024 1024).
    • REGISTRY_STORAGE_S3_SECURE - définissez-le sur true si vous allez utiliser HTTPS.
    • REGISTRY_STORAGE_S3_ACCESSKEY et REGISTRY_STORAGE_S3_SECRETKEY - Identifiants utilisateur que vous avez récupérés après avoir créé votre utilisateur IAM.
    • REGISTRY_STORAGE_S3_V4AUTH - définissez-le sur true si vous utilisez la version 4 de l’authentification AWS. Si vous obtenez des erreurs liées à la connexion S3, définissez-le sur false.
    • REGISTRY_STORAGE_S3_ROOTDIRECTORY - définit le répertoire racine dans votre bucket sous lequel vos données de registre seront stockées.
    • REGISTRY_STORAGE_CACHE_BLOBDESCRIPTOR - définit l’emplacement du cache. Dans notre cas, nous le stockons en mémoire. Vous pouvez également le définir pour utiliser Redis.
    • REGISTRY_HEALTH_STORAGEDRIVER_ENABLED - définissez-le sur false pour désactiver le service de vérification de la santé du stockage du registre. Il y a un bug avec le registre qui peut causer des problèmes si vous ne le définissez pas sur false.
  4. Le registre Docker communique via le port 5000, qui est ce que nous avons exposé sur notre serveur au docker.
  5. ./auth:/etc/nginx/conf.d assure que tous les paramètres de Nginx sont disponibles dans le conteneur.
  6. ./auth/nginx.conf:/etc/nginx/nginx.conf:ro mappe le fichier de paramètres Nginx du système à celui du conteneur en mode lecture seule.
  7. ./logs:/var/log/nginx permet d’accéder aux journaux de Nginx sur le système en les mappant au répertoire des journaux de Nginx dans le conteneur.
  8. Les paramètres du registre Docker sont stockés dans le fichier /etc/docker/registry/config.yml dans le conteneur, et nous l’avons mappé au fichier config.yml dans le répertoire actuel, que nous créerons à l’étape suivante.

Configurer l’authentification

Pour configurer l’authentification HTTP, vous devez installer le paquet httpd-tools.

$ sudo apt install apache2-utils -y

Créez le fichier de mot de passe dans le répertoire ~/docker-registry/auth.

$ htpasswd -Bc ~/docker-registry/auth/nginx.htpasswd user1
New password:
Re-type new password:
Adding password for user user1

Le drapeau -c indique à la commande de créer un nouveau fichier, et le drapeau -B est pour utiliser l’algorithme bcrypt pris en charge par Docker. Remplacez user1 par un nom d’utilisateur de votre choix.

Si vous souhaitez ajouter d’autres utilisateurs, exécutez la commande à nouveau, mais sans le drapeau -c.

$ htpasswd -B ~/docker-registry/auth/registry.password user2

Maintenant, le fichier sera mappé au conteneur de registre pour l’authentification.

Étape 4 - Installer SSL

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 récupérer 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.

$ 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 peut être exécutée 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 registry.example.com

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

Générez un certificat de groupe Diffie-Hellman.

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

Vérifiez le service de planification de renouvellement de Certbot.

$ sudo systemctl list-timers

Vous trouverez snap.certbot.renew.service comme l’un des services programmés pour s’exécuter.

NEXT                        LEFT          LAST                        PASSED        UNIT                      ACTIVATES
.....
Sun 2023-04-14 00:00:00 UTC 19min left    Sat 2023-02-25 18:04:05 UTC n/a          snap.certbot.renew.timer  snap.certbot.renew.service
Sun 2023-04-14 00:00:20 UTC 19min left    Sat 2023-02-25 10:49:23 UTC 14h ago      apt-daily-upgrade.timer   apt-daily-upgrade.service
Sun 2023-04-14 00:44:06 UTC 3h 22min left Sat 2023-02-25 20:58:06 UTC 7h ago       apt-daily.timer           apt-daily.service

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

$ sudo certbot renew --dry-run

Si vous ne voyez aucune erreur, vous êtes prêt. Votre certificat se renouvellera automatiquement.

Copier le fichier Dhparam dans le conteneur

Copiez le certificat de groupe Diffie-Hellman dans le répertoire ~/docker-registry/auth, qui sera mappé au conteneur.

$ sudo cp /etc/ssl/certs/dhparam.pem ~/docker-registry/auth

Étape 5 - Configurer Nginx

L’étape suivante consiste à configurer le serveur Nginx comme proxy frontal pour le serveur de registre Docker. Le registre Docker est livré avec un serveur intégré fonctionnant sur le port 5000. Nous allons le placer derrière Nginx.

Créez et ouvrez le fichier ~/docker-registry/auth/nginx.conf pour l’édition.

$ sudo nano ~/docker-registry/auth/nginx.conf

Collez le code suivant dedans.

events {
    worker_connections  1024;
}

http {

  upstream docker-registry {
    server registry:5000;
  }

  ## Définir une variable pour nous aider à décider si nous devons ajouter le
  ## en-tête 'Docker-Distribution-Api-Version'.
  ## Le registre définit toujours cet en-tête.
  ## Dans le cas où nginx effectue l'authentification, l'en-tête est non défini
  ## puisque nginx authentifie avant de faire le proxy.
  map $upstream_http_docker_distribution_api_version $docker_distribution_api_version {
    '' 'registry/2.0';
  }

  server {
    listen 443 ssl http2;
    server_name registry.example.com;

    # SSL
    ssl_certificate /etc/letsencrypt/live/registry.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/registry.example.com/privkey.pem;
    ssl_trusted_certificate /etc/letsencrypt/live/registry.example.com/chain.pem;

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

    # Recommandations de https://raymii.org/s/tutorials/Strong_SSL_Security_On_nginx.html
    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 on;
    ssl_ecdh_curve X25519:prime256v1:secp384r1:secp521r1;
    ssl_session_cache shared:SSL:10m;
    ssl_dhparam /etc/nginx/conf.d/dhparam.pem;
    resolver 8.8.8.8;

    # désactiver toutes les limites pour éviter HTTP 413 pour les téléchargements d'images volumineuses
    client_max_body_size 0;

    # requis pour éviter HTTP 411 : voir le problème #1486 (https://github.com/moby/moby/issues/1486)
    chunked_transfer_encoding on;

    location /v2/ {
      # Ne pas autoriser les connexions de docker 1.5 et antérieur
      # docker pré-1.6.0 n'a pas correctement défini l'agent utilisateur sur ping, attrapez les agents utilisateurs "Go *"
      if ($http_user_agent ~ "^(docker\/1\.(3|4|5(?!\.[0-9]-dev))|Go ).*$" ) {
        return 404;
      }

      # Pour ajouter une authentification de base à v2, utilisez le paramètre auth_basic.
      auth_basic "Registry realm";
      auth_basic_user_file /etc/nginx/conf.d/nginx.htpasswd;

      ## Si $docker_distribution_api_version est vide, l'en-tête n'est pas ajouté.
      ## Voir la directive map ci-dessus où cette variable est définie.
      add_header 'Docker-Distribution-Api-Version' $docker_distribution_api_version always;

      proxy_pass                          http://docker-registry;
      proxy_set_header  Host              $http_host;   # requis pour le client docker
      proxy_set_header  X-Real-IP         $remote_addr; # passer l'IP réelle du client
      proxy_set_header  X-Forwarded-For   $proxy_add_x_forwarded_for;
      proxy_set_header  X-Forwarded-Proto $scheme;
      proxy_read_timeout                  900;
    }
  }
}

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

Étape 6 - Lancer le registre Docker

Passez au répertoire du registre Docker.

$ cd ~/docker-registry

Lancez le conteneur docker.

$ docker compose up -d

Vérifiez l’état des conteneurs.

$ docker ps
CONTAINER ID   IMAGE          COMMAND                  CREATED              STATUS              PORTS                                      NAMES
3328b7e36bb2   nginx:alpine   "/docker-entrypoint.…"   About a minute ago   Up 3 seconds        80/tcp, 0.0.0.0:443->443/tcp, :::443->443/tcp   docker-registry-nginx-1
bf7cdfc0e013   registry:2     "/entrypoint.sh /etc…"   About a minute ago   Up About a minute   5000/tcp                                 docker-registry-registry-1

Connectez-vous au registre Docker.

$ docker login -u=user1 -p=password https://registry.example.com

Vous obtiendrez la sortie suivante.

WARNING! Using --password via the CLI is insecure. Use --password-stdin.
WARNING! Your password will be stored unencrypted in /home/username/.docker/config.json.
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store

Login Succeeded

Vous pouvez également ouvrir l’URL https://registry.example.com/v2/ dans votre navigateur, et il vous demandera un nom d’utilisateur et un mot de passe. Vous devriez voir une page vide avec {} dessus.

Vous pouvez vérifier l’URL dans le terminal en utilisant curl.

$ curl -u user1 -X GET https://registry.example.com/v2/
Enter host password for user 'user1':
{}

Téléchargez la dernière image Docker d’Ubuntu.

$ docker pull ubuntu:latest

Taguez cette image pour le registre privé.

$ docker tag ubuntu:latest registry.example.com/ubuntu2204

Poussez l’image vers le registre.

$ docker push registry.example.com/ubuntu2204

Testez si le push a réussi.

$ curl -u user1 -X GET https://registry.example.com/v2/_catalog
Enter host password for user 'user1':
{"repositories":["ubuntu2204"]}

Entrez votre mot de passe d’authentification Nginx lorsque vous y êtes invité, et vous verrez la liste des dépôts disponibles via le registre.

Déconnectez-vous en utilisant le terminal pour effacer les identifiants.

$ docker logout https://registry.example.com
Removing login credentials for registry.example.com

Vérifiez la liste des images Docker actuellement disponibles à l’utilisation.

$ docker images
REPOSITORY                            TAG       IMAGE ID       CREATED       SIZE
registry                             2         8db46f9d7550   2 weeks ago   24.2MB
nginx                                alpine    8e75cbc5b25c   2 weeks ago   41MB
ubuntu                               latest    08d22c0ceb15   5 weeks ago   77.8MB
registry.example.com/ubuntu2204      latest    08d22c0ceb15   5 weeks ago   77.8MB

Étape 7 - Accéder et utiliser le registre Docker depuis la machine cliente

Connectez-vous à votre serveur client. À l’étape 1, nous avons installé Docker sur la machine cliente.

Connectez-vous au registre Docker privé depuis la machine cliente.

$ docker login -u=user1 -p=password https://registry.example.com

Tirez l’image Ubuntu depuis le registre.

$ docker pull registry.example.com/ubuntu2204

Listez toutes les images sur votre machine cliente.

$ docker images
REPOSITORY                        TAG        IMAGE ID       CREATED         SIZE
registry.example.com/ubuntu2204   latest     08d22c0ceb15   5 weeks ago   77.8MB

Créez et lancez un conteneur en utilisant l’image téléchargée.

$ docker run -it registry.example.com/ubuntu2204 /bin/bash

Vous serez connecté au Shell à l’intérieur du conteneur Ubuntu.

root@647899f255db:

Exécutez la commande suivante pour vérifier la version de Linux.

root@a2da49fdbea9$ cat /etc/os-release
PRETTY_NAME="Ubuntu 22.04.2 LTS"
NAME="Ubuntu"
VERSION_ID="22.04"
VERSION="22.04.2 LTS (Jammy Jellyfish)"
VERSION_CODENAME=jammy
ID=ubuntu
ID_LIKE=debian
HOME_URL="https://www.ubuntu.com/"
SUPPORT_URL="https://help.ubuntu.com/"
BUG_REPORT_URL="https://bugs.launchpad.net/ubuntu/"
PRIVACY_POLICY_URL="https://www.ubuntu.com/legal/terms-and-policies/privacy-policy"
UBUNTU_CODENAME=jammy

Maintenant, vous pouvez commencer à utiliser votre registre Docker depuis vos machines clientes.

Conclusion

Cela conclut notre tutoriel sur la configuration d’un registre Docker privé sur un serveur Ubuntu 22.04 qui utilise Amazon S3 comme stockage. Si vous avez des questions, postez-les dans les commentaires ci-dessous.

Share: X/Twitter LinkedIn
#Docker

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

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