Kubernetes sur Azure avec Terraform : Du Concept à la Mise en Production

Kubernetes a révolutionné la façon dont nous déployons et gérons les applications conteneurisées. Mais passer de la théorie à la production peut être intimidé.

Ce guide vous accompagnera à travers trois étapes fondamentales :

Les concepts clés de Kubernetes expliqués simplement
Le déploiement sur Azure (AKS – Azure Kubernetes Service)
L’automatisation avec Terraform pour une infrastructure reproductible

Que vous soyez développeur découvrant Kubernetes ou architecte optimisant votre infrastructure cloud, vous trouverez ici une approche complète et pratique.

Partie 1 : Les Concepts Fondamentaux de Kubernetes

1.1 Qu’est-ce que Kubernetes ?

Kubernetes (souvent abrégé K8s) est un orchestrateur de conteneurs. C’est un système qui automatise :

Le déploiement de vos applications
La mise à l’échelle (scaling) automatique
La gestion des ressources
La haute disponibilité et la récupération en cas d’erreur

Analogie : Si Docker est une boîte pour livrer votre application, Kubernetes est l’usine entière qui reçoit, traite et distribue ces boîtes.

1.2 Architecture Générale

Kubernetes fonctionne sur une architecture maître-ouvrier :

			
┌─────────────────────────────────────────┐
│                  CLUSTER KUBERNETES                      │
├─────────────────────────────────────────┤
│                                                            │
│  ┌──────────────────────────────┐ │
│  │          Control Plane (Maître)                 │ │
│  │  - API Server                                   │ │
│  │  - Scheduler                                    │ │
│  │  - Controller Manager                           │ │
│  │  - etcd (base de données)                       │ │
│  └──────────────────────────────┘ │
│                          ↓                               │
│  ┌──────────┌──────────┌──────────┐        │
│  │   Node 1     │   Node 2     │   Node 3     │        │
│  │  (Worker)    │  (Worker)    │  (Worker)    │        │
│  │  - Kubelet   │  - Kubelet   │  - Kubelet   │        │
│  │  - Pods      │  - Pods      │  - Pods      │        │
│  └──────────┴──────────┴──────────┘        │
│                                                            │
└─────────────────────────────────────────┘

		

Le Control Plane : Cerveau du cluster, prend les décisions
Les Nodes : Machines qui exécutent vos applications

1.3 Concepts Clés

1.3.1 Pod

Le Pod est la plus petite unité dans Kubernetes. C’est un conteneur (ou groupe de conteneurs intimement liés).

			
apiVersion: v1
kind: Pod
metadata:
  name: mon-app
spec:
  containers:
  - name: app
    image: monapp:1.0
    ports:
    - containerPort: 8080

		

Important : Un Pod est éphémère. Si un Pod crash, Kubernetes n’essaie pas de le réparer — il le supprime et en crée un nouveau.

1.3.2 Deployment

Un Deployment gère les Pods. Il dit : “Je veux toujours 3 copies de mon application”.

			
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 3  # Toujours 3 Pods actifs
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: app
        image: monapp:1.0
        ports:
        - containerPort: 8080

		

Bénéfices :

Haute disponibilité (si 1 Pod crash, 2 autres continuent)
Scaling facile (augmenter replicas à 5 = 5 Pods instantanément)
Mises à jour sans downtime (rolling updates)

1.3.3 Service

Un Service expose vos Pods à l’intérieur ou l’extérieur du cluster.

			
apiVersion: v1
kind: Service
metadata:
  name: my-app-service
spec:
  type: LoadBalancer  # Expose l'app en externe
  selector:
    app: my-app
  ports:
  - protocol: TCP
    port: 80        # Port externe
    targetPort: 8080  # Port du Pod

		

Types de Services :

ClusterIP : Accès interne uniquement
NodePort : Accès externe via port spécifique
LoadBalancer : Accès externe via load balancer cloud (Azure, AWS, etc.)

1.3.4 ConfigMap et Secret

ConfigMap : Stocke la configuration (variables d’environnement, fichiers)
Secret : Stocke les données sensibles (API keys, passwords)

			
apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  database_host: "db.azure.com"
  log_level: "INFO"
---
apiVersion: v1
kind: Secret
metadata:
  name: db-secret
type: Opaque
data:
  password: cGFzc3dvcmQxMjM=  # Base64 encodé

		

1.3.5 Namespace

Les Namespaces partitionnent le cluster logiquement. Utile pour :

Séparer dev/staging/prod
Isoler les équipes
Contrôler les ressources par équipe

			
kubectl create namespace production
kubectl create namespace staging

1.4 Cycle de Vie d’une Application Kubernetes

Étape 1 : Vous décrivez votre Deployment en YAML
Étape 2 : Vous appliquez : kubectl apply -f deployment.yaml
Étape 3 : Kubernetes crée automatiquement les Pods
Étape 4 : Si un Pod crash, Kubernetes en crée un nouveau
Étape 5 : Pour mettre à jour, changez l’image → Kubernetes fait un rolling update

Partie 2 : Déployer sur Azure Kubernetes Service (AKS)

2.1 Qu’est-ce qu’AKS ?

Azure Kubernetes Service (AKS) est une version managée de Kubernetes sur Azure. Vous ne gérez pas le Control Plane — Azure le fait pour vous.

Avantages :

✅ Moins de maintenance
✅ Intégration native avec Azure (Container Registry, Azure Monitor, etc.)
✅ Auto-scaling automatique
✅ Mises à jour transparentes

2.2 Architecture AKS sur Azure

			
┌────────────────────────────────────────┐
│        Groupe de Ressources Azure      │
├────────────────────────────────────────┤
│                                        │
│  ┌──────────────────────────────┐ │
│  │   AKS Cluster                    │ │
│  │  - Control Plane (géré par Azure)│ │
│  │  - Node Pool 1 (Linux)           │ │
│  │  - Node Pool 2 (Windows)         │ │
│  └──────────────────────────────┘ │
│                                        │
│  ┌──────────────────────────────┐ │
│  │  Azure Container Registry (ACR)  │ │
│  │  - Stockage de vos images Docker │ │
│  └──────────────────────────────┘ │
│                                        │
│  ┌──────────────────────────────┐ │
│  │  Azure Monitor / Log Analytics   │ │
│  │  - Logs et métriques             │ │
│  └──────────────────────────────┘ │
│                                        │
└────────────────────────────────────────┘

		

2.3 Prérequis

Avant de commencer, vous avez besoin de :

Compte Azure avec une souscription active
Azure CLI : az --version
kubectl : kubectl version --client
Terraform (pour la partie automatisation)

2.4 Déployer Manuellement sur AKS (Fondamentaux)

Étape 1 : Créer un AKS Cluster

			
# Se connecter à Azure
az login
# Créer un groupe de ressources
az group create \
  --name myResourceGroup \
  --location eastus
# Créer un cluster AKS
az aks create \
  --resource-group myResourceGroup \
  --name myAKSCluster \
  --node-count 3 \
  --vm-set-type VirtualMachineScaleSets \
  --load-balancer-sku standard \
  --enable-managed-identity \
  --network-plugin azure \
  --network-policy azure

		

Étape 2 : Configurer kubectl

			
# Récupérer les credentials
az aks get-credentials \
  --resource-group myResourceGroup \
  --name myAKSCluster
# Vérifier la connexion
kubectl get nodes

		

Étape 3 : Créer un ACR (Azure Container Registry)

			
# Créer un registre de conteneurs
az acr create \
  --resource-group myResourceGroup \
  --name myACR \
  --sku Basic

		

Étape 4 : Pousser une Image Docker

			
# Se connecter au registre
az acr login --name myACR
# Tagger votre image
docker tag monapp:1.0 myACR.azurecr.io/monapp:1.0
# Pousser l'image
docker push myACR.azurecr.io/monapp:1.0

		

Étape 5 : Déployer sur AKS

			
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: app
        image: myACR.azurecr.io/monapp:1.0
        ports:
        - containerPort: 8080
        resources:
          requests:
            memory: "128Mi"
            cpu: "100m"
          limits:
            memory: "256Mi"
            cpu: "500m"
---
apiVersion: v1
kind: Service
metadata:
  name: my-app-service
spec:
  type: LoadBalancer
  selector:
    app: my-app
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8080

		

			
# Appliquer le déploiement
kubectl apply -f deployment.yaml
# Vérifier le statut
kubectl get pods
kubectl get svc
# Récupérer l'IP externe
kubectl get service my-app-service

		

2.5 Concepts Avancés AKS

Ingress (Routage HTTP avancé)

			
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-app-ingress
spec:
  rules:
  - host: monapp.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: my-app-service
            port:
              number: 80

		

Horizontal Pod Autoscaler (HPA)

			
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: my-app-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: my-app
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70

		

Partie 3 : Infrastructure as Code avec Terraform

3.1 Pourquoi Terraform ?

Terraform vous permet de :

Décrire votre infrastructure en code
Reproduire identiquement votre setup (dev/staging/prod)
Versionner votre infrastructure
Automatiser les déploiements

3.2 Structure Terraform pour AKS

			
terraform/
├── main.tf              # Ressources principales
├── variables.tf         # Variables d'entrée
├── outputs.tf           # Sorties
├── provider.tf          # Configuration des providers
├── terraform.tfvars     # Valeurs des variables
└── kubernetes/          # Manifests Kubernetes
    └── deployment.yaml

		

3.3 Configuration Terraform Complète

Déployer avec Terraform

Étape 1 : Initialiser Terraform

			
cd terraform/
terraform init

Étape 2 : Valider la Configuration

			
terraform validate
terraform plan

Étape 3 : Appliquer l’Infrastructure

terraform apply

Terraform va :

✅ Créer le groupe de ressources
✅ Créer le registre ACR
✅ Créer le cluster AKS
✅ Configurer les connexions
✅ Déployer votre application
✅ Configurer l’autoscaling

Étape 4 : Vérifier le Déploiement

			
# Récupérer les credentials
az aks get-credentials \
  --resource-group $(terraform output -raw resource_group_name) \
  --name $(terraform output -raw aks_cluster_name)
# Vérifier les Pods
kubectl get pods
# Obtenir l'IP de l'application
kubectl get service techsharing-service

		

3.5 Avantages de cette Approche Terraform

Reproductibilité : Même infrastructure partout
Contrôle de version : Suivez les changements d’infrastructure
Automatisation : Déploiements CI/CD faciles
Équipes : Partagez la configuration
Disaster Recovery : Redéploiement en 1 commande

Partie 4 : Workflow Complet de Production

4.1 Pipeline Recommandé

			
┌─────────────────────────────────────────┐
│  1. Développeur pousse du code sur GitHub           │
├─────────────────────────────────────────┤
│         ↓                                             │
│  2. CI/CD (GitHub Actions / Azure Pipelines)        │
│     - Teste le code                                  │
│     - Build l'image Docker                          │
│     - Pousse vers ACR                               │
├─────────────────────────────────────────┤
│         ↓                                             │
│  3. Terraform s'exécute                             │
│     - Met à jour le déploiement Kubernetes          │
│     - Applique les changements d'infrastructure     │
├─────────────────────────────────────────┤
│         ↓                                             │
│  4. Application déployée sur AKS                    │
│     - Rolling update sans downtime                  │
│     - HPA ajuste les replicas                       │
├─────────────────────────────────────────┤
│         ↓                                             │
│  5. Monitoring (Azure Monitor)                      │
│     - Logs, métriques, alertes                      │
└─────────────────────────────────────────┘

		

4.2 Checklist de Sécurité

Avant de mettre en production :

☑ Réseau : Network Policies activées
☑ RBAC : Rôles et permissions configurés
☑ Secrets : Utiliser Azure Key Vault pour les secrets
☑ Images : Signage des images Docker
☑ Monitoring : Alertes configurées
☑ Backups : Strategy de sauvegarde définie
☑ Scaling : HPA configuré pour les pics
☑ DNS : Certificats SSL/TLS en place

Partie 5 : Commandes Essentielles kubectl

Debugging et Monitoring

			
# Voir tous les ressources
kubectl get all -n production
# Logs d'un Pod
kubectl logs <pod-name>
# Accéder au shell d'un Pod
kubectl exec -it <pod-name> -- /bin/bash
# Détails d'une ressource
kubectl describe pod <pod-name>
# Watch les changements en temps réel
kubectl get pods -w
# Événements du cluster
kubectl get events --sort-by='.lastTimestamp'

		

Scaling et Updates

			
# Scaler manuellement
kubectl scale deployment my-app --replicas=5
# Rolling update
kubectl set image deployment/my-app \
  app=myapp:2.0
# Rollback à la version précédente
kubectl rollout undo deployment/my-app
# Voir l'historique
kubectl rollout history deployment/my-app

		

Configuration

			
# Appliquer les changements
kubectl apply -f deployment.yaml
# Supprimer des ressources
kubectl delete -f deployment.yaml
# Patcher une ressource
kubectl patch deployment my-app -p '{"spec":{"replicas":5}}'

		

Partie 6 : Bonnes Pratiques Kubernetes + Terraform

6.1 ✅ À Faire

Pratique	Pourquoi
Définir les ressources (CPU/Mémoire)	Kubernetes optimise le placement
Utiliser des Health Checks	Détecte les Pods morts
Configurer HPA	Scaling automatique
Séparer dev/staging/prod	Environnements isolés
Utiliser des Namespaces	Meilleure organisation
Versionner les images	Rollbacks faciles
Activer le logging	Debug et monitoring

6.2 ❌ À Éviter

Piège	Conséquence
Pas de limites de ressources	Pods écrasent les autres
StatefulSet mal configuré	Données perdues
Pas de backup d’etcd	Perte de configuration
Images `latest`	Imprévisibilité
Secrets en clair	Risques de sécurité
Pas de Network Policies	Accès non restreint

Partie 7 : Troubleshooting Courant

Problème 1 : Pod reste en “Pending”

			
kubectl describe pod <pod-name>
# Causes possibles :
# - Pas assez de ressources
# - Node sélecteur ne correspond pas
# - PVC pas attachée

		

Solution : Augmenter les ressources des nodes ou réduire les demandes.

Problème 2 : ImagePullBackOff

Image ne peut pas être pullée de ACR

Solution : Vérifier les credentials et les permissions ACR.

			
az role assignment create \
  --assignee <kubelet-id> \
  --role "AcrPull" \
  --scope <acr-id>

Problème 3 : Service LoadBalancer n’a pas d’IP externe

			
kubectl get svc
# EXTERNAL-IP: <pending>

Attendre quelques minutes : Azure provisionne le load balancer. Vérifier avec :

kubectl describe svc my-app-service

Conclusion : Vous Avez Maintenant

✅ Compris les concepts Kubernetes
✅ Appris à déployer sur Azure AKS
✅ Maitrisé Terraform pour l’IaC
✅ Mis en place un système reproductible et scalable

Prochaines Étapes

Semaine 1 : Créer votre premier cluster AKS et déployer une app simple
Semaine 2 : Mettre en place Terraform pour votre infrastructure
Semaine 3 : Configurer le monitoring (Azure Monitor)
Semaine 4 : Intégrer dans un pipeline CI/CD

Ressources Supplémentaires

Kubernetes Docs : https://kubernetes.io/docs/
Azure AKS : https://docs.microsoft.com/en-us/azure/aks/
Terraform Azure : https://registry.terraform.io/providers/hashicorp/azurerm/latest/docs
Kubectl Cheatsheet : https://kubernetes.io/docs/reference/kubectl/cheatsheet/

Annexe : Glossaire

Terme	Définition
Pod	Plus petite unité Kubernetes, contient un/plusieurs conteneurs
Deployment	Gère un ensemble de Pods identiques
Service	Expose les Pods en interne/externe
ConfigMap	Stockage de configuration
Secret	Stockage de données sensibles
Namespace	Partition logique du cluster
Node	Machine physique/virtuelle du cluster
Control Plane	Cerveau du cluster Kubernetes
etcd	Base de données de configuration Kubernetes
kubelet	Agent qui gère les Pods sur chaque node
HPA	Horizontal Pod Autoscaler
AKS	Azure Kubernetes Service
ACR	Azure Container Registry
IaC	Infrastructure as Code

Article rédigé pour techpassionsharing.com
Votre ressource pour maîtriser Kubernetes en production