Salut,

Pour une utilisation en production, j'aurais tendance à dire :

• Utilisation des user-namespace, comme ça si dans le conteneur tu es root, sur l'hôte tu ne l'ai pas. Cela complexifie la gestion des volumes
• éviter au maximum le partage du socket docker
• Utiliser ces propres images, ou des images de confiance (linuxserver, binami, mondedie etc ...)
• Separer les reseaux des conteneurs au strict minimum, si un conteneur n'a pas besoin du net, on lui mets un réseau que local
• Utiliser iptables au lieu de docker-proxy
• Limiter les ressources de chaque conteneur

Pour moi c'est le minimum, après y'a des tweaks :

• Utilisation d'un autre runtime comme firecracker ou kata-container, voir gvisor même si c'est un ptrace degueulasse
• Utiliser docker en rootless voir podman qui est aussi daemonless

Et je dirais que c'est deja pas mal.

Je plussoie le message de xataz, et je rajouterais pour le socket, dans le cas où tu as besoin de l'utiliser, d'avoir recours à un proxy granulaire comme celui-là : https://github.com/Tecnativa/docker-socket-proxy

Pour gérer l'isolation réseau des conteneurs utiliser des networks bridge que tu définis toi-même (plutôt que d'utiliser le bridge par défaut et d'utiliser des links, dépréciés d'ailleurs). Utilise le flag --internal si tu veux isoler un réseau de l'Internet par exemple (doit y avoir quelques précisions en plus).

Pour iptables, depuis les versions récentes de Docker, utilise la chaîne DOCKER-USER, puis dedans ajoute une chaîne de filtre qui accepte le traffic prévu vers l'extérieur, puis rejette le reste.

Enfin pour les runtimes je trouve que c'est un peu compliqué encore de conseiller ça, même si le niveau d'isolation est step up encore davantage. Je joue d'ailleurs avec actuellement pour voir comment bien le gérer (a priori c'est surtout niveau réseau que ça se corse car la résolution DNS par Docker ne fonctionne pas sans la stack réseau de l'hôte - mais tu peux y parer en définissant des adresses statiques).

Je ne sais pas si j'ai bien compris mais le user-namespace et l'arg "user: PID:GID" semblent correspondre à la même chose ? Sauf qu'avec le user-namespace tu ne déclares pas à chaque fois un user ? Et ce serait juste l'utilisateur qui exécute l'image ?

Alors y a plusieurs différences.

• Le paramètre --user définit le user (UID/GID) par défaut du conteneur. Par défaut, sauf si USER est déclaré dans un Dockerfile, ça sera root.
• Le user namespace est une feature du kernel qui permet de mapper différents user pour faire en sorte, par exemple, que root dans le conteneur =/= root sur l'hôte (ce qui empêche des catastrophes en cas de compromission d'un conteneur).
• Enfin, certaines images proposent des variables d'environnement (ENV dans le Dockerfile) pour effectivement configurer un utilisateur. Ca ne garantit pas qu'il n'y a pas de root process dans le conteneur, par contre, mais c'est flexible et ça utilise la stratégie du "degrading privileges" (qui a ses défauts aussi).

En gros il faut utiliser un peu de tout ça selon ton besoin, tes images. Idéalement le namespace pour pas qu'un root escape soit dangereux pour la sécurité de l'hôte (d'ailleurs considère que n'importe quel user non-root qui a accès à Docker sans namespace sur l'hôte a tous les pouvoirs....), le paramètre user pour correspondre à tes besoins, et certaines images avec les variables qui "font tout".

Ce ne sont pas vraiment les mêmes choses mais ce sont des moyens mis en oeuvre pour plus ou moins le même but. Et c'est assez compliqué, j'en conviens...

C'est une excellente question quant à l'ICC et l'usage de --link.
Le link est effectivement déprécié : https://docs.docker.com/network/links/

Du coup pour ICC, je ne sais pas trop si c'est encore d'actualité, j'attendrais le retour de quelqu'un de plus expérimenté comme xataz. Je ferai des recherches approfondies dessus, mais il me semble que l'ICC aujourd'hui ne s'applique qu'au bridge par défaut.

L'idée c'est effectivement de gérer tes propres réseaux désormais. Par exemple imaginons tu un conteneur Postgres, il est inutile qu'il soit dans le réseau "frontend", et aussi inutile qu'il soit connecté à l'extérieur (d'où --internal). Tu pourras créer un réseau isolé dédié à l'app en question (app <-> db <-> redis par exemple).

Effectivement pour Traefik le plus commun est de créer un gros réseau dédié, c'est le plus simple. Par contre, toutes les apps de ce réseau peuvent communiquer entre "elles" donc il faut effectivement faire attention si par exemple la sécurité d'une app repose sur le proxy.

Alors il me semble (à vérifier) que Traefik doit simplement pouvoir router vers ces différents conteneurs, donc tu peux voir le sujet à l'envers et faire des réseaux uniques pour chaque lien Traefik <-> conteneur. Mais ça demande un peu plus de configuration, par contre c'est nécessaire pour vraiment bien isoler entre des conteneurs qui n'ont pas besoin de communiquer entre eux (et c'est la bonne pratique).

Pour iptables, la chaine DOCKER-USER est à configurer soi-même ou par défaut elle laisse passer le trafic de/vers l'extérieur ?

Elle est là par défaut, et oui elle laisse passer le traffic. Après pour bloquer spécifiquement l'accès d'un réseau Docker à l'extérieur, je n'ai pas utilisé iptables personnellement.

Tu utilises un daemon.json pour configurer le daemon Docker ? Si oui, tu pourrais le partager pour avoir une idée ?

Oui j'utilise daemon.json, le mien est très simple (enfin c'est relatif) et sur mon serveur perso je n'utilise pas encore le rootless. J'ai juste mis btrfs, le live restore activé, les runtimes alternatifs (gvisor, kata), etc. Rien de spécial !

{
    "data-root": "/docker",
    "debug": false,
    "live-restore": true,
    "userland-proxy": false,
    "iptables": true,
    "icc": false,
    "runtimes": {
        "runsc": {
            "path": "/usr/bin/runsc"
        },
        "kata": {
            "path": "/snap/bin/kata-containers.runtime"
        }
    },
    "storage-driver": "btrfs"
}

(Pourquoi je n'utilise pas les user namespaces : pas compatibles avec kata et gvisor, et c'est redondant avec eux. gvisor par exemple fonctionne avec son namespace séparé de l'hôte. Sinon, je conseille de l'utiliser, c'est une isolation bonne à prendre avec runc.)