Azure Kubernetes Service (AKS) : Déployer et opérer des microservices en production

Pourquoi choisir AKS ?

Azure Kubernetes Service (AKS) est un service Kubernetes managé qui élimine la complexité opérationnelle du control plane : Microsoft gère les mises à jour, la haute disponibilité des nœuds master et l'intégration avec les services Azure (Azure CNI, Azure AD, Key Vault, ACR, Monitor).

1. Créer un cluster AKS sécurisé

# Variables
$RG      = "rg-aks-prod"
$CLUSTER = "aks-prod-westeu"
$ACR     = "acrtechbyhm"
$REGION  = "westeurope"

# Créer le Resource Group
az group create --name $RG --location $REGION

# Créer l'ACR (Azure Container Registry)
az acr create --resource-group $RG --name $ACR --sku Standard

# Créer le cluster AKS avec Azure CNI, Azure AD et Managed Identity
az aks create 
  --resource-group $RG 
  --name $CLUSTER 
  --node-count 3 
  --node-vm-size Standard_D4s_v5 
  --enable-managed-identity 
  --enable-aad 
  --enable-azure-rbac 
  --network-plugin azure 
  --network-policy azure 
  --attach-acr $ACR 
  --enable-addons monitoring 
  --enable-secret-rotation 
  --zones 1 2 3 
  --generate-ssh-keys

# Récupérer les credentials kubectl
az aks get-credentials --resource-group $RG --name $CLUSTER --overwrite-existing

2. Déployer un microservice avec Helm

# Installer Helm (si absent)
winget install Helm.Helm

# Ajouter un chart repository
helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
helm repo update

# Installer le contrôleur Ingress NGINX
helm install ingress-nginx ingress-nginx/ingress-nginx 
  --namespace ingress-basic 
  --create-namespace 
  --set controller.replicaCount=2 
  --set controller.nodeSelector."kubernetes.io/os"=linux 
  --set defaultBackend.nodeSelector."kubernetes.io/os"=linux

Exemple de manifeste Deployment + Service pour une API .NET :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: api-produits
  namespace: prod
spec:
  replicas: 3
  selector:
    matchLabels:
      app: api-produits
  template:
    metadata:
      labels:
        app: api-produits
    spec:
      containers:
      - name: api-produits
        image: acrtechbyhm.azurecr.io/api-produits:1.4.2
        ports:
        - containerPort: 80
        resources:
          requests:
            cpu: "250m"
            memory: "256Mi"
          limits:
            cpu: "500m"
            memory: "512Mi"
        env:
        - name: DB_CONNECTION
          valueFrom:
            secretKeyRef:
              name: app-secrets
              key: db-connection-string
---
apiVersion: v1
kind: Service
metadata:
  name: api-produits-svc
  namespace: prod
spec:
  selector:
    app: api-produits
  ports:
  - port: 80
    targetPort: 80

3. Horizontal Pod Autoscaler (HPA)

# Activer le metrics-server (requis pour HPA basé CPU)
kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml

# Configurer le HPA : scale de 3 à 10 pods si CPU > 60%
kubectl autoscale deployment api-produits 
  --namespace prod 
  --cpu-percent=60 
  --min=3 
  --max=10

# Vérifier l'état du HPA
kubectl get hpa -n prod

4. Sécuriser les secrets avec Azure Key Vault

# Activer le driver CSI Key Vault
az aks enable-addons 
  --addons azure-keyvault-secrets-provider 
  --name $CLUSTER 
  --resource-group $RG

# Manifeste SecretProviderClass pour monter les secrets
cat <

5. Pipeline CI/CD avec Azure DevOps

Fichier azure-pipelines.yml simplifié :

trigger:
  branches:
    include: [main]

pool:
  vmImage: ubuntu-latest

stages:
- stage: Build
  jobs:
  - job: DockerBuild
    steps:
    - task: Docker@2
      inputs:
        containerRegistry: acr-connection
        repository: api-produits
        command: buildAndPush
        tags: $(Build.BuildId)

- stage: Deploy
  dependsOn: Build
  jobs:
  - deployment: DeployAKS
    environment: production
    strategy:
      runOnce:
        deploy:
          steps:
          - task: KubernetesManifest@0
            inputs:
              action: deploy
              manifests: k8s/deployment.yml
              imagePullSecrets: acr-secret
              containers: |
                acrtechbyhm.azurecr.io/api-produits:$(Build.BuildId)

6. Monitoring avec Azure Monitor Container Insights

• Visualisez la consommation CPU/RAM par pod, namespace et nœud depuis Azure Portal
• Configurez des alertes sur la saturation des nœuds (> 80% RAM)
• Consultez les logs applicatifs dans Log Analytics avec KQL

// KQL : Top 10 pods consommant le plus de mémoire
KubePodInventory
| where TimeGenerated > ago(1h)
| join kind=inner (ContainerMetrics | where MetricName == "memoryWorkingSetBytes")
    on ContainerID
| summarize AvgMemMB = avg(MetricValue) / 1024 / 1024 by PodName, Namespace
| top 10 by AvgMemMB desc

Conclusion

AKS offre un équilibre optimal entre flexibilité Kubernetes et simplicité opérationnelle Azure. En combinant Managed Identity, Key Vault, HPA et une pipeline CI/CD solide, vous disposez d'une plateforme microservices de production robuste et sécurisée.