Docker: Základy práce a tvorby obrazů

Proč se naučit základy práce s Dockerem

Docker zjednodušuje balení aplikací a jejich závislostí do přenosných obrazů (image), které se spouštějí jako izolované kontejnery. Tím minimalizuje rozdíly mezi vývojem a produkcí, zrychluje nasazení a zvyšuje spolehlivost. V tomto článku si projdeme praktické základy: klíčové pojmy, práci s image, psaní Dockerfile, práci s volume a sítěmi, orchestraci pomocí Compose, bezpečnost, typické postupy CI/CD a troubleshooting.

Základní pojmy: image, kontejner, registry, daemon, klient

Image: neměnný artefakt popsaný vrstvami. Obsahuje runtime, knihovny a aplikaci. Verzováno pomocí tagů (např. 1.4.2, 2025-10-12, sha256:...).
Kontejner: běžící instance image s vlastním procesem, izolovanými jmennými prostory a řízenými zdroji (cgroups).
Registry: vzdálené úložiště image (Docker Hub, GHCR, ECR, GCR). Práce probíhá pomocí příkazů docker pull a docker push.
Docker daemon a klient: dockerd provádí operace, CLI (docker) zasílá požadavky přes API.

Instalace, kontrola a první spuštění

Ověření verze: docker --version, docker info.
Testovací běh: stažení a spuštění hello-world: docker run --rm hello-world.
Čištění prostředí: docker system df zobrazí využití; docker system prune odstraní nepotřebné objekty (pozor na smazání).

Práce s image: získání, prohlížení, tagování a mazání

Stažení: docker pull nginx:1.27 stáhne konkrétní tag (vyhněte se implicitnímu latest kvůli determinismu).
Seznam a detaily: docker images a docker inspect <image> zobrazí metadata a vrstvy.
Přejmenování (tagování): docker tag nginx:1.27 registry.example.com/web/nginx:prod-2025-11-05.
Smazání: docker rmi <image-id|name:tag> (nelze, pokud je image používána běžícím kontejnerem).

Spouštění kontejnerů: porty, prostředí, odpojování a logy

Základní běh v popředí: docker run --name web -p 8080:80 nginx:1.27.
Běh na pozadí: docker run -d --name web -p 8080:80 nginx:1.27. Logy zobrazíte příkazem docker logs -f web.
Proměnné prostředí: docker run -d -e NODE_ENV=production app:1.0.0.
Automatický restart: --restart=unless-stopped pro vyšší dostupnost.

Životní cyklus kontejneru a základní operace

Start/stop: docker stop web, docker start web.
Seznam a stav: docker ps (běžící kontejnery), docker ps -a (všechny).
Vstup do shellu: docker exec -it web bash nebo sh (pro ladění, nikoliv pro perzistentní změny).
Odstranění kontejneru: docker rm web (zastavený) nebo docker rm -f web (násilné odstranění).

Dockerfile: principy, vrstvy a cache

Dockerfile definuje postup sestavení image. Každá instrukce tvoří vrstvu a využívá cache, pokud se nezměnil její vstup. Správné pořadí a minimalizace změn výrazně zrychluje build a snižuje velikost image.

Základní instrukce: FROM, WORKDIR, COPY, RUN, ENV, EXPOSE, USER, ENTRYPOINT, CMD.
Příklad minimalistického webu:
FROM nginx:1.27-alpine
WORKDIR /usr/share/nginx/html
COPY ./public/ .
HEALTHCHECK --interval=30s --timeout=3s CMD wget -qO- http://localhost/ || exit 1
EXPOSE 80
Build: docker build -t mysite:1.0.0 .
Spuštění: docker run -d -p 8080:80 mysite:1.0.0

Multi-stage build: malé a bezpečnější image

Oddělením fází kompilace od výsledného runtime snížíte velikost image a neprenesete build nástroje do produkce.

Schéma:
FROM node:22-alpine AS build
WORKDIR /app
COPY package.json pnpm-lock.yaml ./
RUN corepack enable && pnpm i --frozen-lockfile
COPY . .
RUN pnpm build
FROM node:22-alpine AS runtime
WORKDIR /app
COPY --from=build /app/dist ./dist
USER node
CMD ["node","dist/server.js"]

Volumes: perzistence dat a sdílení mezi hostitelem a kontejnerem

Named volume (produkčnější): docker volume create dbdata, docker run -v dbdata:/var/lib/postgresql/data postgres:17.
Bind mount (vývoj): docker run -v $(pwd):/app -w /app node:22 pro živou práci se soubory.
Inspekce a správa: docker volume ls, docker volume inspect, docker volume rm.

Sítě: izolace, porty a komunikace mezi kontejnery

Bridge síť (výchozí): docker network create appnet, poté spouštějte kontejnery s --network appnet.
DNS jména: kontejnery se v rámci stejné sítě oslovují názvy služeb/kontejnerů.
Mapování portů: -p host:container, např. -p 8080:80 pro dostupnost z hostitele.

Docker Compose: deklarativní definice více služeb

Compose umožňuje popsat aplikaci a její služby v souboru compose.yaml a spouštět je jedním příkazem.

Příklad:
services:
  web:
    image: nginx:1.27
    ports: ["8080:80"]
    volumes: ["./public:/usr/share/nginx/html:ro"]
  db:
    image: postgres:17
    environment:
      - POSTGRES_PASSWORD=secret
    volumes: ["dbdata:/var/lib/postgresql/data"]
volumes:
  dbdata:
Spuštění a správa: docker compose up -d, docker compose ps, docker compose logs -f web, docker compose down.

Healthcheck, signály a graceful shutdown

Healthcheck v image: HEALTHCHECK CMD curl -f http://localhost/health || exit 1.
Zachytávání signálů: aplikace by měla zachytit SIGTERM a korektně ukončit běh (uzavřít spojení, flushovat buffer).
Stop grace period: --stop-timeout při docker run nebo v Compose stop_grace_period.

Zabezpečení: minimální image, uživatel, capabilities a tajemství

Minimalistický základ: preferujte distroless nebo promyšlené Alpine; odstraňte build nástroje v multi-stage buildu.
Nespouštějte jako root: USER 10001:10001 nebo USER node; nastavte správná přístupová práva k souborům.
Omezení schopností: spouštějte kontejner s omezenou sadou Linux capabilities (např. --cap-drop=ALL --cap-add=NET_BIND_SERVICE dle potřeby).
Secrets: nikdy je nepečte do image; používejte proměnné prostředí, montované soubory nebo externí trezory.
Skenování zranitelností: pravidelně provádějte analýzu image (např. Trivy, Grype) a aktualizujte base image.

Optimalizace výkonu a velikosti image

Cache-friendly Dockerfile: kopírujte manifesty závislostí (např. package.json) před samotným kódem.
Čištění po instalaci: v jedné vrstvě instalujte a poté čistěte cache, aby se nezachovala ve výsledném image.
Multi-arch buildy: docker buildx build --platform linux/amd64,linux/arm64 pro univerzální distribuci.
Limity zdrojů: při běhu definujte CPU/mem kvóty (--cpus, -m) pro lepší predikovatelnost výkonu.

Propojení s CI/CD: build, test, podpis, push a nasazení

Build a test: pipeline vyrobí image, spustí integrační testy v dočasných kontejnerech.
Podpis a SBOM: generujte SBOM (SPDX, CycloneDX) a podepisujte image (cosign), uchovávejte artefakty pro audit.
Push do registry: verzujte pomocí semver i nezaměnitelným digestem (SHA) a přidávejte semantické tagy (např. prod-YYYYMMDD).
Nasazení: v menších projektech Docker Compose, ve větších prostředích orchestrátor (Kubernetes).

Debugging a troubleshooting: systematický postup

Logy: docker logs -f <container> jsou první stopa; přesměrujte STDOUT/STDERR v aplikaci.
Inspekce: docker inspect slouží k ověření mountů, sítí, proměnných prostředí a healthchecku.
Interaktivní shell: docker exec -it <container> sh ověří dostupnost portů, DNS (getent hosts), přístupová práva.
Sítě a porty: pomocí docker network ls, docker network inspect zkontrolujte sítě; ujistěte se, že služba naslouchá na správném 0.0.0.0:PORT.
Čistý start: zastavte a odstraňte nepoužívané kontejnery; docker compose down -v (pozor, smaže volume definovaná v Compose).

Časté chyby a jak se jim vyhnout

Využití latest tagu: způsobuje nedeterministické buildy; vždy používejte konkrétní tagy.
Root uživatel v produkci: nebezpečné a zbytečné; používejte neprivilegované uživatele.
Mutable kontejnery: vyhněte se ad-hoc změnám uvnitř běžícího kontejneru; každá změna znamená nový build image.
Monolit v jednom kontejneru: dodržujte princip „jeden proces = jeden kontejner“. Více procesů orchestruujte zvlášť.
Tajné údaje v image: nikdy nekomitujte klíče; používejte secrets, trezory a promyšlené mounty.

Checklist pro produkční připravenost

Image je malý, imutabilní, podepsaný a obsahuje generovaný SBOM.
Běh pod ne-root uživatelem, omezené capabilities, read-only filesystem tam, kde je to možné.
Definovaný HEALTHCHECK, korektní zachycení signálů a graceful shutdown.
Logy na STDOUT/STDERR, metriky a trasy dostupné přes endpointy.
Compose/Kubernetes manifesty verzované v Gitu, buildy a deploye přes CI/CD.
Pravidelné aktualizace base image, skenování zranitelností a rotace tajemství.

Závěr: pevné základy pro kontejnerový workflow

Osvojení postupů práce s image, kontejnery, sítěmi a volume, psaní efektivního Dockerfile, používání Compose i základních bezpečnostních principů tvoří jádro každodenní praxe s Dockerem. S těmito základy dokážete