lumikha

4 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 disponible comme dataplane réseau géré par Microsoft (Azure CNI Powered by Cilium, GA depuis mai 2023), 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#

Sur AKS, Cilium s'utilise soit en mode géré (Azure CNI Powered by Cilium, ici avec Azure CNI Overlay), soit installé soi-même sur un cluster en mode « Bring your own CNI », que Microsoft ne prend alors pas en charge. 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_data_plane  = "cilium" # provider azurerm >= 3.108 (avant : ebpf_data_plane)
    network_policy      = "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.

Sur le Cilium géré par AKS, Hubble n'est pas activé par défaut : il est fourni par la fonctionnalité Advanced Network Observability, en préversion depuis mai 2024 (extension aks-preview requise, Kubernetes 1.29 minimum).

# Activer Advanced Network Observability (Hubble) sur un cluster AKS existant
az extension add --name aks-preview
az aks update \
  --resource-group mon-rg \
  --name mon-cluster \
  --enable-advanced-network-observability

Pour accéder à l'UI Hubble localement (elle n'est pas installée par défaut : il faut d'abord la déployer, comme décrit dans la documentation AKS) :

# 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

Schéma du namespace mon-app sous default-deny-all : les pods frontend peuvent joindre les pods backend en TCP 8080 (allow-frontend-to-backend), tous les pods peuvent joindre kube-dns dans kube-system en UDP/TCP 53 (allow-dns-egress), et le trafic du backend vers Internet est bloqué ; Cilium applique ces règles sur chaque node et Hubble montre les verdicts FORWARDED / DROPPED

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.

Attention : sur le Cilium géré par AKS (Azure CNI Powered by Cilium), les policies L7 et les policies FQDN ne sont pas prises en charge à ce jour ; seules les CiliumNetworkPolicies L3/L4 le sont. Cet exemple suppose un Cilium installé soi-même (mode « Bring your own CNI »).

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