Déployer une application microservices sur Kubernetes : tutoriel complet

Ce tutoriel vous accompagne pas à pas pour déployer application microservices Kubernetes guide pratique. Vous apprendrez à structurer vos services, configurer le networking inter-pods, gérer les ConfigMaps et Secrets, et exposer votre application au monde extérieur.

Selon le CNCF Annual Survey 2025, 82% des utilisateurs de conteneurs exécutent Kubernetes en production. Ce guide transforme cette statistique en compétence concrète.

TL;DR : Déployez une application microservices complète (frontend, backend API, base de données) sur Kubernetes en 45 minutes. Vous maîtriserez les Deployments, Services, Ingress, ConfigMaps, et le debugging inter-services.

Pour maîtriser ces compétences, découvrez la formation LFD459 Kubernetes pour les développeurs d'applications.

Pourquoi ce guide pour déployer application microservices Kubernetes ?

Les architectures microservices dominent le développement cloud-native. Pourtant, le passage de Docker Compose à Kubernetes déroute de nombreux développeurs. Ce guide comble ce fossé.

Le problème résolu : vous avez une application fonctionnelle en local avec Docker Compose. Vous devez la déployer sur un cluster Kubernetes de production. Ce tutoriel vous montre exactement comment procéder.

Selon Mordor Intelligence, le marché Kubernetes atteindra 8,41 milliards USD d'ici 2031 (CAGR de 21,85%). Maîtriser ces déploiements devient une compétence stratégique.

À retenir : Ce guide couvre le déploiement complet d'une stack 3-tiers : frontend React, API Node.js, base PostgreSQL. Chaque composant illustre un pattern Kubernetes différent.

Prérequis : environnement et outils nécessaires

Avant de commencer, vérifiez votre environnement local. Consultez notre guide d'installation Kubernetes en local si nécessaire.

Versions et outils requis

# Vérification rapide de l'environnement
kubectl cluster-info
kubectl get nodes

Démarrez minikube avec suffisamment de ressources :

minikube start --cpus=4 --memory=8192 --driver=docker
minikube addons enable ingress
minikube addons enable metrics-server

Structure du projet microservices

Notre application exemple comprend trois services :

microservices-demo/
├── frontend/           # React SPA
│   ├── Dockerfile
│   └── k8s/
│       ├── deployment.yaml
│       └── service.yaml
├── api/                # Node.js Express API
│   ├── Dockerfile
│   └── k8s/
│       ├── deployment.yaml
│       ├── service.yaml
│       └── configmap.yaml
├── database/           # PostgreSQL
│   └── k8s/
│       ├── statefulset.yaml
│       ├── service.yaml
│       └── secret.yaml
└── ingress.yaml

À retenir : Organisez vos manifestes Kubernetes par service, pas par type de ressource. Cette structure facilite le déploiement indépendant de chaque microservice.

Déployer application microservices Kubernetes guide : la base de données

Commençons par PostgreSQL. Une base de données nécessite un StatefulSet pour garantir la persistance et l'identité stable des pods.

Créer le Secret pour les credentials

# database/k8s/secret.yaml
apiVersion: v1
kind: Secret
metadata:
  name: postgres-secret
  namespace: microservices
type: Opaque
stringData:
  POSTGRES_USER: appuser
  POSTGRES_PASSWORD: SecureP@ss2026!
  POSTGRES_DB: microservices_db

Appliquez le namespace et le secret :

kubectl create namespace microservices
kubectl apply -f database/k8s/secret.yaml -n microservices

Configurer le stockage persistant

Consultez notre guide complet sur les volumes persistants Kubernetes pour approfondir ce sujet.

# database/k8s/statefulset.yaml
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: postgres
  namespace: microservices
spec:
  serviceName: postgres
  replicas: 1
  selector:
    matchLabels:
      app: postgres
  template:
    metadata:
      labels:
        app: postgres
    spec:
      containers:
      - name: postgres
        image: postgres:16.2
        ports:
        - containerPort: 5432
        envFrom:
        - secretRef:
            name: postgres-secret
        volumeMounts:
        - name: postgres-data
          mountPath: /var/lib/postgresql/data
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
  volumeClaimTemplates:
  - metadata:
      name: postgres-data
    spec:
      accessModes: ["ReadWriteOnce"]
      resources:
        requests:
          storage: 5Gi

Service headless pour PostgreSQL

# database/k8s/service.yaml
apiVersion: v1
kind: Service
metadata:
  name: postgres
  namespace: microservices
spec:
  clusterIP: None
  selector:
    app: postgres
  ports:
  - port: 5432
    targetPort: 5432

kubectl apply -f database/k8s/ -n microservices
kubectl get pods -n microservices -w

Attendez que le pod postgres-0 affiche Running et 1/1 ready.

Déployer l'API backend Node.js

L'API backend illustre l'utilisation des ConfigMaps pour la configuration externe et des probes pour le health checking.

ConfigMap pour la configuration

# api/k8s/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: api-config
  namespace: microservices
data:
  NODE_ENV: "production"
  PORT: "3000"
  DB_HOST: "postgres.microservices.svc.cluster.local"
  DB_PORT: "5432"
  LOG_LEVEL: "info"

Deployment avec probes et ressources

# api/k8s/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: api
  namespace: microservices
spec:
  replicas: 3
  selector:
    matchLabels:
      app: api
  template:
    metadata:
      labels:
        app: api
    spec:
      containers:
      - name: api
        image: your-registry/microservices-api:v1.0.0
        ports:
        - containerPort: 3000
        envFrom:
        - configMapRef:
            name: api-config
        - secretRef:
            name: postgres-secret
        livenessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 5
        resources:
          requests:
            memory: "128Mi"
            cpu: "100m"
          limits:
            memory: "256Mi"
            cpu: "200m"

À retenir : Définissez toujours des requests et limits de ressources. Sans eux, un pod peut consommer toutes les ressources du node et impacter les autres workloads.

Service ClusterIP pour l'API

# api/k8s/service.yaml
apiVersion: v1
kind: Service
metadata:
  name: api
  namespace: microservices
spec:
  selector:
    app: api
  ports:
  - port: 80
    targetPort: 3000

kubectl apply -f api/k8s/ -n microservices
kubectl rollout status deployment/api -n microservices

Déployer le frontend React

Le frontend statique utilise Nginx comme serveur web. La configuration diffère légèrement des services backend.

Deployment frontend optimisé

# frontend/k8s/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: frontend
  namespace: microservices
spec:
  replicas: 2
  selector:
    matchLabels:
      app: frontend
  template:
    metadata:
      labels:
        app: frontend
    spec:
      containers:
      - name: frontend
        image: your-registry/microservices-frontend:v1.0.0
        ports:
        - containerPort: 80
        livenessProbe:
          httpGet:
            path: /
            port: 80
          initialDelaySeconds: 10
          periodSeconds: 30
        resources:
          requests:
            memory: "64Mi"
            cpu: "50m"
          limits:
            memory: "128Mi"
            cpu: "100m"

# frontend/k8s/service.yaml
apiVersion: v1
kind: Service
metadata:
  name: frontend
  namespace: microservices
spec:
  selector:
    app: frontend
  ports:
  - port: 80
    targetPort: 80

Configurer l'Ingress pour l'exposition externe

L'Ingress route le trafic externe vers vos services. Consultez notre guide Ingress Controller pour une configuration avancée.

# ingress.yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: microservices-ingress
  namespace: microservices
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
    nginx.ingress.kubernetes.io/ssl-redirect: "false"
spec:
  ingressClassName: nginx
  rules:
  - host: microservices.local
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: frontend
            port:
              number: 80
      - path: /api
        pathType: Prefix
        backend:
          service:
            name: api
            port:
              number: 80

kubectl apply -f ingress.yaml -n microservices

# Récupérer l'IP de l'Ingress
kubectl get ingress -n microservices

# Ajouter l'entrée hosts (Linux/Mac)
echo "$(minikube ip) microservices.local" | sudo tee -a /etc/hosts

Vérifier et debugger le déploiement

Selon Cloud Native Now, les équipes IT passent 34 jours de travail par an à résoudre des problèmes Kubernetes. Ces commandes réduisent ce temps.

Commandes de diagnostic essentielles

# Vue d'ensemble de tous les pods
kubectl get pods -n microservices -o wide

# Logs d'un pod spécifique
kubectl logs -n microservices deployment/api --tail=100

# Logs en temps réel
kubectl logs -n microservices -l app=api -f

# Décrire un pod en erreur
kubectl describe pod -n microservices <pod-name>

# Accès shell pour debugging
kubectl exec -it -n microservices deployment/api -- /bin/sh

Tester la connectivité inter-services

# Depuis un pod API, tester la connexion à PostgreSQL
kubectl exec -it -n microservices deployment/api -- \
  nc -zv postgres.microservices.svc.cluster.local 5432

# Tester l'endpoint de l'API
kubectl run curl-test --rm -it --image=curlimages/curl -- \
  curl http://api.microservices.svc.cluster.local/health

Consultez notre mémo Kubernetes pour d'autres commandes utiles.

À retenir : Les DNS internes Kubernetes suivent le format ..svc.cluster.local. Utilisez ce format pour les communications inter-services.

Gérer les mises à jour avec Rolling Updates

Kubernetes gère les déploiements sans interruption grâce aux rolling updates.

Stratégie de déploiement

# Ajout dans le Deployment
spec:
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0

Mettre à jour l'image

# Mettre à jour l'image de l'API
kubectl set image deployment/api -n microservices \
  api=your-registry/microservices-api:v1.1.0

# Suivre le déploiement
kubectl rollout status deployment/api -n microservices

# En cas de problème, rollback
kubectl rollout undo deployment/api -n microservices

# Historique des révisions
kubectl rollout history deployment/api -n microservices

Scaling et haute disponibilité

Le scaling horizontal répond aux variations de charge.

# Scaling manuel
kubectl scale deployment/api -n microservices --replicas=5

# Scaling automatique avec HPA
kubectl autoscale deployment/api -n microservices \
  --min=3 --max=10 --cpu-percent=70

Manifest HPA complet

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: api-hpa
  namespace: microservices
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: api
  minReplicas: 3
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: 80

Simplifier avec Helm

Pour des déploiements récurrents, Helm standardise vos configurations. Consultez notre guide Premiers pas avec Helm.

Selon Orca Security, 70% des organisations utilisant Kubernetes en cloud utilisent Helm.

# Installer un chart depuis un repository
helm repo add bitnami https://charts.bitnami.com/bitnami
helm install postgres bitnami/postgresql -n microservices \
  --set auth.postgresPassword=SecureP@ss2026!

À retenir : Helm permet de versionner vos déploiements comme du code. Un helm upgrade avec --atomic assure un rollback automatique en cas d'échec.

Bonnes pratiques pour la production

Avant de passer en production, vérifiez ces points essentiels. Retrouvez plus de détails dans la section Comparatifs et alternatives Kubernetes.

Checklist pré-production

Network Policy restrictive

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: api-network-policy
  namespace: microservices
spec:
  podSelector:
    matchLabels:
      app: api
  policyTypes:
  - Ingress
  - Egress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: frontend
    ports:
    - protocol: TCP
      port: 3000
  egress:
  - to:
    - podSelector:
        matchLabels:
          app: postgres
    ports:
    - protocol: TCP
      port: 5432

Erreurs fréquentes et solutions

« Don't let your knowledge remain theoretical - set up a real Kubernetes environment to solidify your skills. »
— TealHQ Kubernetes DevOps Guide

Aller plus loin : ressources complémentaires

Ce tutoriel couvre les fondamentaux. Pour approfondir, explorez notre hub Tutoriels et guides pratiques Kubernetes.

La certification CKAD valide ces compétences de déploiement. La formation LFD459 prépare à cet examen en 3 jours (21h) avec des labs pratiques similaires à ce tutoriel.

À retenir : 71 % des entreprises Fortune 100 exécutent Kubernetes en production (CNCF Project Journey Report). Ces compétences sont directement valorisables sur le marché.

Passez à l'action : formations SFEIR

Vous avez déployé votre première application microservices. Pour maîtriser Kubernetes en profondeur :

Formation LFD459 Kubernetes pour les développeurs d'applications : 3 jours pour préparer la certification CKAD. Labs pratiques, déploiements avancés, debugging.

Kubernetes, les fondamentaux : 1 journée pour découvrir l'écosystème Kubernetes si vous débutez.

Formation LFS458 Administration Kubernetes : 4 jours pour administrer des clusters de production et préparer le CKA.

Consultez nos conseillers pour construire votre parcours de certification.