Les Network Policies : Règles de sécurité pour contrôler le trafic réseau entre les pods

Les Network Policies sont des objets Kubernetes qui permettent de définir des règles de sécurité pour contrôler le trafic réseau entre les pods. Ils sont utilisés pour définir les politiques de sécurité réseau au niveau du namespace et permettent de spécifier quel trafic est autorisé ou refusé entre les pods.

Pour tester les NetworkPolicy, vous devez d'abord déployer les applications correspondantes (par exemple, web-app, nginx, frontend, backend, et database).

 

Exemple 1 : Autoriser tout le trafic dans un namespace (politique de réseau ouvert) :

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-all-policy
namespace: dev
spec:
  podSelector: {}  # Sélectionne tous les pods de l'espace de noms
  policyTypes:
  - Ingress         # Autorise le trafic entrant (des autres pods)
  - Egress          # Autorise le trafic sortant (vers d'autres pods)

 

Dans cet exemple, la Network Policy allow-all-policy spécifie que tous les pods du namesapce dev associé sont autorisés à communiquer les uns avec les autres, que ce soit en entrée ou en sortie.

Exemple 2 : Autoriser uniquement un certain type de trafic entrant :

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-http-policy
spec:
  podSelector: {}  # Sélectionne tous les pods de l'espace de noms
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: web     # Autorise le trafic entrant depuis les pods avec l'étiquette "app: web"
  policyTypes:
  - Ingress

Dans cet exemple, la Network Policy allow-http-policy spécifie que tous les pods du namespace sont autorisés à recevoir du trafic entrant uniquement des pods qui ont l'étiquette "app: web".

Exemple 3 : Autoriser le trafic sortant uniquement vers un service spécifique :

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-outgoing-db-policy
spec:
  podSelector: {}  # Sélectionne tous les pods de l'espace de noms
  egress:
  - to:
    - podSelector:
        matchLabels:
          app: database    # Autorise le trafic sortant vers les pods avec l'étiquette "app: database"
  policyTypes:
  - Egress

Dans cet exemple, la Network Policy allow-outgoing-db-policy spécifie que tous les pods du namespace sont autorisés à envoyer du trafic sortant uniquement vers les pods qui ont l'étiquette "app: database".

 

Restriction avec des règles plus strictes

• frontend: Le service frontend est la seule autorisée à envoyé du flux sur le web-app sur le port 80
• web-app: Le service web-app autorise en entrée que le flux venant de frontend sur le port 80 et ne peut envoyer du flux que vers le backend sur le port 5678
• backend: Le service backend autorise en entrée que le flux venant de web-app sur le port 5678 et ne peut envoyer du flux que vers le database sur le port 5432
• database: Le service database autorise en entrée que le flux venant de backend sur ke port 5432

• Frontend.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: frontend
  labels:
    app: frontend
spec:
  replicas: 1
  selector:
    matchLabels:
      app: frontend
  template:
    metadata:
      labels:
        app: frontend
    spec:
      containers:
        - name: frontend
          image: nginx:alpine
          ports:
            - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: frontend
  labels:
    app: frontend
spec:
  selector:
    app: frontend
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  type: ClusterIP

---

# Seul le pod frontend peut acceder qu'au pod web-app sur le port 80.
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-frontend-to-webapp
  namespace: default
spec:
  podSelector:
    matchLabels:
      app: web-app      
  egress: # frontend peut appeler que le web-app sur le port 80
    - to:
        - podSelector:
            matchLabels:
              app: web-app
      ports:
        - protocol: TCP
          port: 80
    - to: # Permettre les requêtes DNS
        - namespaceSelector: {}
          podSelector:
            matchLabels:
              k8s-app: kube-dns
      ports:
        - protocol: UDP
          port: 53
  policyTypes:
    - Egress

 

• Webb-app.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
  labels:
    app: web-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: web-app
  template:
    metadata:
      labels:
        app: web-app
    spec:
      containers:
        - name: web-app
          image: nginx:alpine
          ports:
            - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: web-app
  labels:
    app: web-app
spec:
  selector:
    app: web-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  type: ClusterIP

---

# Seul le pod frontend peut accéder au pod web-app sur le port 80.
# Le service web-app peut accéder uniquement au service backend sur le port 8080.
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-webapp-to-backend
  namespace: default
spec:
  podSelector:
    matchLabels:
      app: web-app
  ingress:
    - from:
        - podSelector:
            matchLabels:
              app: frontend
      ports:
        - protocol: TCP
          port: 80          
  egress:
    - to:
        - podSelector:
            matchLabels:
              app: backend
      ports:
        - protocol: TCP
          port: 5678
    - to: # Permettre les requêtes DNS
        - namespaceSelector: {}
          podSelector:
            matchLabels:
              k8s-app: kube-dns
      ports:
        - protocol: UDP
          port: 53
  policyTypes:
    - Ingress
    - Egress

 

• backend.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: backend
  labels:
    app: backend
spec:
  replicas: 1
  selector:
    matchLabels:
      app: backend
  template:
    metadata:
      labels:
        app: backend
    spec:
      containers:
        - name: backend
          image: hashicorp/http-echo
          args:
            - "-text=Hello from Backend. Bye !!!"
          ports:
            - containerPort: 5678
---
apiVersion: v1
kind: Service
metadata:
  name: backend
  labels:
    app: backend
spec:
  selector:
    app: backend
  ports:
    - protocol: TCP
      port: 5678
      targetPort: 5678
  type: ClusterIP

---

# Seul le service web-app peut accéder au service backend sur le port 8080.
# Le service backend peut accéder uniquement au service database sur le port 5432.
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-only-webapp-to-backend
  namespace: default
spec:
  podSelector:
    matchLabels:
      app: backend
  ingress:
    - from:
        - podSelector:
            matchLabels:
              app: web-app
      ports:
        - protocol: TCP
          port: 5678      
  egress:
    - to:
        - podSelector:
            matchLabels:
              app: database
      ports:
        - protocol: TCP
          port: 5432
    - to: # Permettre les requêtes DNS
        - namespaceSelector: {}
          podSelector:
            matchLabels:
              k8s-app: kube-dns
      ports:
        - protocol: UDP
          port: 53
  policyTypes:
    - Ingress
    - Egress

 

• database.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: database
  labels:
    app: database
spec:
  replicas: 1
  selector:
    matchLabels:
      app: database
  template:
    metadata:
      labels:
        app: database
    spec:
      containers:
        - name: database
          image: postgres:alpine
          env:
            - name: POSTGRES_USER
              value: user
            - name: POSTGRES_PASSWORD
              value: password
            - name: POSTGRES_DB
              value: example
          ports:
            - containerPort: 5432
---
apiVersion: v1
kind: Service
metadata:
  name: database
  labels:
    app: database
spec:
  selector:
    app: database
  ports:
    - protocol: TCP
      port: 5432
      targetPort: 5432
  type: ClusterIP


---

# Le pod database accepte uniquement le trafic provenant de backend.
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: restrict-database-access
  namespace: default
spec:
  podSelector:
    matchLabels:
      app: database
  ingress:
    - from:
        - podSelector:
            matchLabels:
              app: backend
      ports:
        - protocol: TCP
          port: 5432
  policyTypes:
    - Ingress

 

• Appliquer les YAML :

kubectl apply -f frontend.yaml
kubectl apply -f web-app.yaml
kubectl apply -f backend.yaml
kubectl apply -f database.yaml

 

 

Tester le trafic :

• Depuis le service frontend faire un curl vers le service web-app: curl web-app:80

kubectl exec -it svc/frontend -- sh

curl web-app:80 # doit marcher
curl backend:5678 # doit pas marcher car frontend est autorisé uniquement sur le service web-app

 

• Depuis le service web-app faire un curl vers le service backend: curl backend:5678

kubectl exec -it svc/web-app -- sh

curl backend:5678 # doit marcher
curl frontend:80 # doit pas marcher car web-app est autorisé uniquement sur le service backend