Network Policies in Kubernetes

Standardmäßig akzeptieren die Pods Traffic von jeder Quelle. Eine Netzwerkrichtlinie hilft dabei, festzulegen, wie eine Gruppe von Pods miteinander und mit anderen Netzwerk-Endpunkten kommunizieren kann. NetworkPolicy verwendet Labels, um Pods auszuwählen und Regeln zu definieren, die angeben, welcher Verkehr zu den ausgewählten Pods zulässig ist. Sobald eine NetworkPolicy auf einen bestimmten Pod angewendet wird, lehnt dieser Pod Verbindungen ab, die der NetworkPolicy nicht erlaubt sind. Die Pods, die von keiner NetworkPolicy ausgewählt werden, akzeptieren weiterhin den gesamten Verkehr.

Um mehr über NetworkPolicy im Detail zu erfahren, besuchen Sie die offizielle Seite von Kubernetes hier.

In diesem Artikel sehen wir die Verwendung von Ingress und Egress NetworkPolicy, wobei Ingress der eingehende Datenverkehr zum Pod und Egress der ausgehende Datenverkehr vom Pod ist.

Vorraussetzungen

  1. Kubernetes Cluster mit mindestens 1 Worker-Knoten.
    Wenn Sie lernen möchten, wie man einen Kubernetes-Cluster erstellt, klicken Sie hier. Dieses Handbuch hilft Ihnen bei der Erstellung eines Kubernetes-Clusters mit 1 Master- und 2 Worker-Knoten auf AWS Ubuntu 18.04 EC2-Instanzen.

Was werden wir tun?

  1. Netzwerk-Richtlinien erstellen

Netzwerkrichtlinien erstellen

Netzwerk-Politik einführen

Erstellen Sie einen Hallo-Web-Pod mit der Aufschrift „app-destination-pod“ und einem Dienst, auf dem wir eingehenden Verkehr auf Port 8080 zulassen werden.

kubectl run hello-web --labels app=destination-pod --image=gcr.io/google-samples/hello-app:1.0 --port 8080 --
kubectl get pod | grep hello-web
kubectl get service | grep hello-web

creat-a-pod-and-a-service

Erstellen Sie eine Ingress-Definitionsdatei mit dem folgenden Inhalt, die den Verkehr auf dem „hello-web“-Pod mit der Bezeichnung „app=destination-pod“ auf Port 8080 von dem Pod mit der Bezeichnung „app=source-pod“ erlaubt.

vim ingress.yml
kind: NetworkPolicy
apiVersion: networking.k8s.io/v1
metadata:
  name: destination-pod-allow-from-source-pod
spec:
  policyTypes:
  - Ingress
  podSelector:
    matchLabels:
      app: destination-pod
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: source-pod

ingress-netzwerk-politik-definition

Bevor wir eine Ingress-Policy erstellen, erstellen Sie einen Pod mit dem Label „app=unknown“, der nicht der Regel der Policy entspricht.

kubectl run -l app=unknown --image=alpine --restart=Never --rm -i -t test-1

Wenn wir nun versuchen, von dieser Kapsel aus auf unsere „Hallo-Netz“-Kapsel an Port 8080 zuzugreifen, wird die Kapsel zugänglich sein.

wget -qO- --timeout=2 http://hello-web:8080

schaffe-einen-unbekannten-Pod

Erstellen Sie nun eine Richtlinie, die eine Verbindung auf dem Pod mit der Bezeichnung „app=destination-pod“ von dem Pod mit der Bezeichnung „app=source-pod“ erlaubt, und holen Sie Einzelheiten dazu ein.

kubectl apply -f ingress.yml
kubectl get networkpolicy destination-pod-allow-from-source-pod

schaffe-ingress-netzwerk-politik

Erstellen Sie nun erneut einen Pod mit einem Label, das nicht mit der in der Richtlinie definierten Regel übereinstimmt.

kubectl run -l app=unknown --image=alpine --restart=Never --rm -i -t test-1

Wenn wir erneut versuchen, von diesem Pod aus auf den „Hallo-Netz“-Pod zuzugreifen, wird der „Hallo-Netz“-Pod nicht erreichbar sein.

wget -qO- --timeout=2 http://hello-web:8080

versucht-von-unbekannt-zu-erreichen

Dieses Mal erstellen wir einen Pod, der der Netzwerkrichtlinienregel entspricht, d.h. einen Pod mit der Bezeichnung „app=source-app“.

kubectl run -l app=source-pod --image=alpine --restart=Never --rm -i -t test-1

Wenn wir nun versuchen, von dem Pod mit der Bezeichnung „app=source-pod“ auf den „hello-web“-Pod zuzugreifen, kann auf das „hello-web“ zugegriffen werden.

wget -qO- --timeout=2 http://hello-web:8080

versucht-zu-zugreifen-von-known-pod

Auf dem obigen Screenshot sehen Sie, dass der „hello-web“-Pod vom Pod mit der Bezeichnung „app=source-pod“ aus zugänglich war. Das bedeutet, dass wir die Verbindungen auf unserem „hello-web“ eingeschränkt haben und nur Pods mit der Bezeichnung „app=source-pod“ darauf zugreifen können.

Egress Netzwerk-Politik

Erstellen Sie eine neue Datei für die Egress Network Policy mit folgendem Inhalt.

vim egress.yml
kind: NetworkPolicy
apiVersion: networking.k8s.io/v1
metadata:
  name: source-pod-allow-to-destination-pod
spec:
  policyTypes:
  - Egress
  podSelector:
    matchLabels:
      app: source-pod
  egress:
  - to:
    - podSelector:
        matchLabels:
          app: destination-pod
  - ports:
    - port: 53
      protocol: TCP
    - port: 53
      protocol: UDP

egress-netzwerk-politik-definition

Die obige Richtlinie erlaubt ausgehende Verbindungen vom Pod mit der Bezeichnung „app=source-pod“ zum Pod mit der Bezeichnung „app=destination-pod“ und auch auf Port 53 für die DNS-Auflösung.

Bevor wir die Egress-Policy im Cluster anwenden, erstellen Sie einen Pod „hello-web-2“ und einen Dienst, der nicht unserer Policy entspricht.

kubectl run hello-web-2 --labels app=hello-2 --image=gcr.io/google-samples/hello-app:1.0 --port 8080 --expose
kubectl get pod | grep hello-web-2
kubectl get service | grep hello-web-2

Anwendung erstellen - unbekannt -

Erstellen Sie nun einen Pod mit der Bezeichnung „app=source-pod“.

kubectl run -l app=source-pod --image=alpine --restart=Never --rm -i -t test-2

Bevor wir die Egress-Politik anwenden, können die beiden Apps „hello-web“ und „hello-web-2“ vom Pod mit der Bezeichnung „app=source-pod“ aufgerufen werden

wget -qO- --timeout=2 http://hello-web:8080
wget -qO- --timeout=2 http://hello-web-2:8080

Zugang zu unbekannter Anwendung - verfügbar

Erstellen Sie jetzt eine Netzwerk-Richtlinie mit Ausstiegsregel.

kubectl create -f egress.yml
kubectl get networkpolicy | grep source-pod-allow-to-destination-pod

schaffe-egress-netzwerk-politik

Lassen Sie uns einen Pod mit der Bezeichnung „app=source-pod“ erstellen und versuchen, sowohl auf den Pod „app=source-pod“ zuzugreifen

kubectl run -l app=source-pod --image=alpine --restart=Never --rm -i -t test-3

wget -qO- –timeout=2 http://hello-web:8080

wget -qO- --timeout=2 http://hello-web-2:8080

Zugang zu unbekannter Anwendung - nicht verfügbar

Im obigen Screenshot können Sie beobachten, dass der Pod „hello-web-2“ diesmal nicht erreichbar war, da er nicht der Egress-Policy entspricht, die eine Verbindung von einem Pod mit der Bezeichnung „app=source-pod“ zum Pod mit der Bezeichnung „app=destination-pod“ erlaubt.

Schlussfolgerung

In diesem Artikel sahen wir die Schritte zur Schaffung einer Netzwerkpolitik für Ein- und Ausgänge. Wir sahen auch, wie die ein- und ausgehende Verbindung mit Hilfe von Ingress bzw. Egress eingeschränkt werden kann, und um dies besser zu verstehen, sahen wir ihre Umsetzung mit Hilfe einer einfachen Webanwendung.

Das könnte dich auch interessieren …