Docker: základy práce a tvorba 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 nasazování a zvyšuje spolehlivost. V tomto článku 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 i typické postupy CI/CD a řešení problémů.

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

• Image: neměnný artefakt popsaný vrstvami. Obsahuje runtime, knihovny a aplikaci. Verzuje se 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). Pracuje se s ním pomocí příkazů docker pull a docker push.
• Docker daemon a klient: dockerd provádí operace, CLI (docker) posí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, může dojít k jejich 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 (kvůli předvídatelnosti se vyhněte implicitnímu tagu latest).
• Seznam a podrobnosti: 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 image používá běžící kontejner).

Spouštění kontejnerů: porty, prostředí, běh na pozadí 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

• Spuštění/zastavení: 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í, nikoli pro trvalé změny).
• Odstranění kontejneru: docker rm web (zastavený kontejner) 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í instrukcí a minimalizace změn výrazně zrychlují sestavení a zmenšují 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
• Sestavení: docker build -t mysite:1.0.0 .
• Spuštění: docker run -d -p 8080:80 mysite:1.0.0

Vícefázové sestavení: malé a bezpečnější image

Oddělením fází kompilace od výsledného runtime zmenšíte image a zabráníte tomu, aby se buildovací nástroje dostaly 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: trvalé uchovávání dat a sdílení mezi hostitelem a kontejnerem

• Pojmenovaný volume (vhodnější pro produkci): 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 práci se soubory v reálném čase.
• Kontrola a správa: docker volume ls, docker volume inspect, docker volume rm.

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

• Síť typu bridge (výchozí): docker network create appnet, poté spouštějte kontejnery s parametrem --network appnet.
• Názvy DNS: kontejnery ve stejné síti lze oslovovat názvy služeb/kontejnerů.
• Mapování portů: -p host:container, například -p 8080:80, pro zpřístupnění 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 jediný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 řízené ukončení

• Healthcheck v image: HEALTHCHECK CMD curl -f http://localhost/health || exit 1.
• Zpracování signálů: aplikace by měla zachytit SIGTERM a korektně ukončit běh (uzavřít spojení, vyprázdnit buffer).
• Doba čekání před zastavením: --stop-timeout při použití docker run nebo stop_grace_period v Compose.

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

• Minimalistický základ: upřednostňujte distroless nebo vhodně zvolené Alpine; v rámci vícefázového sestavení odstraňte buildovací nástroje.
• Nespouštějte jako root: USER 10001:10001 nebo USER node; nastavte oprávnění k souborům.
• Omezení oprávnění: spouštějte s menší sadou Linux capabilities (např. --cap-drop=ALL --cap-add=NET_BIND_SERVICE podle potřeby).
• Tajné údaje: nikdy je nezabudovávejte do image; používejte proměnné prostředí, připojené soubory nebo externí trezory.
• Skenování zranitelností: pravidelně analyzujte image (např. pomocí Trivy/Grype) a aktualizujte základní image.

Optimalizace výkonu a velikosti image

• Dockerfile optimalizovaný pro cache: kopírujte manifesty závislostí (např. package.json) před samotným kódem.
• Úklid po instalaci: instalujte a následně čistěte cache v jedné vrstvě, aby se cache neuchovala ve výsledném image.
• Sestavení pro více architektur: docker buildx build --platform linux/amd64,linux/arm64 pro univerzální distribuci.
• Limity zdrojů: při běhu nastavte limity CPU a paměti (--cpus, -m) pro lepší předvídatelnost.

Propojení s CI/CD: sestavení, testování, podpis, odeslání a nasazení

• Sestavení a testování: pipeline vytvoří image a spustí integrační testy v dočasných kontejnerech.
• Podpis a SBOM: generujte SBOM (SPDX/CycloneDX) a podepisujte image (cosign); artefakty ukládejte pro účely auditu.
• Odeslání do registry: používejte verzování semverem i jednoznačným digestem (SHA) a přidávejte sémantické tagy (např. prod-YYYYMMDD).
• Nasazení: v menších projektech použijte Docker Compose, ve větších prostředích orchestrátor (Kubernetes).

Ladění a řešení problémů: systematický postup

• Logy: docker logs -f <container> jsou první stopou; aplikaci nastavte tak, aby zapisovala do STDOUT/STDERR.
• Kontrola: pomocí docker inspect ověřte mounty, sítě, proměnné prostředí a healthcheck.
• Interaktivní shell: docker exec -it <container> sh umožní ověřit dostupnost portů, DNS (getent hosts) a oprávnění.
• Sítě a porty: docker network ls, docker network inspect; ujistěte se, že služba naslouchá na správné adrese 0.0.0.0:PORT.
• Čistý start: zastavte a odstraňte osiřelé kontejnery; docker compose down -v (pozor: smaže volumes definované v Compose).

Časté chyby a jak se jim vyhnout

• Použití latest: způsobuje nedeterministická sestavení; vždy používejte konkrétní tagy.
• Root v produkci: je nebezpečný a zbytečný; přepněte na neprivilegovaného uživatele.
• Proměnlivé kontejnery: neprovádějte žádné ad hoc změny uvnitř běžícího kontejneru; změna znamená nové sestavení image.
• Monolit v jednom kontejneru: dodržujte princip „1 proces = 1 kontejner“. Více procesů orchestrujte.
• Tajné údaje v image: nikdy neukládejte klíče do verzovacího systému; používejte secrets/trezory a promyšlené mounty.

Kontrolní seznam pro připravenost k produkčnímu nasazení

• Image je malé, neměnné, podepsané a má vygenerovaný SBOM.
• Kontejner běží pod uživatelem, který není root, má omezené capabilities a tam, kde je to možné, používá souborový systém pouze pro čtení.
• Je definován HEALTHCHECK, signály jsou správně zpracovávány a ukončení probíhá řízeně.
• Logy se zapisují do STDOUT/STDERR, metriky a trasy jsou dostupné přes endpointy.
• Manifesty Compose/Kubernetes jsou verzované v Git; sestavení a nasazení probíhají přes CI/CD.
• Základní image se pravidelně aktualizují, zranitelnosti se skenují a tajné údaje se obměňují.

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

Osvojení 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í práce s Dockerem. S těmito základy dokážete vytvářet spolehlivá sestavení, rychle iterovat při vývoji a bezpečně nasazovat aplikace od notebooku až po produkční clustery.