Základy Dockeru

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 troubleshooting.

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

• Image: neměnný artefakt popsaný vrstvami. Obsahuje runtime, knihovny a aplikaci. Verzuje se tagy (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í 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 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 pro determinismus).
• Seznam a detaily: docker images a docker inspect <image> pro 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í, 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 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í), docker ps -a (všechny).
• Vstup do shellu: docker exec -it web bash nebo sh (pro ladění, nikoli pro perzistentní změny).
• Odstranění kontejneru: docker rm web (zastavený) nebo docker rm -f web (násilně).

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 buildy a zmenšuje 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 nepřenášíte 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 hostem 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.
• Signal handling: aplikace by měla zachytit SIGTERM a korektně ukončit běh (uzavřít spojení, flushnout 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.
• Nespouštějte jako root: USER 10001:10001 nebo USER node; nastavte práva k souborům.
• Omezení schopností: spouštějte s menší 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.

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), ukládejte artefakty pro audit.
• Push do registry: verzujte semverem 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 pro 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), práva.
• Sítě a porty: docker network ls, docker network inspect; ujistěte se, že služba naslouchá na správném 0.0.0.0:PORT.
• Čistý start: zastavte a odstraňte sirotky; docker compose down -v (pozor: smaže volume definovaná v Compose).

Časté chyby a jak se jim vyhnout

• Využití latest: způsobuje nondeterministické buildy; vždy používejte konkrétní tagy.
• Root v produkci: nebezpečné a zbytečné; přepněte na neprivilegovaného uživatele.
• Mutable kontejnery: žádné ad-hoc změny uvnitř běžícího kontejneru; změna = nový build image.
• Monolit v jednom kontejneru: držte princip „1 proces = 1 kontejner“. Více procesů orchestruujte.
• Tajné údaje v image: nikdy necommitujte klíče; používejte secrets/trezory a promyšlené mounty.

Checklist pro produkční připravenost

• Image je malý, imutabilní, podepsaný a s generovaným 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 Git, buildy a deploye přes CI/CD.
• Pravidelné aktualizace base image, sken zranitelností a rotace tajemství.

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í praxe s Dockerem. S těmito základy dokážete stavět spolehlivé buildy, rychle iterovat ve vývoji a bezpečně nasazovat aplikace od notebooku po produkční clustery.