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