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.
Sommaire
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

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.