lumikha

3 min de lecture

Cilium sur AKS : installation et premiers NetworkPolicies eBPF

Migrer depuis le CNI Azure vers Cilium sur AKS, activer Hubble, écrire ses premières NetworkPolicies L3/L4 et vérifier leur comportement.

Cilium est un plugin CNI pour Kubernetes qui s'appuie sur eBPF pour implémenter le réseau et les politiques de sécurité directement dans le kernel Linux. Sur AKS, il est aujourd'hui disponible en tant que CNI de données géré par Microsoft, ce qui simplifie considérablement son adoption.

Pourquoi Cilium plutôt que le CNI Azure par défaut ?#

Le CNI Azure (azure-cni) est fonctionnel mais limité sur le plan des NetworkPolicies : il s'appuie sur iptables, ce qui devient un goulot d'étranglement à grande échelle (des milliers de règles), et ne supporte pas les politiques Layer 7 (HTTP, DNS) ni l'observabilité fine des flux.

Cilium apporte :

  • eBPF : les politiques réseau sont implémentées dans le kernel, sans iptables. Les performances sont meilleures à grande échelle et la latence est réduite.
  • NetworkPolicies étendues : politiques L7 (HTTP paths, DNS), policies basées sur les FQDN (domaines externes), et egress filtering.
  • Hubble : une interface d'observabilité intégrée qui permet de visualiser les flux réseau entre pods en temps réel.

Installation sur AKS#

Microsoft propose Cilium comme "Bring your own CNI" géré ou via le mode Azure CNI Overlay avec Cilium. La façon la plus simple sur un nouveau cluster :

az aks create \
  --resource-group mon-rg \
  --name mon-cluster \
  --network-plugin azure \
  --network-plugin-mode overlay \
  --network-dataplane cilium \
  --generate-ssh-keys

En Terraform :

resource "azurerm_kubernetes_cluster" "main" {
  name                = "mon-cluster"
  resource_group_name = azurerm_resource_group.main.name
  location            = azurerm_resource_group.main.location
  dns_prefix          = "mon-cluster"

  network_profile {
    network_plugin      = "azure"
    network_plugin_mode = "overlay"
    network_dataplane   = "cilium"
  }

  default_node_pool {
    name       = "system"
    node_count = 3
    vm_size    = "Standard_D2s_v3"
  }

  identity {
    type = "SystemAssigned"
  }
}

Vérifier l'installation#

# Vérifier que Cilium est actif
kubectl get pods -n kube-system -l k8s-app=cilium

# Vérifier l'état de Cilium avec le CLI
kubectl exec -n kube-system ds/cilium -- cilium status

# Lister les endpoints Cilium (un par pod)
kubectl exec -n kube-system ds/cilium -- cilium endpoint list

Activer Hubble#

Hubble est l'interface d'observabilité de Cilium. Elle permet de voir les flux réseau autorisés et bloqués entre pods.

# Activer Hubble sur un cluster AKS existant
az aks update \
  --resource-group mon-rg \
  --name mon-cluster \
  --enable-network-observability

Pour accéder à l'UI Hubble localement :

# Port-forward vers Hubble UI
kubectl port-forward -n kube-system svc/hubble-ui 12000:80

# Ou utiliser le CLI Hubble
kubectl exec -n kube-system ds/cilium -- hubble observe --follow

Premières NetworkPolicies L3/L4#

Deny-all par défaut (meilleure pratique)#

La première policy à poser dans chaque namespace est un deny-all, qui bloque tout le trafic entrant et sortant par défaut. Ensuite on ajoute les exceptions nécessaires.

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny-all
  namespace: mon-app
spec:
  podSelector: {}   # Sélectionne tous les pods du namespace
  policyTypes:
    - Ingress
    - Egress

Autoriser les pods frontend vers les pods backend#

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-frontend-to-backend
  namespace: mon-app
spec:
  podSelector:
    matchLabels:
      app: backend
  ingress:
    - from:
        - podSelector:
            matchLabels:
              app: frontend
      ports:
        - protocol: TCP
          port: 8080

Cette policy s'applique aux pods backend et autorise le trafic entrant sur le port 8080, mais uniquement depuis les pods frontend du même namespace.

Autoriser l'accès DNS (obligatoire si deny-all)#

Avec un deny-all, les pods ne peuvent plus résoudre les noms DNS. Il faut explicitement autoriser le trafic vers kube-dns :

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-dns-egress
  namespace: mon-app
spec:
  podSelector: {}
  policyTypes:
    - Egress
  egress:
    - to:
        - namespaceSelector:
            matchLabels:
              kubernetes.io/metadata.name: kube-system
          podSelector:
            matchLabels:
              k8s-app: kube-dns
      ports:
        - protocol: UDP
          port: 53
        - protocol: TCP
          port: 53

Vérifier les policies avec Hubble#

C'est là que Cilium brille par rapport au CNI standard. Après avoir appliqué un deny-all, on peut observer en temps réel quels flux sont bloqués :

kubectl exec -n kube-system ds/cilium -- hubble observe \
  --namespace mon-app \
  --verdict DROPPED \
  --follow

Cette commande affiche en temps réel les connexions refusées, avec la source, la destination, le port, et la raison du blocage. Indispensable pour déboguer une NetworkPolicy mal configurée sans avoir à tâtonner.

CiliumNetworkPolicy : aller plus loin#

Cilium propose ses propres CRD en complément des NetworkPolicies standard Kubernetes. La CiliumNetworkPolicy permet des règles L7 que les NetworkPolicies standard ne supportent pas :

apiVersion: "cilium.io/v2"
kind: CiliumNetworkPolicy
metadata:
  name: allow-http-get-only
  namespace: mon-app
spec:
  endpointSelector:
    matchLabels:
      app: api
  ingress:
    - fromEndpoints:
        - matchLabels:
            app: frontend
      toPorts:
        - ports:
            - port: "8080"
              protocol: TCP
          rules:
            http:
              - method: GET    # Seul GET autorisé — POST sera bloqué
                path: "/api/.*"

Cette policy autorise uniquement les requêtes HTTP GET sur les paths /api/* depuis les pods frontend — le POST sera bloqué au niveau L7, même si la connexion TCP est établie.

Prochaines étapes#

Les NetworkPolicies L3/L4 standard constituent la base. Cilium permet d'aller beaucoup plus loin avec les policies basées sur les FQDN pour filtrer le trafic sortant vers internet — c'est le sujet d'un prochain article sur les egress policies et le DNS-aware filtering.

← Tous les articles