Docker: Configurare l’accesso remoto sulla porta 2376

In questo tutorial vedremo come configurare l’accesso remoto al daemonDockerutilizzando la porta 2376, che vi consentirà di gestire i vostri container da remoto o di monitorarli.

Esistono due porte che consentono l’accesso remoto:

• la 2375, che non è sicura né a livello di traffico né di accesso
• 2376, che è protetta tramite TLS e utilizza un set di certificati per garantire la sicurezza dell’accesso

In entrambi i casi non è prevista l’autenticazione tramite account e password; solo l’utilizzo della porta 2376 consente di proteggere l’accesso tramite un set di certificati.

Dato che ci sono diverse operazioni da eseguire, ho scritto due script che consentiranno di eseguire le azioni facilmente.

Il primo passo consiste nel generare i certificati per la connessione TLS tra il serverDockere il client che si desidera connettere.

In una cartella, create un fileopenssl.cnfcon il seguente contenuto:

[ 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)

DockerModificate le righe 15 e 16 in modo che corrispondano al vostro server.

generate-certificate.shOra, nella stessa cartella in cui avete creato il fileopenssl.cnf, create il file.

#!/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

Eseguite lo script: sudo bash generate-certificate.sh

DockerI certificati sono ora generati; passiamo alla configurazione del daemon.

A tal fine, sarà necessario modificare o creare il filedaemon.json che deve trovarsi nella cartella /etc/docker/.

sudo nano /etc/docker/daemon.json

Nel file, aggiungere il seguente contenuto:

{
    "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
  }

Qui si configuraDocker per l’ascolto sulla porta 2376 e gli si indica la posizione dei certificati.

DockerInfine, dobbiamo modificare i parametri di avvio del servizio; a tal fine utilizzeremo unoverride.conf per modificare la configurazione. Anche in questo caso, per semplificare la configurazione, ecco lo 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."

DockerEseguire lo script che creerà il fileoverride.conf per il servizioDocker e ricaricherà il daemon, quindi riavviare il sistema.

sudo bash docker-tls-override.sh

La configurazioneDockerè terminata.

A seconda dei client che utilizzerete, dovrete recuperare i certificati client da /etc/docker/certs/client.

Potete trovare i file qui: https://forge.rdr-it.com/Scripts/Linux/src/branch/main/docker-tls-config