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 -
Deploymentgwarantuje żądaną liczbę zawsze-działających replik (self-healing, automatyczne skalowanie), aServicedaje 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).