lumikha

4 min de lecture

Cilium NetworkPolicies avancées : Egress et DNS-aware policies sur AKS

Filtrer le trafic sortant par FQDN avec toFQDN, DNS egress filtering Cilium, et couper l'accès internet sélectivement sur AKS.

Les NetworkPolicies standard Kubernetes permettent de filtrer le trafic par IP ou CIDR. Mais en pratique, les IPs des services externes changent (CDN, APIs tierces, Azure PaaS) — il est beaucoup plus fiable de filtrer par nom de domaine. Cilium rend ça possible avec ses toFQDN policies.

Cet article fait suite à Cilium sur AKS : installation et premiers NetworkPolicies eBPF, il suppose Cilium installé et opérationnel.

Sur le Cilium géré par AKS (Azure CNI Powered by Cilium), les policies toFQDNs ne fonctionnent qu'avec Advanced Container Networking Services (ACNS), généralement disponible depuis novembre 2024 : option payante, Kubernetes 1.29 minimum, activée avec az aks update --enable-acns (le filtrage FQDN est alors actif par défaut). Côté AKS, la résolution DNS des pods soumis à une policy FQDN passe par l'agent de sécurité ACNS, qui transmet les correspondances FQDN → IP à Cilium.

Pourquoi les IPs ne suffisent pas pour l'egress#

Les services Azure PaaS (Storage, Key Vault, Service Bus) ont des plages d'IPs qui changent et sont documentées dans des JSON publiés par Microsoft. Maintenir ces CIDRs à la main dans des NetworkPolicies est ingérable.

Les APIs tierces (GitHub, Stripe, Datadog) utilisent des CDN dont les IPs varient. Une policy basée sur des IPs sera rapidement obsolète et bloquera des connexions légitimes.

La solution : filtrer par FQDN (nom de domaine), laisser Cilium résoudre dynamiquement les IPs correspondantes et maintenir ses tables à jour.

Architecture du DNS filtering avec Cilium#

Cilium intercepte les réponses DNS au niveau du node (via eBPF) et maintient une table de correspondance FQDN → IPs. Quand une CiliumNetworkPolicy toFQDN est définie, Cilium :

  1. Observe les requêtes DNS des pods concernés
  2. Pour les domaines autorisés, autorise dynamiquement les IPs résolues dans ses tables eBPF
  3. Bloque automatiquement tout trafic vers des IPs non autorisées par les policies

Ce mécanisme est transparent pour les pods — ils font leurs requêtes DNS normalement.

Diagramme de séquence du filtrage FQDN : la requête DNS du pod mon-worker est interceptée par l'agent Cilium et envoyée au proxy DNS (agent ACNS sur AKS), qui vérifie que le nom est autorisé, le fait résoudre par kube-dns, ajoute la correspondance FQDN vers IP à la policy eBPF et renvoie la réponse au pod ; la connexion TCP 443 vers l'IP résolue est autorisée, une connexion vers une IP jamais résolue (1.2.3.4) est rejetée (DROPPED). Rappel : egressDeny prime sur toFQDNs

Deny-all egress par défaut#

Avant de définir des allowlists, mettre l'egress en refus par défaut. Avec Cilium, dès qu'une policy comportant une section egress sélectionne un pod, tout le trafic sortant qui n'est pas explicitement autorisé est refusé :

apiVersion: "cilium.io/v2"
kind: CiliumNetworkPolicy
metadata:
  name: default-deny-egress
  namespace: mon-app
spec:
  endpointSelector: {}   # Tous les pods du namespace
  egress:
    - toEntities:
        - "cluster"        # Seul le trafic interne au cluster est autorisé : "world" (internet) est refusé par défaut

Après cette policy, aucun pod du namespace ne peut accéder à internet. On ajoute ensuite les exceptions.

Piège : ne pas écrire ce deny-all avec egressDeny vers world. Chez Cilium, une règle deny l'emporte toujours sur une règle allow, y compris sur les toFQDNs : les exceptions ci-dessous seraient bloquées elles aussi.

Policy toFQDN : autoriser des domaines spécifiques#

Accès à Azure Storage#

apiVersion: "cilium.io/v2"
kind: CiliumNetworkPolicy
metadata:
  name: allow-storage-egress
  namespace: mon-app
spec:
  endpointSelector:
    matchLabels:
      app: mon-worker
  egress:
    - toFQDNs:
        - matchName: "monstorageaccount.blob.core.windows.net"
      toPorts:
        - ports:
            - port: "443"
              protocol: TCP
    - toFQDNs:
        - matchPattern: "*.blob.core.windows.net"   # Wildcard pour tous les storage
      toPorts:
        - ports:
            - port: "443"
              protocol: TCP

matchName pour un FQDN exact, matchPattern pour un wildcard. Les wildcards ne supportent qu'un seul niveau (pas **.azure.com).

Accès à plusieurs APIs externes#

apiVersion: "cilium.io/v2"
kind: CiliumNetworkPolicy
metadata:
  name: allow-external-apis
  namespace: mon-app
spec:
  endpointSelector:
    matchLabels:
      app: api-gateway
  egress:
    - toFQDNs:
        - matchName: "api.stripe.com"
        - matchName: "api.sendgrid.com"
        - matchPattern: "*.datadog.com"
      toPorts:
        - ports:
            - port: "443"
              protocol: TCP

Autoriser le DNS (obligatoire)#

Pour que les toFQDN policies fonctionnent, les pods doivent pouvoir faire des requêtes DNS. Il faut une policy egress explicite vers kube-dns :

apiVersion: "cilium.io/v2"
kind: CiliumNetworkPolicy
metadata:
  name: allow-dns-egress
  namespace: mon-app
spec:
  endpointSelector: {}
  egress:
    - toEndpoints:
        - matchLabels:
            k8s:io.kubernetes.pod.namespace: kube-system
            k8s:k8s-app: kube-dns
      toPorts:
        - ports:
            - port: "53"
              protocol: UDP
            - port: "53"
              protocol: TCP
          rules:
            dns:
              - matchPattern: "*"    # Toutes les requêtes DNS sont observées

Le bloc rules.dns est important : il indique à Cilium d'inspecter les réponses DNS pour alimenter ses tables FQDN → IP.

Vérifier les policies avec Hubble#

Hubble permet de confirmer quels flux sont autorisés et bloqués après l'application des policies :

# Voir les flux egress bloqués
kubectl exec -n kube-system ds/cilium -- hubble observe \
  --namespace mon-app \
  --verdict DROPPED \
  --type policy-verdict \
  --follow

# Voir les flux egress autorisés
kubectl exec -n kube-system ds/cilium -- hubble observe \
  --namespace mon-app \
  --verdict FORWARDED \
  --follow

Inspecter les tables FQDN de Cilium#

Pour voir quelles IPs Cilium a résolu pour un FQDN donné :

kubectl exec -n kube-system ds/cilium -- cilium fqdn cache list

Cette commande liste tous les enregistrements DNS cachés par Cilium, avec les IPs associées et leur TTL. Utile pour diagnostiquer pourquoi une connexion est bloquée alors que le FQDN est dans la allowlist (l'IP n'est peut-être pas encore dans le cache).

Limitation : les wildcards multi-niveaux#

Cilium ne supporte pas les wildcards multi-niveaux type **.azure.com. Si un service Azure utilise plusieurs niveaux de sous-domaines, il faut lister explicitement les patterns ou accepter un wildcard *.azure.com qui sera plus large.

Pour les Private Endpoints Azure, qui résolvent via des zones privatelink.*, la policy egress n'est souvent pas nécessaire puisque le trafic reste dans le VNet et ne sort pas vers "world". La policy toFQDN cible surtout le trafic qui sort réellement vers internet.

Impact sur les performances#

Le DNS filtering Cilium a un overhead minimal grâce à eBPF : les décisions d'autorisation/refus sont prises dans le kernel, sans passer par l'espace utilisateur. En pratique, l'impact est inférieur à la latence DNS elle-même.

La table FQDN est maintenue en mémoire par Cilium sur chaque node. Sur des clusters avec un grand nombre de pods et de policies FQDN, surveiller la consommation mémoire de Cilium (typiquement < 100 MB).

← Tous les articles