Docker : configurer l’accès distant sur le port 2376

Dans ce tutoriel, nous allons voir comment configurer l’accès distant au daemon Docker en utilisant le port 2376, qui va vous permettre de gérer vos conteneurs à distance ou encore des les superviser.

Il existe deux ports pour permettre l’accès distant :

• 2375 qui n’est pas sécurisé que cela soit au niveau des flux ou encore de l’accès
• 2376 qui est sécurisé en utilisant TLS et qui utilise un jeu de certificat pour sécurisé l’accès

Dans les deux cas, il n’y a pas d’authentification par utilisation d’un compte et d’un mot de passe, seule l’utilisation du port 2376 permet de sécurisé l’accès en utilisant un jeu de certificat.

Ayant pas mal de manipulation à faire, j’ai écris deux scripts qui va permettre de réaliser les actions facilement.

La première étape va être de générer les certificats pour la connexion TLS entre le serveur Docker et le client que vous souhaitez connecter.

Dans un dossier créé un fichier openssl.cnf dont voici le contenu :

[ req ]
distinguished_name  = req_distinguished_name
req_extensions = v3_req

[ req_distinguished_name ]
# Information to be displayed for the user
commonName = Common Name (e.g. server FQDN or YOUR name)
commonName_default = docker-server

[ v3_req ]
# Extensions to add to a certificate request
subjectAltName = @alt_names

[ alt_names ]
IP.1 = 192.168.X.X # Adresse IP de l'hôte
DNS.1 = docker-server.local  # Nom d'hôte (par exemple, l'hôte Docker)

Modifier les lignes 15 et 16 pour les faire correspondre à votre serveur Docker.

Maintenant dans le même dossier que où vous avez créé le fichier openssl.cnf créer le fichier generate-certificate.sh.

#!/bin/bash

# Définir le répertoire des certificats
CERT_DIR="/etc/docker/certs"
CA_DIR="$CERT_DIR/ca"
SERVER_DIR="$CERT_DIR/server"
CLIENT_DIR="$CERT_DIR/client"

# Créer les répertoires s'ils n'existent pas
mkdir -p $CA_DIR $SERVER_DIR $CLIENT_DIR

# Vérifier si les certificats existent déjà
if [ ! -f "$CA_DIR/ca.pem" ]; then
    echo "Génération des certificats TLS..."

    # Générer la clé privée de l'autorité de certification (CA)
    openssl genrsa -aes256 -out $CA_DIR/ca-key.pem -passout pass:password 4096

    # Générer le certificat de l'autorité de certification (CA)
    openssl req -new -x509 -days 365 -key $CA_DIR/ca-key.pem -sha256 -passin pass:password \
        -subj "/CN=Docker-CA" -out $CA_DIR/ca.pem

    # Générer la clé privée du serveur
    openssl genrsa -out $SERVER_DIR/server-key.pem 4096

    # Créer une demande de signature de certificat (CSR) pour le serveur en utilisant le fichier de config avec SAN
    openssl req -new -key $SERVER_DIR/server-key.pem -out $SERVER_DIR/server.csr -config openssl.cnf

    # Signer le certificat du serveur avec l'autorité de certification
    openssl x509 -req -days 365 -sha256 -in $SERVER_DIR/server.csr -CA $CA_DIR/ca.pem \
        -CAkey $CA_DIR/ca-key.pem -passin pass:password -CAcreateserial -out $SERVER_DIR/cert.pem -extensions v3_req -extfile openssl.cnf

    # Générer la clé privée du client
    openssl genrsa -out $CLIENT_DIR/client-key.pem 4096

    # Créer une demande de signature de certificat (CSR) pour le client
    openssl req -new -key $CLIENT_DIR/client-key.pem -out $CLIENT_DIR/client.csr \
        -subj "/CN=docker-client"

    # Signer le certificat du client avec l'autorité de certification
    openssl x509 -req -days 365 -sha256 -in $CLIENT_DIR/client.csr -CA $CA_DIR/ca.pem \
        -CAkey $CA_DIR/ca-key.pem -passin pass:password -CAcreateserial -out $CLIENT_DIR/cert.pem

    # Pour uptime kuma
    cp $CLIENT_DIR/client-key.pem $CLIENT_DIR/key.pem
    cp $CA_DIR/ca.pem $CLIENT_DIR/ca.pem

    echo "Certificats générés avec succès."
else
    echo "Les certificats existent déjà. Aucune génération nécessaire."
fi

Exécuter le script : sudo bash generate-certificate.sh

Les certificats sont maintenant générés, on va passer à la configuration de daemon Docker.

Pour cela, il va falloir éditer ou créer le fichier daemon.json que doit se trouver dans le dossier /etc/docker/.

sudo nano /etc/docker/daemon.json

Dans le fichier ajouter le contenu suivant :

{
    "hosts": [
      "tcp://0.0.0.0:2376",
      "unix:///var/run/docker.sock"
    ],
    "tls": true,
    "tlscacert": "/etc/docker/certs/ca/ca.pem",
    "tlscert": "/etc/docker/certs/server/cert.pem",
    "tlskey": "/etc/docker/certs/server/server-key.pem",
    "tlsverify": true
  }

Ici on configure Docker pour écouter sur le port 2376 et on lui indique l’emplacement des certificats.

Pour finir, nous devons modifier les paramètres de démarrage du service Docker, pour cela nous allons utiliser un override.conf afin de modifier la configuration. Là aussi pour simplifier la configuration voici le script :

#!/bin/bash

# Variables
DOCKER_SERVICE_OVERRIDE_DIR="/etc/systemd/system/docker.service.d"
OVERRIDE_CONF_FILE="$DOCKER_SERVICE_OVERRIDE_DIR/override.conf"

# Création du répertoire d'override si nécessaire
if [ ! -d "$DOCKER_SERVICE_OVERRIDE_DIR" ]; then
  echo "Création du répertoire d'override systemd pour Docker..."
  sudo mkdir -p "$DOCKER_SERVICE_OVERRIDE_DIR"
fi

# Création du fichier override.conf
echo "Création du fichier d'override Docker pour exposer Docker sur le port 2376 avec TLS..."
sudo tee "$OVERRIDE_CONF_FILE" > /dev/null <<EOL
[Service]
ExecStart=
ExecStart=/usr/bin/dockerd
EOL

# Recharger la configuration systemd
echo "Rechargement de la configuration systemd..."
sudo systemctl daemon-reload

# Redémarrage du service Docker
echo "Redémarrage du service Docker..."
sudo systemctl restart docker

# Vérification du statut du service Docker
echo "Vérification du statut du service Docker..."
sudo systemctl status docker

# Fin
echo "La configuration de Docker pour utiliser TLS sur le port 2376 a été appliquée avec succès."

Exécuter le script qui va créer le fichier override.conf pour le service Docker et recharger les daemon et redémarrer Docker.

sudo bash docker-tls-override.sh

La configuration Docker est terminé.

En fonction des clients que vous allez utiliser, vous allez devoir récupérer les certificats clients dans /etc/docker/certs/client.

Vous pouvez retrouver les fichiers ici : https://git.rdr-it.com/root/docker-tls-config/