C# / .NET Kompendium PLEN
.NET / C# / Architektura rozproszona

Docker i Kubernetes - podstawy w kontekście mikroserwisów

Docker - konteneryzacja pojedynczego serwisu

Docker pozwala spakować aplikację (kod + runtime + zależności + konfigurację) w przenośny, izolowany obraz, który działa identycznie niezależnie od maszyny, na której jest uruchamiany.

# Dockerfile dla ASP.NET Core Web API (dokładnie ten OrderService, o którym mówiliśmy)
FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY *.csproj .
RUN dotnet restore
COPY . .
RUN dotnet publish -c Release -o /app

FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS runtime
WORKDIR /app
COPY --from=build /app .
ENTRYPOINT ["dotnet", "OrderService.dll"]

Wieloetapowy build (multi-stage) - pierwszy etap (build) ma pełny SDK (kompilator, narzędzia), drugi etap (runtime) ma tylko runtime potrzebny do wykonania - finalny obraz jest znacznie mniejszy, bo nie zawiera niepotrzebnych narzędzi budowania.

docker build -t order-service:latest .
docker run -p 5000:80 order-service:latest

Docker Compose - uruchamianie wielu powiązanych serwisów lokalnie

To jest praktyczne narzędzie do lokalnego developmentu architektury mikroserwisów - jednym plikiem opisujesz całą infrastrukturę (serwisy + baza + Kafka), którą docker-compose up uruchamia naraz:

version: '3.8'
services:
  order-service:
    build: ./OrderService
    ports:
      - "5001:80"
    environment:
      - ConnectionStrings__DefaultConnection=Server=order-db;Database=OrderDb;User=sa;Password=Pass123!
      - Kafka__BootstrapServers=kafka:9092
    depends_on:
      - order-db
      - kafka

  inventory-service:
    build: ./InventoryService
    ports:
      - "5002:80"
    depends_on:
      - inventory-db
      - kafka

  order-db:
    image: mcr.microsoft.com/mssql/server:2022-latest
    environment:
      - ACCEPT_EULA=Y
      - SA_PASSWORD=Pass123!
    ports:
      - "1433:1433"

  kafka:
    image: confluentinc/cp-kafka:latest
    ports:
      - "9092:9092"
    environment:
      - KAFKA_ZOOKEEPER_CONNECT=zookeeper:2181
    depends_on:
      - zookeeper

  zookeeper:
    image: confluentinc/cp-zookeeper:latest

Kluczowa obserwacja architektoniczna - każdy mikroserwis (order-service, inventory-service) ma własną, dedykowaną bazę (order-db, inventory-db) - to jest wprost realizacja zasady, o której mówiliśmy przy Sadze: brak jednej, współdzielonej bazy danych między serwisami, stąd potrzeba Sagi/Outboxa do koordynacji zamiast klasycznej transakcji SQL.

Kubernetes - orkiestracja na produkcji (skala, którą Docker Compose nie obsługuje)

Docker Compose jest świetny lokalnie, ale nie jest przeznaczony do produkcji na dużą skalę - brak automatycznego skalowania, brak samo-naprawiania (self-healing) przy awarii, brak rozproszenia między wiele maszyn fizycznych. Tym zajmuje się Kubernetes (K8s).

Pod - najmniejsza jednostka wdrożenia

apiVersion: v1
kind: Pod
metadata:
  name: order-service-pod
spec:
  containers:
    - name: order-service
      image: order-service:latest
      ports:
        - containerPort: 80

Pod to jeden lub więcej kontenerów (najczęściej jeden) współdzielących sieć i storage - to jest podstawowa jednostka, którą Kubernetes zarządza (uruchamia, restartuje, skaluje).

Deployment - zarządzanie wieloma replikami Poda

apiVersion: apps/v1
kind: Deployment
metadata:
  name: order-service-deployment
spec:
  replicas: 3 # 3 NIEZALEŻNE instancje OrderService, dla wysokiej dostępności i przepustowości
  selector:
    matchLabels:
      app: order-service
  template:
    metadata:
      labels:
        app: order-service
    spec:
      containers:
        - name: order-service
          image: order-service:latest
          ports:
            - containerPort: 80
          env:
            - name: ConnectionStrings__DefaultConnection
              valueFrom:
                secretKeyRef:
                  name: order-db-secret
                  key: connectionString

Deployment gwarantuje, że zawsze działa zadana liczba replik (replicas: 3) - jeśli jeden Pod padnie (crash, awaria maszyny), Kubernetes automatycznie tworzy nowy, żeby przywrócić żądaną liczbę. To jest właśnie self-healing, czego Docker Compose nie zapewnia.

Nawiązanie do Kafka Consumer Groups - jeśli te 3 repliki OrderService nasłuchują z tego samego topicu Kafki jako jedna consumer group, Kubernetes automatycznie utrzymuje 3 działające instancje do dzielenia partycji między sobą, dokładnie jak omawialiśmy wcześniej.

Service - stabilny punkt dostępu do zmiennych Podów

apiVersion: v1
kind: Service
metadata:
  name: order-service
spec:
  selector:
    app: order-service # kieruje ruch do WSZYSTKICH Podów z tą etykietą
  ports:
    - port: 80
      targetPort: 80
  type: ClusterIP # dostępne tylko WEWNĄTRZ klastra (inne serwisy mogą się połączyć)

Problem, który Service rozwiązuje: Pody są efemeryczne - mogą być tworzone/usuwane/restartowane, każdy z własnym, zmiennym adresem IP. Service daje stabilną nazwę (order-service), przez którą inne serwisy (np. InventoryService wywołujący OrderService przez HTTP) zawsze mogą się połączyć, niezależnie od tego, które konkretne Pody aktualnie działają "pod spodem" - Kubernetes automatycznie kieruje ruch (load balancing) do zdrowych Podów.

// InventoryService wywołujący OrderService - używa STABILNEJ nazwy Service, nie konkretnego IP Poda
builder.Services.AddHttpClient<IOrderServiceClient, OrderServiceClient>(client =>
    client.BaseAddress = new Uri("http://order-service")); // "order-service" to nazwa K8s Service

ConfigMap i Secret - konfiguracja i dane wrażliwe

apiVersion: v1
kind: Secret
metadata:
  name: order-db-secret
type: Opaque
stringData:
  connectionString: "Server=order-db;Database=OrderDb;User=sa;Password=Pass123!"

Secret (dla danych wrażliwych, jak connection stringi z hasłami) i ConfigMap (dla zwykłej konfiguracji) pozwalają odseparować konfigurację od obrazu kontenera - ten sam obraz order-service:latest może być wdrożony w różnych środowiskach (dev/staging/prod) z różną konfiguracją, bez przebudowywania obrazu.

Podsumowanie - jak to się łączy w jedną architekturę

Docker pakuje pojedynczy mikroserwis w przenośny, izolowany obraz. Docker Compose lokalnie uruchamia całą architekturę (wiele serwisów + bazy + Kafka) do developmentu, jednocześnie naturalnie wymuszając myślenie o niej jako o zbiorze niezależnych serwisów z własnymi bazami danych (stąd potrzeba Sagi/Outboxa do koordynacji). Kubernetes przenosi to na produkcję w dużej skali - Deployment gwarantuje żądaną liczbę zawsze-działających replik (self-healing, automatyczne skalowanie), a Service daje stabilny punkt wejścia do dynamicznie zmieniającego się zestawu Podów, przez który inne serwisy komunikują się (np. przez HTTP albo publikując/konsumując zdarzenia z Kafki, jak omawialiśmy wcześniej).

Postaw mi kawę