Docker zmenil zpusob, jakym staviame, dodavame a spoustime software. Misto "na mem pocitaci to funguje" Docker zarucuje, ze vase aplikace bezi vsude stejne - na vasem notebooku, na pocitaci kolegy, v CI/CD a v produkci. V tomto pruvodci pujdeme od nuly az k nasazeni realne aplikace.

Co je Docker?

Docker je platforma, ktera balickuje vasi aplikaci a vsechny jeji zavislosti do standardizovane jednotky zvane kontejner. Kontejner je izolovan, lehky proces, ktery sdili jadro operacniho systemu hostitele, ale ma vlastni souborovy system, sit a prostor procesu.

Kontejnery vs Virtualni stroje

Aspekt	Kontejnery	Virtualni stroje
Spusteni	Sekundy	Minuty
Velikost	MB	GB
OS	Sdili jadro hostitele	Uplny hostujici OS
Izolace	Uroven procesu	Uroven hardwaru
Vykon	Temer nativni	Rezie hypervisoru
Hustota	Stovky na hostitele	Desitky na hostitele

Instalace Dockeru

# macOS
brew install --cask docker

# Ubuntu/Debian
curl -fsSL https://get.docker.com | sh
sudo usermod -aG docker $USER

# Verify installation
docker --version
docker run hello-world

Zakladni koncepty

Obrazy

Obraz je sablona pouze pro cteni s instrukcemi pro vytvoreni kontejneru. Predstavte si ho jako snimek vasi aplikace a jejiho prostredi.

# Pull an image from Docker Hub
docker pull node:20-alpine

# List local images
docker images

# Remove an image
docker rmi node:20-alpine

Kontejnery

Kontejner je bezici instance obrazu. Muzete vytvorit, spustit, zastavit a smazat kontejnery.

# Run a container
docker run -d --name my-app -p 3000:3000 node:20-alpine

# List running containers
docker ps

# List all containers (including stopped)
docker ps -a

# Stop a container
docker stop my-app

# Remove a container
docker rm my-app

# View logs
docker logs my-app

# Execute a command inside a running container
docker exec -it my-app sh

Psani Dockerfile

Dockerfile je textovy soubor s instrukcemi pro sestaveni obrazu. Kazda instrukce vytvori vrstvu.

Zakladni Dockerfile pro Node.js aplikaci

# Use an official Node.js runtime as base image
FROM node:20-alpine

# Set working directory
WORKDIR /app

# Copy package files first (better caching)
COPY package.json package-lock.json ./

# Install dependencies
RUN npm ci --only=production

# Copy application code
COPY . .

# Expose the port the app runs on
EXPOSE 3000

# Command to run the application
CMD ["node", "server.js"]

Sestaveni a spusteni

# Build the image
docker build -t my-node-app .

# Run the container
docker run -d -p 3000:3000 my-node-app

# Visit http://localhost:3000

Vicefazove sestaveni

Vicefazove sestaveni udrzuji vase produkcni obrazy male oddelenim prostredi pro sestaveni od prostredi pro beh.

# Stage 1: Build
FROM node:20-alpine AS builder
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci
COPY . .
RUN npm run build

# Stage 2: Production
FROM node:20-alpine AS runner
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
COPY --from=builder /app/package.json ./
EXPOSE 3000
CMD ["node", "dist/server.js"]

Toto vytvori obraz pouze s kompilovanym vystupem a produkcnimi zavislostmi - bez zdrojoveho kodu, bez vyvojovych zavislosti, bez nastroju pro sestaveni.

Priklad vicefazoveho sestaveni pro Next.js

FROM node:20-alpine AS deps
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci

FROM node:20-alpine AS builder
WORKDIR /app
COPY --from=deps /app/node_modules ./node_modules
COPY . .
RUN npm run build

FROM node:20-alpine AS runner
WORKDIR /app
ENV NODE_ENV=production
COPY --from=builder /app/public ./public
COPY --from=builder /app/.next/standalone ./
COPY --from=builder /app/.next/static ./.next/static
EXPOSE 3000
CMD ["node", "server.js"]

Svazky: Trvala data

Ve vychozim nastaveni jsou data uvnitr kontejneru ztracena pri jeho odstraneni. Svazky tento problem resi.

# Create a named volume
docker volume create my-data

# Run with a volume
docker run -d -v my-data:/app/data my-app

# Bind mount (map host directory to container)
docker run -d -v $(pwd)/data:/app/data my-app

# List volumes
docker volume ls

Sitove pripojeni

Docker vytvari izolovane site pro komunikaci kontejneru.

# Create a custom network
docker network create my-network

# Run containers on the same network
docker run -d --name api --network my-network my-api
docker run -d --name db --network my-network postgres:16

# Containers can reach each other by name
# From "api" container: postgres://db:5432

Docker Compose

Docker Compose vam umoznuje definovat a spoustet vicekontejerove aplikace s jednim YAML souborem.

docker-compose.yml

services:
  api:
    build: ./api
    ports:
      - "3000:3000"
    environment:
      - DATABASE_URL=postgres://user:pass@db:5432/mydb
    depends_on:
      - db

  db:
    image: postgres:16-alpine
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=pass
      - POSTGRES_DB=mydb
    volumes:
      - pgdata:/var/lib/postgresql/data
    ports:
      - "5432:5432"

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"

volumes:
  pgdata:

Prikazy

# Start all services
docker compose up -d

# View logs
docker compose logs -f

# Stop all services
docker compose down

# Rebuild and restart
docker compose up -d --build

# Scale a service
docker compose up -d --scale api=3

.dockerignore

Stejne jako .gitignore tento soubor zabranuje kopirovani nepotrebnych souboru do obrazu.

node_modules
.git
.env
*.md
.next
dist
coverage

Osvedcene postupy pro produkci

1. Pouzivejte male zakladni obrazy

# Bad: 1GB+
FROM node:20

# Good: ~180MB
FROM node:20-alpine

2. Nespoustejte jako Root

FROM node:20-alpine
RUN addgroup -S app && adduser -S app -G app
USER app
WORKDIR /home/app
COPY --chown=app:app . .

3. Pouzivejte specificke tagy obrazu

# Bad: can change unexpectedly
FROM node:latest

# Good: pinned version
FROM node:20.11-alpine3.19

4. Vyuzijte cache sestaveni

Seradte instrukce Dockerfile od nejmene po nejvice casto menenych:

FROM node:20-alpine
WORKDIR /app

# These change rarely - cached
COPY package.json package-lock.json ./
RUN npm ci --only=production

# This changes often - not cached
COPY . .

5. Kontroly zdravi

HEALTHCHECK --interval=30s --timeout=3s --retries=3 \
  CMD wget -qO- http://localhost:3000/health || exit 1

6. Pouzivejte promenne prostredi

ENV NODE_ENV=production
ENV PORT=3000

Tahak beznych prikazu Dockeru

# Images
docker build -t name:tag .        # Build image
docker images                      # List images
docker rmi image_name              # Remove image
docker image prune                 # Remove unused images

# Containers
docker run -d -p 3000:3000 image   # Run detached
docker ps                          # List running
docker stop container_name         # Stop
docker rm container_name           # Remove
docker logs -f container_name      # Follow logs
docker exec -it container sh       # Shell into container

# Compose
docker compose up -d               # Start services
docker compose down                # Stop services
docker compose logs -f             # Follow all logs
docker compose ps                  # List services

# Cleanup
docker system prune -a             # Remove everything unused

Od Dockeru ke Kubernetes

Docker spravuje jednotlive kontejnery. Kdyz potrebujete orchestrovat stovky kontejneru na vice serverech, potrebujete Kubernetes. Docker a Kubernetes se doplnuji:

1. Docker: stavi a spousti kontejnery
2. Kubernetes: orchestruje kontejnery ve velkem meritku (planovani, skalovani, samooprava)

Pokud vas zajima dalsi krok, podivejte se na muj clanek o Uvodu do Kubernetes.

Zaver

Docker je zakladni dovednost pro moderni vyvojare. Eliminuje nesrovnalosti prostredi, zjednodusuje nasazeni a je zakladem pro orchestraci kontejneru s Kubernetes. Zacnete s jednoduchym Dockerfile, prejdete na Docker Compose pro vicesluzbove aplikace a prijmete vicefazove sestaveni a osvedcene postupy zabezpeceni jak budete rust.

Nejlepsi zpusob, jak se naucit Docker, je kontejnerizovat projekt, na kterem uz pracujete. Zacnete dnes.