Kurs NestJS · Moduł 12: Konteneryzacja i CI/CD

Kubernetes - Zarządzanie Prowincjami Imperium

4 min czytania ·
W tej lekcji8

Salve, legioniście! Dotychczas nauczyliśmy się budować obozy legionowe (kontenery Docker) i łączyć je drogami (Docker Compose). Ale Imperium Rzymskie zarządzało dziesiątkami prowincji jednocześnie. Potrzebowało systemu, który automatycznie rozmieszczał legiony, zastępował poległych żołnierzy i skalował siły w odpowiedzi na zagrożenia. W świecie aplikacji, tę rolę pełni Kubernetes (K8s).

Czym jest Kubernetes?

Kubernetes to platforma do orkiestracji kontenerów - automatycznie zarządza wdrażaniem, skalowaniem i operowaniem kontenerami na klastrze serwerów. Nazwa pochodzi od greckiego słowa "sternik" - Kubernetes jest sternikiem naszego legionu kontenerów.

// Analogia: Imperium Rzymskie vs Kubernetes
interface ImperiumKubernetes {
  imperator: 'Control Plane';       // Centrum dowodzenia
  prowincje: 'Nodes (serwery)';     // Maszyny w klastrze
  legiony: 'Pods';                  // Jednostki wdrożeniowe
  edykty: 'Deployments';            // Deklaracje stanu
  drogi: 'Services';                // Komunikacja sieciowa
  bramy: 'Ingress';                 // Wejście z zewnątrz
}

const k8sConcepts = {
  pod: 'Najmniejsza jednostka - jeden lub więcej kontenerów',
  deployment: 'Zarządza replikami podów (ile legionów)',
  service: 'Stały adres sieciowy dla podów',
  ingress: 'Brama wejściowa z zewnątrz (HTTP/HTTPS)',
  configMap: 'Konfiguracja bez sekretów (edykty publiczne)',
  secret: 'Zaszyfrowane dane wrażliwe (tajne depesze)',
  namespace: 'Izolacja zasobów (prowincje)',
};

Pod - Najmniejsza jednostka

Pod to najmniejsza jednostka wdrożeniowa w Kubernetes. Zawiera jeden lub więcej kontenerów, które współdzielą sieć i storage:

# pod-definition.yaml
apiVersion: v1
kind: Pod
metadata:
  name: roman-api-pod
  labels:
    app: roman-imperium
    tier: backend
spec:
  containers:
    - name: api
      image: roman-imperium-api:1.0
      ports:
        - containerPort: 4000
      env:
        - name: NODE_ENV
          value: "production"

Deployment - Edykt wdrożeniowy

Deployment to deklaracja, jak ma wyglądać nasz stan docelowy. Kubernetes sam dba o to, żeby rzeczywistość odpowiadała deklaracji:

# deployment.yaml - Wdrożenie API NestJS
apiVersion: apps/v1
kind: Deployment
metadata:
  name: roman-api
  labels:
    app: roman-imperium
spec:
  replicas: 3                  # 3 legiony (instancje)
  selector:
    matchLabels:
      app: roman-imperium
  template:
    metadata:
      labels:
        app: roman-imperium
    spec:
      containers:
        - name: api
          image: roman-imperium-api:1.0
          ports:
            - containerPort: 4000
          resources:
            requests:
              memory: "256Mi"
              cpu: "250m"
            limits:
              memory: "512Mi"
              cpu: "500m"
          livenessProbe:         # Czy legion żyje?
            httpGet:
              path: /health
              port: 4000
            initialDelaySeconds: 30
            periodSeconds: 10
          readinessProbe:        # Czy legion gotowy do walki?
            httpGet:
              path: /health
              port: 4000
            initialDelaySeconds: 5
            periodSeconds: 5

Service - Drogi Imperium

Service zapewnia stały adres sieciowy dla podów, nawet gdy pody są zastępowane:

# service.yaml - Droga do API
apiVersion: v1
kind: Service
metadata:
  name: roman-api-service
spec:
  selector:
    app: roman-imperium
  ports:
    - protocol: TCP
      port: 80            # Port zewnętrzny
      targetPort: 4000    # Port kontenera
  type: ClusterIP          # Dostępny tylko wewnątrz klastra

Ingress - Brama Imperium

Ingress kieruje ruch HTTP/HTTPS z zewnątrz do odpowiednich serwisów:

# ingress.yaml - Brama Imperium
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: roman-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  rules:
    - host: api.roman-imperium.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: roman-api-service
                port:
                  number: 80

ConfigMap i Secret - Edykty i tajne depesze

# configmap.yaml - Publiczna konfiguracja
apiVersion: v1
kind: ConfigMap
metadata:
  name: roman-config
data:
  NODE_ENV: "production"
  PORT: "4000"
  LOG_LEVEL: "warn"
---
# secret.yaml - Zaszyfrowane sekrety
apiVersion: v1
kind: Secret
metadata:
  name: roman-secrets
type: Opaque
data:
  DATABASE: bW9uZ29kYjovL2ltcGVyYXRvcjpyb21hQG1vbmdvZGI6MjcwMTcvaW1wZXJpdW0=
  JWT_SECRET: c3VwZXItc2VjcmV0LWtleS1jaGFuZ2UtbWU=

HPA - Autoskalowanie legionów

Horizontal Pod Autoscaler automatycznie skaluje liczbę podów w odpowiedzi na obciążenie:

# hpa.yaml - Autoskalowanie
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: roman-api-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: roman-api
  minReplicas: 2          # Minimum 2 legiony
  maxReplicas: 10         # Maksimum 10 legionów
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 70    # Skaluj przy 70% CPU

Podstawowe komendy kubectl

# Wdróż zasoby
kubectl apply -f deployment.yaml

# Sprawdź pody
kubectl get pods

# Sprawdź deploymenty
kubectl get deployments

# Logi poda
kubectl logs roman-api-xxxxx

# Skaluj ręcznie
kubectl scale deployment roman-api --replicas=5

# Sprawdź status HPA
kubectl get hpa

Kubernetes to system zarządzania prowincjami naszego Imperium - automatycznie rozmieszcza legiony, zastępuje poległych i skaluje siły w odpowiedzi na zagrożenia. To fundament nowoczesnej infrastruktury produkcyjnej.

Kod do tej lekcji: src/kubernetes-concepts.ts
// Kubernetes - Zarzadzanie Prowincjami Imperium
console.log("=== KUBERNETES (K8s) ===\n");

interface K8sResource {
  name: string;
  kind: string;
  romanAnalogy: string;
  description: string;
}

const resources: K8sResource[] = [
  {
    name: 'Pod',
    kind: 'v1/Pod',
    romanAnalogy: 'Pojedynczy legion',
    description: 'Najmniejsza jednostka - jeden lub wiecej kontenerow',
  },
  {
    name: 'Deployment',
    kind: 'apps/v1/Deployment',
    romanAnalogy: 'Edykt wdrozeniowy',
    description: 'Zarzadza replikami podow',
  },
  {
    name: 'Service',
    kind: 'v1/Service',
    romanAnalogy: 'Drogi rzymskie',
    description: 'Staly adres sieciowy dla podow',
  },
  {
    name: 'Ingress',
    kind: 'networking.k8s.io/v1/Ingress',
    romanAnalogy: 'Brama Imperium',
    description: 'Wejscie HTTP/HTTPS z zewnatrz',
  },
  {
    name: 'ConfigMap',
    kind: 'v1/ConfigMap',
    romanAnalogy: 'Edykty publiczne',
    description: 'Konfiguracja bez sekretow',
  },
  {
    name: 'Secret',
    kind: 'v1/Secret',
    romanAnalogy: 'Tajne depesze',
    description: 'Zaszyfrowane dane wrazliwe',
  },
  {
    name: 'HPA',
    kind: 'autoscaling/v2/HPA',
    romanAnalogy: 'Autoskalowanie legionow',
    description: 'Automatyczne skalowanie przy obciazeniu',
  },
];

console.log("Zasoby Kubernetes:\n");
resources.forEach((r, i) => {
  console.log(`${i + 1}. ${r.name} (${r.kind})`);
  console.log(`   Analogia: ${r.romanAnalogy}`);
  console.log(`   Opis: ${r.description}\n`);
});

// Komendy kubectl
console.log("=== KOMENDY kubectl ===\n");
const commands = [
  'kubectl apply -f deployment.yaml',
  'kubectl get pods',
  'kubectl get services',
  'kubectl logs <pod-name>',
  'kubectl scale deployment roman-api --replicas=5',
  'kubectl get hpa',
];

commands.forEach(cmd => console.log(`  $ ${cmd}`));

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Czym jest Kubernetes (K8s)?

  2. 2. Czym jest Pod w Kubernetes?

To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Edytor kodu

    Uzupełnij definicje zasobów K8s: Pod, Deployment, Service, Ingress, ConfigMap, Secret, HPA

  • Układanie w pionie

    Uporządkuj kroki wdrożenia aplikacji NestJS w Kubernetes:

  1. PytanieCzym jest Kubernetes
  2. PytaniePod w Kubernetes
  3. Zadanie z kodemZasoby Kubernetes w praktyce
  4. PytanieDeployment w Kubernetes
  5. Ułóż w kolejnościWdrożenie aplikacji w Kubernetes

Przydatne artykuły