Aller au contenu principal

Chapitre 9.3 - Network Policies

Objectifs d'Apprentissage​

À la fin de ce chapitre, vous serez capable de:

  • Comprendre ce que sont les Network Policies
  • Créer des Network Policies pour isoler le trafic
  • Configurer les règles ingress et egress
  • Utiliser les selectors pour cibler les Pods
  • Implémenter la segmentation réseau
  • Comprendre les limitations

Introduction​

Les Network Policies permettent de contrôler le trafic réseau entre les Pods dans un cluster Kubernetes. Elles fournissent une segmentation réseau au niveau de l'application.

Qu'est-ce qu'une Network Policy?​

Une Network Policy définit des règles qui contrôlent le trafic réseau entre les Pods. Elle permet de:

  • Autoriser ou bloquer le trafic ingress (entrant)
  • Autoriser ou bloquer le trafic egress (sortant)
  • Filtrer par namespace, labels, ou IPs

Important: Les Network Policies nécessitent un CNI qui les supporte (Calico, Cilium, etc.).

Comportement par Défaut​

Sans Network Policy​

Par défaut: Tous les Pods peuvent communiquer avec tous les autres Pods.

Avec Network Policy​

Isolation: Seul le trafic autorisé est permis.

Exemple Basique​

Network Policy: Isoler un Namespace​

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: deny-all
  namespace: production
spec:
  podSelector: {}  # Tous les Pods
  policyTypes:
  - Ingress
  - Egress

Résultat: Aucun trafic ingress ou egress n'est autorisé dans le namespace production.

Network Policy: Autoriser le Trafic Interne​

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-internal
  namespace: production
spec:
  podSelector: {}
  policyTypes:
  - Ingress
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          name: production

Résultat: Seul le trafic depuis le namespace production est autorisé.

Selectors​

Pod Selector​

Cibler des Pods spécifiques:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: app-network-policy
spec:
  podSelector:
    matchLabels:
      app: web
      tier: frontend
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: api

Résultat: Les Pods avec app=web et tier=frontend peuvent recevoir du trafic seulement des Pods avec app=api.

Namespace Selector​

Cibler des namespaces:

spec:
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          name: frontend

IP Block​

Cibler des plages d'IPs:

spec:
  ingress:
  - from:
    - ipBlock:
        cidr: 192.168.1.0/24
        except:
        - 192.168.1.100/32

Exemple Complet: Application Multi-Tiers​

Architecture​

Network Policy: Frontend​

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: frontend-policy
  namespace: frontend
spec:
  podSelector:
    matchLabels:
      app: web
  policyTypes:
  - Ingress
  - Egress
  ingress:
  - from: []  # Autoriser depuis n'importe où (Internet via Ingress)
  egress:
  - to:
    - namespaceSelector:
        matchLabels:
          name: backend
    ports:
    - protocol: TCP
      port: 80

Network Policy: Backend​

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: backend-policy
  namespace: backend
spec:
  podSelector:
    matchLabels:
      app: api
  policyTypes:
  - Ingress
  - Egress
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          name: frontend
    ports:
    - protocol: TCP
      port: 8080
  egress:
  - to:
    - namespaceSelector:
        matchLabels:
          name: database
    ports:
    - protocol: TCP
      port: 5432

Network Policy: Database​

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: database-policy
  namespace: database
spec:
  podSelector:
    matchLabels:
      app: postgres
  policyTypes:
  - Ingress
  - Egress
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          name: backend
    ports:
    - protocol: TCP
      port: 5432
  egress: []  # Pas de trafic sortant autorisé

Ports et Protocoles​

Spécifier les Ports​

spec:
  ingress:
  - ports:
    - protocol: TCP
      port: 80
    - protocol: TCP
      port: 443
    - protocol: UDP
      port: 53

Port Range (selon CNI)​

Certains CNI supportent les plages de ports:

spec:
  ingress:
  - ports:
    - protocol: TCP
      port: 8000-8999

Commandes Utiles​

Gestion​

# Créer une Network Policy
kubectl apply -f network-policy.yaml

# Voir les Network Policies
kubectl get networkpolicies
kubectl get netpol

# Détails
kubectl describe networkpolicy frontend-policy

# Voir par namespace
kubectl get netpol -n production

Test​

# Tester la connectivité depuis un Pod
kubectl exec -it test-pod -- curl http://api-service:8080

# Voir les règles appliquées (selon CNI)
# Calico
calicoctl get networkpolicies

Limitations​

1. Support CNI​

Tous les CNI ne supportent pas les Network Policies:

  • Supportent: Calico, Cilium, Weave Net, Antrea
  • Ne supportent pas: Flannel (basique)

2. Performance​

Les Network Policies peuvent impacter les performances selon le CNI.

3. Complexité​

La gestion de nombreuses Network Policies peut devenir complexe.

Bonnes Pratiques​

1. Démarrage Progressif​

Commencer par isoler les namespaces critiques, puis étendre.

2. Documentation​

Documenter les règles de communication entre les services.

3. Tests​

Tester les Network Policies avant de les appliquer en production.

4. Monitoring​

Surveiller les connexions bloquées pour détecter les problèmes.

5. Default Deny​

Utiliser une politique "deny all" par défaut, puis autoriser explicitement.

Résumé​

Dans ce chapitre, vous avez appris:

Network Policy: Contrôle du trafic réseau entre Pods
Comportement par défaut: Tous les Pods peuvent communiquer
Selectors: Pod, namespace, IP block
Ingress/Egress: Règles pour trafic entrant et sortant
Ports: Spécifier les ports et protocoles autorisés
Cas d'usage: Segmentation réseau, isolation multi-tiers
Limitations: Nécessite un CNI compatible
Bonnes pratiques: Démarrage progressif, default deny, tests

Prochaines Étapes​

Chapitre 9.4: Pod Security Standards
Lab 9.3: Network Policies Avancées

Chapitre créé le: Décembre 2024