Netzwerkrichtlinie konfigurieren

Auf dieser Seite wird gezeigt, wie Sie mithilfe von Netzwerkrichtlinien für Cluster steuern, ob ein Pod eingehenden (bzw. Ingress-) Netzwerktraffic empfangen kann und ob er ausgehenden (bzw. Egress-) Traffic senden kann.

Mit Netzwerkrichtlinien können Sie Verbindungen zwischen Pod-Objekten beschränken, um die Anfälligkeit für Angriffe zu reduzieren.

Netzwerkrichtlinien dienen als Firewall auf Ebene 3 oder Ebene 4 des OSI-Modells. Sie bieten keine zusätzlichen Funktionen wie Autorisierung oder Verschlüsselung.

Eingehenden Traffic zu Pod-Objekten beschränken

Mit einem NetworkPolicy-Objekt können Sie Netzwerkzugriffsrichtlinien für einen Pod konfigurieren. NetworkPolicy-Objekte enthalten die folgenden Informationen:

  • Pod-Objekte, für die die Richtlinie gilt. Pod-Objekte und -Arbeitslasten werden mit Labels und Selektoren definiert.

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

  • Bei Ingress-Richtlinien die Pod-Objekte, die eine Verbindung zu den angegebenen Pod-Objekten herstellen können.

  • Bei Egress-Richtlinien die Pod-Objekte, zu denen die angegebenen Pod-Objekte eine Verbindung herstellen können

Beispiel für eine Beschränkung des eingehenden Traffics

In diesem Abschnitt wird das Erstellen einer Beschränkung für eingehenden Traffic für eine Beispielanwendung gezeigt. Ändern Sie dieses Beispiel entsprechend Ihrer eigenen Anwendungsumgebung.

  1. Führen Sie 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

  2. Konfigurieren Sie eine NetworkPolicy, um Traffic zum Pod hello-web nur von den Pod-Objekten app=foo zuzulassen. GKE on AWS blockiert eingehenden Traffic von Pod-Objekten, die dieses Label nicht haben, sowie externen Traffic und Traffic von Pod-Objekten in einem anderen Namespace.

    Mit dem folgenden Manifest werden Pod-Objekte mit dem Label app=hello ausgewählt und eine Ingress-Richtlinie angegeben, die nur Traffic von Pod-Objekten 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

  3. Wenden Sie diese Richtlinie auf den Cluster an:

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

Ingress-Richtlinie prüfen

  1. Führen Sie einen temporären Pod mit dem Label app=foo aus. Senden Sie eine Anfrage an den Endpunkt hello-web:8080, um zu prüfen, ob der eingehende Traffic zulässig ist:

    kubectl run -l app=foo --image=alpine --restart=Never --rm -i -t foo-app \
    -- wget -qO- --timeout=2 http://hello-web:8080

    Wenn Traffic vom Pod app=foo zu den Pod-Objekten app=hello aktiviert ist, sieht die Ausgabe so aus:

    Hello, world!
Version: 1.0.0
Hostname: hello-web-2258067535-vbx6z

  2. Führen Sie einen temporären Pod mit einem anderen Label (app=other) aus und stellen Sie dieselbe Anfrage, um zu bestätigen, dass der Traffic nicht zulässig ist:

    kubectl run -l app=other --image=alpine --restart=Never --rm -i -t other-app \
    -- wget -qO- --timeout=2 http://hello-web:8080

    Die Ausgabe bestätigt, dass die Verbindung keine Antwort empfängt:

    wget: download timed out

Ausgehenden Traffic von Pod-Objekten einschränken

Sie können den ausgehenden Traffic genau wie den eingehenden Traffic beschränken.

Zum Abfragen interner Hostnamen wie hello-web oder externer Hostnamen wie www.example.com müssen Sie jedoch eine Egress-Richtlinie erstellen, die DNS-Traffic an Port 53 mit TCP- und UDP-Protokollen zulässt.

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

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

  1. Pod-Objekte im selben Namespace mit dem Label app=hello
  2. Interne 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

Wenden Sie diese Richtlinie auf den Cluster an:

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

Egress-Richtlinie validieren

  1. Stellen Sie 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

  2. Führen Sie einen temporären Pod mit dem Label app=foo aus und prüfen Sie, ob der Pod Verbindungen zu hello-web:8080 herstellen kann:

    kubectl run -l app=foo --image=alpine --rm -i -t --restart=Never foo-app \
  -- wget -qO- --timeout=2 http://hello-web:8080

    Der Pod antwortet auf die Anfrage:

    Hello, world!
Version: 1.0.0
Hostname: hello-web-2258067535-vbx6z

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

    kubectl run -l app=foo --image=alpine --rm -i -t --restart=Never foo-app \
    -- wget -qO- --timeout=2 http://hello-web-2:8080

    Die Ausgabe bestätigt, dass die Verbindung keine Antwort empfängt:

    wget: download timed out

  4. Bestätigen Sie, dass der Pod keine Verbindungen zu externen Websites wie www.example.com herstellen kann.

    kubectl run -l app=foo --image=alpine --rm -i -t --restart=Never foo-app \
    -- wget -qO- --timeout=2 http://www.example.com

    Die Ausgabe bestätigt, dass die Verbindung keine Antwort empfängt:

    wget: download timed out

Bereinigen

Führen Sie die folgenden Befehle aus, um die in dieser Anleitung erstellten Ressourcen zu entfernen:

kubectl delete pods --labels app=hello-2
kubectl delete pods --labels app=hello
kubectl delete -f foo-allow-to-hello.yaml
kubectl delete -f hello-allow-from-foo.yaml

Nächste Schritte