Docker és Kubernetes a mindennapokban – Teljes kezdő útmutató

"De a gépen működött!" – Ismerős? A konténerizáció ezt a problémát oldja meg egyszer s mindenkorra. A Docker és a Kubernetes napjaink legfontosabb DevOps eszközei. Ebben a cikkben nem elméleti szintű magyarázatot kapsz, hanem használható, másolható parancsokat és konfig fájlokat, amelyekkel azonnal produktívvá válhatsz.

Miért van szükség konténerekre?

Képzeld el: megírod a webalkalmazásod Node.js-ben, használsz egy bizonyos verziójú könyvtárat, Redis-t cache-nek, és PostgreSQL adatbázist. A fejlesztői gépeden minden tökéletesen fut. Aztán felteszed a szerverre, és… semmi. Mert a szerveren más a Node verzió, nincs telepítve a Redis, más a környezeti változó.

A Docker ezt úgy oldja meg, hogy minden függőséget egy konténerbe csomagol, ami bárhol ugyanúgy fut. A Kubernetes pedig ezeket a konténereket kezeli, skálázza, és ha egy leáll, újraindítja.

1. Docker – Az alapok

Telepítsd a Docker-t a hivatalos oldalról (macOS, Windows, Linux egyaránt).

Első konténer indítása

# Hello World
docker run hello-world

# Indíts egy Ubuntu konténert interaktív módban
docker run -it ubuntu bash

# Indíts egy Nginx webszervert a 8080-as porton
docker run -d -p 8080:80 nginx

A docker ps megmutatja a futó konténereket, docker stop <container_id> leállítja.

Dockerfile – a konténer receptje

Hozz létre egy Dockerfile fájlt egy Node.js alkalmazáshoz:

# Alapkép (hivatalos Node 20-alpine, ami nagyon kicsi)
FROM node:20-alpine

# Munkakönyvtár beállítása
WORKDIR /app

# Csak a package.json fájlokat másoljuk először (a cache miatt)
COPY package*.json ./

# Függőségek telepítése (production only)
RUN npm ci --only=production

# Forráskód másolása
COPY . .



# A port, amit az alkalmazás használ
EXPOSE 3000

# Az indításkor futtatandó parancs
CMD ["node", "server.js"]

Buildeld és futtasd:

docker build -t my-node-app .
docker run -p 3000:3000 my-node-app

Használd a .dockerignore fájlt, hogy ne másolódjanak be a felesleges dolgok (node_modules, .git, stb.).

2. Docker Compose – több konténer együtt

Egy modern alkalmazás ritkán egyetlen konténerből áll. Legyen egy Node.js backend, egy PostgreSQL adatbázis, és egy Redis cache. Így néz ki a docker-compose.yml:

version: '3.8'

services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - DATABASE_URL=postgresql://user:pass@db:5432/myapp
      - REDIS_URL=redis://redis:6379
    depends_on:
      - db
      - redis
    volumes:
      - ./uploads:/app/uploads

db:
    image: postgres:15-alpine
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=pass
      - POSTGRES_DB=myapp
    volumes:
      - postgres_data:/var/lib/postgresql/data
    ports:
      - "5432:5432"

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

volumes:
  postgres_data:

Indítás:

docker-compose up -d   # háttérben
docker-compose logs -f  # logok követése
docker-compose down     # leállítás

Ez a setup fejlesztésre is tökéletes – a kód megváltoztatásakor újra kell buildelni a app szolgáltatást, de az adatbázis adatai megmaradnak a volume-nak köszönhetően.

3. Kubernetes – a konténer orkesztrátor

Ha már több konténered van, és azokat több szerveren akarod futtatni, automatizálni a skálázást, a frissítéseket, akkor jön a Kubernetes (röviden K8s).

Először is telepítsd a kubectl parancssori eszközt, és ha lokálisan tanulnál, használd a Minikube-ot vagy a Docker Desktop beépített Kubernetes funkcióját.

Alapfogalmak

Pod – egy vagy több konténer együtt, a legkisebb egység.
Deployment – pod-ok sablonja, kezeli a replikák számát, a frissítéseket.
Service – stabil hálózati címet ad a pod-oknak (mert a pod-ok jönnek-mennek).
ConfigMap / Secret – konfigurációs adatok és jelszavak tárolása.
Ingress – külső forgalom irányítása a service-ekhez (pl. domain alapján).

Első Deployment

Készíts egy deployment.yaml fájlt:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: app
        image: my-node-app:latest
        ports:
        - containerPort: 3000
        env:
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: db-secret
              key: url
        resources:
          requests:
            memory: "128Mi"
            cpu: "100m"
          limits:
            memory: "256Mi"
            cpu: "500m"

Service hozzáadása:

apiVersion: v1
kind: Service
metadata:
  name: my-app-service
spec:
  selector:
    app: my-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 3000
  type: LoadBalancer   # Ha felhőben vagy, kap egy külső IP-t

Telepítsd:

kubectl apply -f deployment.yaml
kubectl apply -f service.yaml
kubectl get pods
kubectl get services

Ha Minikube-ot használsz, futtasd: minikube service my-app-service – megnyitja a böngészőben.

Skálázás és frissítés

# Skálázás 5 replikára
kubectl scale deployment my-app --replicas=5

# Frissítés új image-re (rolling update)
kubectl set image deployment/my-app app=my-node-app:v2

# Állapot figyelése
kubectl rollout status deployment/my-app

# Visszaállítás
kubectl rollout undo deployment/my-app

Gyakorlati tippek és trükkök

Használj multi-stage build-eket a Dockerben, hogy a production image kicsi legyen (pl. builder stage + node:alpine).
Ne futtasd root-ként a konténereket – adj meg USER node a Dockerfile-ban.
Health check-ek – Kubernetesben állíts be livenessProbe és readinessProbe értékeket, hogy a K8s tudja, mikor indítsa újra a pod-ot.
Használd a kubectl port-forward parancsot fejlesztéshez: kubectl port-forward pod/my-app-pod 3000:3000.
Tanulj Helm-et – a Kubernetes csomagkezelője, amivel sablonosíthatod a konfigokat.

Ha most kezded, ne ijedj meg a sok új fogalomtól. Kezdd a Dockerrel, építs pár egyszerű konténert, próbáld ki a Docker Compose-t, és csak utána ugorj a Kubernetes-be. Minden perc megéri, mert a konténerizáció tudása ma már alap elvárás a legtöbb fejlesztői pozícióban.

Kérdésed van? Vagy valami nem működik? Írd meg kommentben, segítek! 🐳