Kubernetes - Gérer les provinces de l'Empire

Salve, légionnaire ! Jusqu'à présent, nous avons appris à construire des camps de légionnaires (conteneurs Docker) et à les relier par des routes (Docker Compose). Mais l'Empire romain gérait des dizaines de provinces simultanément. Il lui fallait un système qui déployait automatiquement les légions, remplaçait les soldats tombés et adaptait les forces face aux menaces. Dans le monde des applications, ce rôle est rempli par Kubernetes (K8s).

Qu'est-ce que Kubernetes ?

Kubernetes est une plateforme d'orchestration de conteneurs - elle gère automatiquement le déploiement, la mise à l'échelle et l'exploitation des conteneurs à travers un cluster de serveurs. Le nom vient du mot grec signifiant « timonier » - Kubernetes est le timonier de notre flotte de conteneurs.

1// Analogie : Empire romain vs Kubernetes
2interface ImperiumKubernetes {
3  imperator: 'Control Plane';       // Centre de commandement
4  prowincje: 'Nodes (serveurs)';    // Machines du cluster
5  legiony: 'Pods';                  // Unités de déploiement
6  edykty: 'Deployments';            // Déclarations d'état
7  drogi: 'Services';                // Communication réseau
8  bramy: 'Ingress';                 // Entrée externe
9}
10
11const k8sConcepts = {
12  pod: 'Plus petite unité - un ou plusieurs conteneurs',
13  deployment: 'Gère les répliques de pods (combien de légions)',
14  service: 'Adresse réseau stable pour les pods',
15  ingress: 'Passerelle d\'entrée depuis l\'extérieur (HTTP/HTTPS)',
16  configMap: 'Configuration sans secrets (édits publics)',
17  secret: 'Données sensibles chiffrées (dépêches secrètes)',
18  namespace: 'Isolation des ressources (provinces)',
19};

Pod - La plus petite unité

Un Pod est la plus petite unité de déploiement dans Kubernetes. Il contient un ou plusieurs conteneurs qui partagent le réseau et le stockage :

1# pod-definition.yaml
2apiVersion: v1
3kind: Pod
4metadata:
5  name: roman-api-pod
6  labels:
7    app: roman-imperium
8    tier: backend
9spec:
10  containers:
11    - name: api
12      image: roman-imperium-api:1.0
13      ports:
14        - containerPort: 4000
15      env:
16        - name: NODE_ENV
17          value: "production"

Deployment - L'édit de déploiement

Un Deployment est une déclaration de ce à quoi doit ressembler l'état souhaité. Kubernetes lui-même veille à ce que la réalité corresponde à la déclaration :

1# deployment.yaml - Deployment de l'API NestJS
2apiVersion: apps/v1
3kind: Deployment
4metadata:
5  name: roman-api
6  labels:
7    app: roman-imperium
8spec:
9  replicas: 3                  # 3 légions (instances)
10  selector:
11    matchLabels:
12      app: roman-imperium
13  template:
14    metadata:
15      labels:
16        app: roman-imperium
17    spec:
18      containers:
19        - name: api
20          image: roman-imperium-api:1.0
21          ports:
22            - containerPort: 4000
23          resources:
24            requests:
25              memory: "256Mi"
26              cpu: "250m"
27            limits:
28              memory: "512Mi"
29              cpu: "500m"
30          livenessProbe:         # La légion est-elle en vie ?
31            httpGet:
32              path: /health
33              port: 4000
34            initialDelaySeconds: 30
35            periodSeconds: 10
36          readinessProbe:        # La légion est-elle prête au combat ?
37            httpGet:
38              path: /health
39              port: 4000
40            initialDelaySeconds: 5
41            periodSeconds: 5

Service - Les routes de l'Empire

Un Service fournit une adresse réseau stable pour les pods, même lorsque les pods sont remplacés :

1# service.yaml - Route vers l'API
2apiVersion: v1
3kind: Service
4metadata:
5  name: roman-api-service
6spec:
7  selector:
8    app: roman-imperium
9  ports:
10    - protocol: TCP
11      port: 80            # Port externe
12      targetPort: 4000    # Port du conteneur
13  type: ClusterIP          # Disponible uniquement dans le cluster

Ingress - La porte de l'Empire

Ingress route le trafic HTTP/HTTPS depuis l'extérieur vers les services appropriés :

1# ingress.yaml - Porte de l'Empire
2apiVersion: networking.k8s.io/v1
3kind: Ingress
4metadata:
5  name: roman-ingress
6  annotations:
7    nginx.ingress.kubernetes.io/rewrite-target: /
8spec:
9  rules:
10    - host: api.roman-imperium.com
11      http:
12        paths:
13          - path: /
14            pathType: Prefix
15            backend:
16              service:
17                name: roman-api-service
18                port:
19                  number: 80

ConfigMap et Secret - Édits et dépêches secrètes

1# configmap.yaml - Configuration publique
2apiVersion: v1
3kind: ConfigMap
4metadata:
5  name: roman-config
6data:
7  NODE_ENV: "production"
8  PORT: "4000"
9  LOG_LEVEL: "warn"
10---
11# secret.yaml - Secrets chiffrés
12apiVersion: v1
13kind: Secret
14metadata:
15  name: roman-secrets
16type: Opaque
17data:
18  DATABASE: bW9uZ29kYjovL2ltcGVyYXRvcjpyb21hQG1vbmdvZGI6MjcwMTcvaW1wZXJpdW0=
19  JWT_SECRET: c3VwZXItc2VjcmV0LWtleS1jaGFuZ2UtbWU=

HPA - Mise à l'échelle automatique des légions

Le Horizontal Pod Autoscaler met automatiquement à l'échelle le nombre de pods en fonction de la charge :

1# hpa.yaml - Mise à l'échelle automatique
2apiVersion: autoscaling/v2
3kind: HorizontalPodAutoscaler
4metadata:
5  name: roman-api-hpa
6spec:
7  scaleTargetRef:
8    apiVersion: apps/v1
9    kind: Deployment
10    name: roman-api
11  minReplicas: 2          # Minimum 2 légions
12  maxReplicas: 10         # Maximum 10 légions
13  metrics:
14    - type: Resource
15      resource:
16        name: cpu
17        target:
18          type: Utilization
19          averageUtilization: 70    # Mise à l'échelle à 70 % du CPU

Commandes kubectl de base

1# Déployer les ressources
2kubectl apply -f deployment.yaml
3
4# Vérifier les pods
5kubectl get pods
6
7# Vérifier les deployments
8kubectl get deployments
9
10# Logs d'un pod
11kubectl logs roman-api-xxxxx
12
13# Mise à l'échelle manuelle
14kubectl scale deployment roman-api --replicas=5
15
16# Vérifier l'état du HPA
17kubectl get hpa

Kubernetes est le système de gestion des provinces de notre Empire - il déploie automatiquement les légions, remplace les soldats tombés et adapte les forces face aux menaces. C'est le socle de l'infrastructure de production moderne.

1// Kubernetes - Gérer les provinces de l'Empire
2console.log("=== KUBERNETES (K8s) ===\n");
3
4interface K8sResource {
5  name: string;
6  kind: string;
7  romanAnalogy: string;
8  description: string;
9}
10
11const resources: K8sResource[] = [
12  {
13    name: 'Pod',
14    kind: 'v1/Pod',
15    romanAnalogy: 'Légion unique',
16    description: 'Plus petite unité - un ou plusieurs conteneurs',
17  },
18  {
19    name: 'Deployment',
20    kind: 'apps/v1/Deployment',
21    romanAnalogy: 'Édit de déploiement',
22    description: 'Gère les répliques de pods',
23  },
24  {
25    name: 'Service',
26    kind: 'v1/Service',
27    romanAnalogy: 'Routes romaines',
28    description: 'Adresse réseau permanente pour les pods',
29  },
30  {
31    name: 'Ingress',
32    kind: 'networking.k8s.io/v1/Ingress',
33    romanAnalogy: 'Porte de l\'Empire',
34    description: 'Entrée HTTP/HTTPS depuis l\'extérieur',
35  },
36  {
37    name: 'ConfigMap',
38    kind: 'v1/ConfigMap',
39    romanAnalogy: 'Édits publics',
40    description: 'Configuration sans secrets',
41  },
42  {
43    name: 'Secret',
44    kind: 'v1/Secret',
45    romanAnalogy: 'Dépêches secrètes',
46    description: 'Données sensibles chiffrées',
47  },
48  {
49    name: 'HPA',
50    kind: 'autoscaling/v2/HPA',
51    romanAnalogy: 'Mise à l\'échelle automatique des légions',
52    description: 'Mise à l\'échelle automatique selon la charge',
53  },
54];
55
56console.log("Ressources Kubernetes :\n");
57resources.forEach((r, i) => {
58  console.log(`${i + 1}. ${r.name} (${r.kind})`);
59  console.log(`   Analogie : ${r.romanAnalogy}`);
60  console.log(`   Description : ${r.description}\n`);
61});
62
63// Commandes kubectl
64console.log("=== COMMANDES kubectl ===\n");
65const commands = [
66  'kubectl apply -f deployment.yaml',
67  'kubectl get pods',
68  'kubectl get services',
69  'kubectl logs <pod-name>',
70  'kubectl scale deployment roman-api --replicas=5',
71  'kubectl get hpa',
72];
73
74commands.forEach(cmd => console.log(`  $ ${cmd}`));
75