Netzwerkrichtlinien für Anwendungen konfigurieren

In dieser Anleitung wird gezeigt, wie Sie mithilfe von Netzwerkrichtlinien für Cluster steuern, welche Pods eingehenden Netzwerktraffic empfangen und welche Pods ausgehenden Traffic senden können. Weitere Informationen finden Sie unter Cluster-Netzwerkrichtlinien erstellen.

Mit Netzwerkrichtlinien können Sie Verbindungen zwischen Pods beschränken. Damit lässt sich der Kreis der manipulierbaren Komponenten eingrenzen und die Sicherheit erhöhen.

Mit Netzwerkrichtlinien werden lediglich die zulässigen Verbindungen festgelegt und keine anspruchsvolleren Features wie Autorisierung oder sichere Übertragung (z. B. SSL/TLS) bereitgestellt.

Ziele

In dieser Anleitung erhalten Sie Informationen zu folgenden Themen:

  • Cluster mit Durchsetzung von Netzwerkrichtlinien erstellen
  • Eingehenden Traffic mithilfe von Labels auf bestimmte Pods beschränken
  • Ausgehenden Traffic mithilfe von Labels auf bestimmte Pods beschränken

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen. Neuen Google Cloud-Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

Nach Abschluss der in diesem Dokument beschriebenen Aufgaben können Sie weitere Kosten vermeiden, indem Sie die erstellten Ressourcen löschen. Weitere Informationen finden Sie unter Bereinigen.

Hinweis

Gehen Sie folgendermaßen vor, um die Kubernetes Engine API zu aktivieren:
  1. Rufen Sie in der Google Cloud Console die Seite "Kubernetes Engine" auf.
  2. Erstellen Sie ein Projekt oder wählen Sie eines aus.
  3. Warten Sie, bis die API und die zugehörigen Dienste aktiviert worden sind. Dieser Vorgang kann einige Minuten dauern.

  4. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

Installieren Sie die folgenden Befehlszeilentools, die in dieser Anleitung verwendet werden:

  • Mit gcloud werden Kubernetes Engine-Cluster erstellt und gelöscht. gcloud ist in der gcloud CLI enthalten.
  • kubectl wird zur Verwaltung von Kubernetes verwendet, dem Cluster-Orchestrierungssystem von Kubernetes Engine. Sie können kubectl mit gcloud installieren: 
    gcloud components install kubectl

Klonen Sie den Beispielcode aus GitHub:

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
cd kubernetes-engine-samples/networking/network-policies

Standards für das gcloud-Befehlszeilentool festlegen

Wenn Sie die Projekt-ID und die Optionen für die Compute Engine-Zone nicht immer wieder neu in das gcloud-Befehlszeilentool eingeben möchten, können Sie die Standardwerte festlegen: 
gcloud config set project project-id
gcloud config set compute/zone compute-zone

GKE-Cluster mit Durchsetzung von Netzwerkrichtlinien erstellen

Führen Sie folgenden Befehl aus, um einen Containercluster mit Durchsetzung von Netzwerkrichtlinien zu erstellen:

gcloud container clusters create test --enable-network-policy

Eingehenden Traffic zu Pods beschränken

Mit Kubernetes-Ressourcen vom Typ NetworkPolicy können Sie Netzwerk-Zugriffsrichtlinien für die Pods konfigurieren. NetworkPolicy-Objekte enthalten die folgenden Informationen:

  • Pods, für die die Netzwerkrichtlinien gelten. Sie werden in der Regel durch einen Labelselektor gekennzeichnet.

  • Die Art des Traffics, auf den sich die Netzwerkrichtlinien auswirken: Ingress für eingehenden Traffic, Egress für ausgehenden Traffic oder beides.

  • Bei Ingress-Richtlinien die Pods, die mit den angegebenen Pods eine Verbindung herstellen können.

  • Bei Egress-Richtlinien die Pods, mit denen die angegebenen Pods eine Verbindung herstellen können.

Führen Sie zuerst eine Webserveranwendung mit dem Label app=hello aus und geben Sie sie intern im Cluster frei:

kubectl run hello-web --labels app=hello \
  --image=us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0 --port 8080 --expose

Konfigurieren Sie als Nächstes eine NetworkPolicy, um Traffic zu den hello-web-Pods ausschließlich von den app=foo-Pods zuzulassen. Anderer eingehender Traffic von Pods ohne dieses Label, externer Traffic und Traffic von Pods in anderen Namespaces werden blockiert.

Mit dem folgenden Manifest werden Pods mit dem Label app=hello ausgewählt und eine Ingress-Richtlinie angegeben, die nur Traffic von Pods mit dem Label app=foo zulässt:

kind: NetworkPolicy
apiVersion: networking.k8s.io/v1
metadata:
  name: hello-allow-from-foo
spec:
  policyTypes:
  - Ingress
  podSelector:
    matchLabels:
      app: hello
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: foo

Führen Sie folgenden Befehl aus, um diese Richtlinie auf den Cluster anzuwenden:

kubectl apply -f hello-allow-from-foo.yaml

Ingress-Richtlinie validieren

Führen Sie zuerst einen temporären Pod mit dem Label app=foo aus und rufen Sie im Pod eine Shell ab:

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

Stellen Sie eine Anfrage an den hello-web:8080-Endpunkt, um zu prüfen, ob der eingehende Datenverkehr zugelassen ist:

/ # wget -qO- --timeout=2 http://hello-web:8080
Hello, world!
Version: 1.0.0
Hostname: hello-web-2258067535-vbx6z
/ # exit

Zugriffe vom Pod app=foo an die app=hello-Pods ist aktiviert.

Führen Sie als Nächstes einen temporären Pod mit einem anderen Label (app=other) aus und rufen Sie im Pod eine Shell ab:

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

Senden Sie denselben Request, um zu bestätigen, dass der Traffic nicht zulässig ist und der Request daher eine Zeitüberschreitung auslöst. Beenden Sie dann die Pod-Shell:

/ # wget -qO- --timeout=2 http://hello-web:8080
wget: download timed out
/ # exit

Ausgehenden Traffic von den Pods beschränken

Sie können den ausgehenden Traffic (Egress-Traffic) genau wie den eingehenden Traffic beschränken.

Damit Sie jedoch interne Hostnamen wie hello-web oder externe Hostnamen wie www.example.com abfragen können, müssen Sie die DNS-Auflösung (Domain Name System) in den Netzwerkrichtlinien für ausgehenden Datenverkehr zulassen. Der DNS-Traffic wird über Port 53 mit den TCP- und UDP-Protokollen weitergeleitet.

Stellen Sie für Egress-Netzwerkrichtlinien eine NetworkPolicy bereit, die den ausgehenden Traffic von Pods mit dem Label app=foo steuert und gleichzeitig Traffic nur an Pods mit dem Label app=hello sowie den DNS-Traffic zulässt.

Das folgende Manifest gibt eine Netzwerkrichtlinie an, die den ausgehenden Traffic von Pods mit dem Label app=foo mit zwei zulässigen Zielen steuert:

  1. Pods im selben Namespace mit dem Label app=hello.
  2. Cluster-Pods oder externe Endpunkte an Port 53 (UDP und TCP).
kind: NetworkPolicy
apiVersion: networking.k8s.io/v1
metadata:
  name: foo-allow-to-hello
spec:
  policyTypes:
  - Egress
  podSelector:
    matchLabels:
      app: foo
  egress:
  - to:
    - podSelector:
        matchLabels:
          app: hello
  - ports:
    - port: 53
      protocol: TCP
    - port: 53
      protocol: UDP

Führen Sie folgenden Befehl aus, um diese Richtlinie auf den Cluster anzuwenden:

kubectl apply -f foo-allow-to-hello.yaml

Egress-Richtlinie validieren

Stellen Sie zuerst eine neue Webanwendung namens hello-web-2 bereit und geben Sie sie intern im Cluster frei:

kubectl run hello-web-2 --labels app=hello-2 \
  --image=us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0 --port 8080 --expose

Führen Sie als Nächstes einen temporären Pod mit dem Label app=foo aus und öffnen Sie eine Shell im Container:

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

Prüfen Sie, ob der Pod Verbindungen zu hello-web:8080 herstellen kann:

/ # wget -qO- --timeout=2 http://hello-web:8080
Hello, world!
Version: 1.0.0
Hostname: hello-web-2258067535-vbx6z

Bestätigen Sie, dass der Pod keine Verbindung zu hello-web-2:8080 herstellen kann:

/ # wget -qO- --timeout=2 http://hello-web-2:8080
wget: download timed out

Bestätigen Sie, dass der Pod keine Verbindung zu externen Websites wie www.example.com herstellen kann und verlassen Sie die Pod-Shell.

/ # wget -qO- --timeout=2 http://www.example.com
wget: download timed out
/ # exit

Bereinigen

Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, löschen Sie entweder das Projekt, das die Ressourcen enthält, oder Sie behalten das Projekt und löschen die einzelnen Ressourcen.

  1. Containercluster löschen: Mit diesem Schritt werden alle Ressourcen gelöscht, die den Containercluster ausmachen, also Compute-Instanzen, Datenträger und Netzwerkressourcen.

    gcloud container clusters delete test

Weitere Informationen