Bezpečný Docker na Ubuntu Serveru

Celé nastavení v kostce

1. Ověřená instalace - Docker z oficiálního zdroje, pravost balíčků ověřená podpisovým klíčem
2. Přístup jen pro správce - Docker ovládá jen sudo, skupina docker zůstane prázdná
3. Bezpečné výchozí nastavení - logy nezaplní disk, porty kontejnerů se otevírají jen pro server samotný
4. Firewall i pro kontejnery - omylem otevřený port zůstane zvenku zavřený
5. Kontejnery s minimem práv - bez práv správce, bez možnosti měnit vlastní soubory, s omezeným výkonem a pamětí

Co potřebujete vyřešit?

Kontejner vs. virtuální stroj

Kontejner tedy neodděluje aplikaci od serveru tak pevně jako virtuální stroj. Jeho izolace je dobrá, ale jen když je správně nastavená. O tom je zbytek návodu.

Pojmy, které budete potřebovat

Kdy Docker na serveru dává smysl

1. Docker běží s právy správce (roota). Kdo mu může zadávat příkazy, převezme celý server: stačí spustit kontejner, který vidí všechny soubory serveru.
2. Přístup k Dockeru = práva správce. Skupina docker proto dává plná práva bez hesla. Socket docker.sock nesmí do kontejnerů ani na síť.
3. Docker obchází firewall. Spojení na publikovaný port přesměruje do kontejneru dřív, než ho UFW zkontroluje. A port ve výchozím stavu otevře na všech adresách serveru, tedy i do internetu.
4. Kontejnery sdílí jádro serveru. Výchozí omezení jsou rozumná, ale volby jako privileged nebo network_mode: host je ruší.

• Ubuntu Server 22.04, 24.04 nebo 26.04 LTS (64bit).
• Uživatel <ADMIN_USER> s právem sudo (správa uživatelů) a přihlášení SSH klíčem.
• Zapnutý firewall UFW (průvodce Ubuntu Serverem). Ideálně SSH dostupné jen přes Tailscale nebo z lokální sítě.
• Automatické bezpečnostní aktualizace (unattended-upgrades). Kontejnery sdílí jádro serveru, jeho aktuálnost je proto zásadní.

Běžný, nebo rootless režim?

Instalace (kapitola 04) je pro oba režimy stejná. Kapitoly 05–08 popisují běžný režim, rootless navazuje v kapitole 09.

Hodnoty, které nahradíte svými

# anyone in the docker group gets a root shell on the host with this one line:
docker run --rm -it -v /:/host alpine chroot /host

Obejde tím heslo, 2FA i záznam v logu, které vyžaduje sudo. Útočníkovi stačí ukradený SSH klíč. Docker proto spouštějte přes sudo docker. Kdo chce Docker bez sudo, má použít rootless režim.

Skupina docker musí zůstat prázdná

getent group docker      # → docker:x:<GID>:   (nobody after the last colon)

# if someone is there, remove them:
sudo gpasswd -d <USER> docker

docker.sock do kontejneru nepatří

Některé nástroje (Portainer, Traefik, Watchtower, různé dashboardy) chtějí do svého kontejneru připojit docker.sock. Kdo pak ovládne takový kontejner, ovládne celý server. Pokud nástroj opravdu potřebujete, dejte mezi něj a socket prostředníka (socket proxy), který povolí jen čtení.

sudo tee /etc/docker/daemon.json >/dev/null <<'EOF'
{
  "log-driver": "local",
  "log-opts": {
    "max-size": "10m",
    "max-file": "5"
  },
  "live-restore": true,
  "no-new-privileges": true,
  "icc": false,
  "ip": "127.0.0.1",
  "default-network-opts": {
    "bridge": {
      "com.docker.network.bridge.host_binding_ipv4": "127.0.0.1"
    }
  },
  "default-address-pools": [
    { "base": "172.30.0.0/16", "size": 24 }
  ]
}
EOF
sudo chmod 0644 /etc/docker/daemon.json

sudo dockerd --validate --config-file=/etc/docker/daemon.json     # → configuration OK
sudo systemctl restart docker

sudo docker info --format '{{.LoggingDriver}} live-restore={{.LiveRestoreEnabled}}'
sudo docker info | grep -A5 'Security Options'     # apparmor, seccomp (builtin), cgroupns

# daemon defaults apply only to newly created containers and networks
cd /opt/stacks/<PROJECT>
sudo docker compose down && sudo docker compose up -d     # volumes are kept

Pokročilá volba "userns-remap": "default" zařídí, že správce v kontejneru není správcem na serveru. Komplikuje ale práva k souborům a vylučuje některé volby. Stejnou ochranu dá jednodušeji rootless režim.

Kam publikovat porty

Ke službě na 127.0.0.1 se vzdáleně dostanete přes SSH tunel. Port se tak nikam neotevírá a funguje to i s Tailscale, který povoluje jen SSH:

# on your PC: forward local port 8080 to 127.0.0.1:8080 on the server
ssh -N -L 8080:127.0.0.1:8080 -p <SSH_PORT> <ADMIN_USER>@<SERVER>
# then open http://127.0.0.1:8080 in the browser on your PC

Nepoužívejte network_mode: host (každý port kontejneru je pak port serveru) ani "iptables": false (rozbije síť kontejnerů a zpřístupní je z lokální sítě).

Firewall i pro kontejnery: řetězec DOCKER-USER

Pravidla v řetězci DOCKER-USER platí pro spojení do kontejnerů a Docker je nikdy nepřepíše. Pravidla níže zahodí každé spojení zvenku do kontejneru kromě portů, které výslovně povolíte. Kontejnery se přitom ven připojit mohou (aktualizace, API). Uložíme je do /etc/ufw/after.rules, takže je UFW načte při každém startu.

ip -4 route show default          # → default via … dev <EXT_IF> …
sudo cp -a /etc/ufw/after.rules /etc/ufw/after.rules.bak

# safety net: in 10 minutes restore the original file and empty DOCKER-USER
sudo systemd-run --unit=rollback-docker-user --on-active=10min \
  /bin/sh -c 'cp -a /etc/ufw/after.rules.bak /etc/ufw/after.rules; iptables -F DOCKER-USER; ufw reload'

# BEGIN DOCKER-USER
*filter
:DOCKER-USER - [0:0]
# replies to existing connections (including those a container opened to the outside)
-A DOCKER-USER -m conntrack --ctstate RELATED,ESTABLISHED -j RETURN
# explicitly allowed public ports (original destination port, before DNAT)
-A DOCKER-USER -i <EXT_IF> -p tcp -m conntrack --ctorigdstport 80 --ctdir ORIGINAL -j RETURN
-A DOCKER-USER -i <EXT_IF> -p tcp -m conntrack --ctorigdstport 443 --ctdir ORIGINAL -j RETURN
# optional: your whole LAN may reach published ports
# -A DOCKER-USER -i <EXT_IF> -s <LAN_SUBNET> -j RETURN
# drop everything else coming from the external interface into containers
-A DOCKER-USER -i <EXT_IF> -j DROP
COMMIT
# END DOCKER-USER

sudo ufw reload
sudo ufw status verbose            # must say "Status: active", no errors
sudo iptables -S DOCKER-USER
sudo iptables -S FORWARD | head -5 # the first rules jump to DOCKER-USER

sudo systemctl stop rollback-docker-user.timer
systemctl list-timers rollback-docker-user.timer   # → 0 timers listed

sudo install -d -m 0750 -o root -g root /opt/stacks/<PROJECT>
cd /opt/stacks/<PROJECT>

Příklad: zabezpečený kontejner

Webový server (nginx) s omezeními, která se hodí pro většinu kontejnerů. Komentáře vysvětlují jednotlivé řádky:

services:
  web:
    # fixed version + digest: the image never changes without you knowing
    image: nginxinc/nginx-unprivileged:1.29-alpine@sha256:<DIGEST>
    user: "101:101"               # do not run as root inside the container
    read_only: true               # root filesystem is read-only
    tmpfs:
      - /tmp                      # writable only where the app needs it
    cap_drop:
      - ALL                       # no Linux capabilities
    security_opt:
      - no-new-privileges:true    # also in daemon.json; keep it visible here
    ports:
      - "127.0.0.1:8080:8080"     # server only / SSH tunnel
    mem_limit: 256m
    cpus: 0.50
    pids_limit: 200
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "wget", "-q", "--spider", "http://127.0.0.1:8080/"]
      interval: 30s
      timeout: 5s
      retries: 3
    networks:
      - frontend

networks:
  frontend: {}

Digest pro řádek image: zjistíte prvním příkazem. Druhý blok nastavení zkontroluje a kontejner spustí:

# the "Digest:" line is the value for @sha256:…
sudo docker buildx imagetools inspect nginxinc/nginx-unprivileged:1.29-alpine

sudo docker compose config      # prints the resolved file and reports errors
sudo docker compose up -d
sudo docker compose ps
sudo docker compose logs --tail=50

Pravidla pro každý kontejner

Hesla

Compose předá heslo kontejneru jako soubor /run/secrets/<jméno>. Většina oficiálních image ho umí načíst přes proměnnou s koncovkou _FILE:

# password file readable by root only, never typed into the shell history
sudo install -d -m 0700 /opt/stacks/<PROJECT>/secrets
openssl rand -base64 32 | sudo tee /opt/stacks/<PROJECT>/secrets/db_password >/dev/null
sudo chmod 0600 /opt/stacks/<PROJECT>/secrets/db_password

services:
  db:
    image: postgres:18-alpine@sha256:<DIGEST>
    environment:
      POSTGRES_PASSWORD_FILE: /run/secrets/db_password
    secrets:
      - db_password
    volumes:
      - db-data:/var/lib/postgresql
    networks:
      - backend

networks:
  backend:
    internal: true      # no internet access, no published ports

volumes:
  db-data: {}

secrets:
  db_password:
    file: ./secrets/db_password

Soubor s heslem musí umět přečíst uživatel, pod kterým běží aplikace v kontejneru. Když ho nepřečte, změňte vlastníka souboru na tohoto uživatele; práva pro všechny nenastavujte.

sudo apt install uidmap dbus-user-session docker-ce-rootless-extras systemd-container

# stop the system-wide (rootful) daemon - rootless does not need it
sudo systemctl disable --now docker.service docker.socket
sudo rm -f /var/run/docker.sock

# a dedicated user for containers: no password, no sudo
sudo adduser --disabled-password --gecos "" <DOCKER_USER>
grep '^<DOCKER_USER>:' /etc/subuid /etc/subgid     # at least 65536 IDs each

# start the user's daemon at boot, even when nobody is logged in
sudo loginctl enable-linger <DOCKER_USER>

# a full systemd session for the user (sudo -iu / su - do not create one)
sudo machinectl shell <DOCKER_USER>@

# --- now as <DOCKER_USER> ---
dockerd-rootless-setuptool.sh install
systemctl --user enable docker
docker context use rootless
docker info | grep -Ei 'context|rootless|cgroup'

sudo install -d -m 0755 /etc/systemd/system/user@.service.d
sudo tee /etc/systemd/system/user@.service.d/delegate.conf >/dev/null <<'EOF'
[Service]
Delegate=cpu cpuset io memory pids
EOF
sudo systemctl daemon-reload
# takes effect once the user's systemd instance restarts (simplest: reboot)

Porty a firewall

V rootless režimu platí firewall UFW i pro kontejnery a řetězec DOCKER-USER není potřeba. Port, který má být dostupný zvenku, proto povolte v UFW (sudo ufw allow 443/tcp). Porty pod 1024 (např. 80 a 443) obyčejný uživatel otevřít nesmí; povolte to jen programu rootlesskit:

# allow ports below 1024 only for rootlesskit, not for every user
sudo setcap cap_net_bind_service=ep "$(command -v rootlesskit)"

# as <DOCKER_USER>:
systemctl --user restart docker

Po každé aktualizaci balíčku docker-ce-rootless-extras příkaz zopakujte, aktualizace oprávnění smaže.

Další omezení

• Kontejner ve výchozím stavu nevidí skutečnou IP návštěvníka (vadí např. u logů webu). Řešení popisuje dokumentace.
• Volba privileged nedává plná práva a ping v kontejneru nemusí fungovat.
• Data jsou v ~/.local/share/docker uživatele, ne v /var/lib/docker. Myslete na to u záloh.

Docker – varianta A: automaticky

Přidá Docker do automatických aktualizací. Kontejnery díky live-restore aktualizaci přežijí bez restartu.

sudo tee /etc/apt/apt.conf.d/52unattended-upgrades-docker >/dev/null <<'EOF'
Unattended-Upgrade::Origins-Pattern {
        "site=download.docker.com";
};
EOF

# dry run: Docker packages must show up as allowed
sudo unattended-upgrade --dry-run --debug 2>&1 | grep -iE 'docker|containerd'

Docker – varianta B: ručně

Pro server, kde restarty plánujete sami. Sledujte přehled vydání a bezpečnostní oznámení. Aktualizujte pravidelně (např. jednou měsíčně) a hned po bezpečnostní opravě.

sudo apt update
apt list --upgradable 2>/dev/null | grep -E 'docker|containerd'
sudo apt install --only-upgrade docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Images aplikací

1. Sledujte nové verze aplikace a bezpečnostní oznámení výrobce.
2. V compose.yaml přepište verzi a digest.
3. Stáhněte novou image, nasaďte ji, zkontrolujte stav a smažte staré images:

cd /opt/stacks/<PROJECT>
# after changing tag + digest in compose.yaml:
sudo docker compose pull
sudo docker compose up -d
sudo docker compose ps
sudo docker image prune

Nástroje, které kontejnery aktualizují automaticky, potřebují přístup k docker.sock a nasadí cokoli nového bez kontroly. Na server nepatří. Známé zranitelnosti v images odhalí skener (Trivy, Docker Scout).

# 1) nobody in the docker group, no API on the network
getent group docker
sudo ss -tlnp | grep -E ':2375|:2376'          # → nothing

# 2) daemon security options
sudo docker info | grep -A5 'Security Options'
sudo docker info --format '{{.LoggingDriver}} live-restore={{.LiveRestoreEnabled}}'

# 3) where ports are published (0.0.0.0 / [::] only for ports meant to be public)
sudo docker ps --format 'table {{.Names}}\t{{.Ports}}'
sudo ss -tlnp | grep -E 'docker-proxy|rootlesskit'

# 4) firewall safety net
sudo iptables -S DOCKER-USER

# 5) settings of every running container
sudo docker inspect --format '{{.Name}} user={{.Config.User}} ro={{.HostConfig.ReadonlyRootfs}} priv={{.HostConfig.Privileged}} caps={{.HostConfig.CapDrop}} sec={{.HostConfig.SecurityOpt}}' $(sudo docker ps -q)

Test zvenku

Z počítače mimo vaši síť (jiný server, telefon na mobilních datech) zjistěte, které porty jsou otevřené. Otevřené (open) smí být jen ty, které jste povolili, typicky 80 a 443 u webu:

# from a machine OUTSIDE your network
nmap -Pn -p 80,443,2375,2376,5432,6379,8080,<SSH_PORT> <PUBLIC_IP>

Firewall pro kontejnery vyzkoušíte kontejnerem, který schválně otevře port do internetu. Zvenku musí být port filtered (zablokovaný):

# on the server: publish a test port on all addresses on purpose
sudo docker run --rm -d --name test-leak -p 0.0.0.0:8081:8080 nginxinc/nginx-unprivileged:alpine

# from outside: port 8081 must be "filtered", not "open"
nmap -Pn -p 8081 <PUBLIC_IP>

# on the server: clean up
sudo docker stop test-leak

Podrobný kontrolní seznam nabízí CIS Docker Benchmark. Na malém serveru není nutné splnit vše.

sudo apt purge docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin docker-ce-rootless-extras
sudo rm -rf /var/lib/docker /var/lib/containerd
sudo rm -f /etc/apt/sources.list.d/docker.sources /etc/apt/keyrings/docker.asc
sudo rm -f /etc/apt/apt.conf.d/52unattended-upgrades-docker
sudo rm -rf /etc/docker
sudo apt update

Z /etc/ufw/after.rules smažte blok BEGIN DOCKER-USER … END DOCKER-USER a spusťte sudo ufw reload. Rootless režim odinstalujte ještě před apt purge:

# as <DOCKER_USER>, before apt purge:
dockerd-rootless-setuptool.sh uninstall
rootlesskit rm -rf ~/.local/share/docker

# as <ADMIN_USER>:
sudo loginctl disable-linger <DOCKER_USER>

Návod vychází z oficiální dokumentace Dockeru (ověřeno k 27. 10. 2026):

• Install Docker Engine on UbuntuPodporované verze, repozitář, instalační skript a firewall.
• Linux post-installation stepsSkupina docker a její práva, rotace logů.
• Docker Engine securityRizika démona, dílčí práva, user namespaces.
• Protect the Docker daemon socketVzdálený přístup jen přes SSH nebo TLS.
• Packet filtering and firewallsDocker a UFW.
• Docker with iptablesŘetězec DOCKER-USER.
• Port publishing and mappingPublikování portů a výchozí adresa.
• dockerd referenceVšechna nastavení daemon.json.
• Rootless modeInstalace rootless režimu.
• Rootless – tips and troubleshootingAppArmor, nízké porty, limity, odinstalace.
• Compose file referenceVšechny volby compose.yaml.
• OWASP Docker Security Cheat SheetPřehled bezpečnostních doporučení.

Související

• Průvodce Ubuntu ServeremInstalace, SSH, firewall a základní zabezpečení.
• Tailscale na Ubuntu ServeruSSH jen přes soukromou síť.
• SSH klíčePřihlášení klíčem místo hesla.
• Unattended upgrades (anglicky)Automatické bezpečnostní aktualizace.

Jak citovat tuto publikaci (ČSN ISO 690:2022)NEPOR, Vladimír. Docker na Ubuntu Serveru: bezpečná instalace a nastavení. Online. Vrealmatic, 2026. Aktualizováno 27. 10. 2026. Dostupné z: https://vrealmatic.com/ubuntu-server/docker-instalace. [citováno RRRR-MM-DD].

Sdílet