Hilf mit, diese Seite zu verbessern

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Wenn Sie zu diesem Benutzerhandbuch beitragen möchten, wählen Sie den GitHub Link Diese Seite bearbeiten auf, der sich im rechten Bereich jeder Seite befindet.

Kubernetes-Netzwerkrichtlinien für Hybridknoten konfigurieren

AWS unterstützt Kubernetes-Netzwerkrichtlinien (Layer 3/Layer 4) für Pod-Eingangs- und Ausgangsverkehr, wenn Cilium als CNI mit EKS-Hybridknoten verwendet wird. Wenn Sie EKS-Cluster mit Knoten in der AWS Cloud ausführen, AWS unterstützt Amazon VPC CNI for Kubernetes Network Policies.

Dieses Thema behandelt die Konfiguration von Cilium- und Kubernetes-Netzwerkrichtlinien mit EKS-Hybridknoten. Ausführliche Informationen zu Kubernetes-Netzwerkrichtlinien finden Sie unter Kubernetes-Netzwerkrichtlinien in der Kubernetes-Dokumentation.

Netzwerkrichtlinien konfigurieren

Überlegungen

AWS unterstützt die Upstream-Kubernetes-Netzwerkrichtlinien und die Spezifikation für Pod-Ingress und -Egress. AWS unterstützt derzeit nicht oder. CiliumNetworkPolicy CiliumClusterwideNetworkPolicy
Der policyEnforcementMode Helm-Wert kann verwendet werden, um das Standardverhalten bei der Durchsetzung von Cilium-Richtlinien zu steuern. Das Standardverhalten lässt den gesamten ausgehenden und eingehenden Verkehr zu. Wenn ein Endpunkt durch eine Netzwerkrichtlinie ausgewählt wird, wechselt er in den Status „Standardverweigerung“, in dem nur explizit zugelassener Datenverkehr zugelassen ist. In der Cilium-Dokumentation finden Sie weitere Informationen zum Standardrichtlinienmodus und zu den Modi zur Richtliniendurchsetzung.
Wenn Sie zu einer bestehenden Cilium-Installation wechselnpolicyEnforcementMode, müssen Sie den Cilium-Agenten neu starten, um den neuen DaemonSet Modus zur Durchsetzung von Richtlinien anzuwenden.
Verwenden Sie namespaceSelector undpodSelector, um to/from Traffic-Namespaces und Pods mit übereinstimmenden Labels zuzulassen oder zu verweigern. Das namespaceSelector und podSelector kann zusammen mit matchLabels oder verwendet werden, matchExpressions um Namespaces und Pods anhand ihrer Labels auszuwählen.
Verwenden Sie ingress.ports undegress.ports, um to/from Datenverkehrsports und -protokolle zuzulassen oder zu verweigern.
Das ipBlock Feld kann nicht verwendet werden, um IP-Adressen von to/from Traffic-Pods selektiv zuzulassen oder abzulehnen (#9209). Die Verwendung von ipBlock Selektoren für Knoten IPs ist eine Beta-Funktion in Cilium und wird von nicht unterstützt. AWS
Informationen zu den verfügbaren Feldern für Kubernetes-Netzwerkrichtlinien finden Sie in der NetworkPolicy Ressource in der Kubernetes-Dokumentation.

Voraussetzungen

Cilium wurde gemäß den Anweisungen unter installiert. CNI für Hybridknoten konfigurieren
Helm wurde in Ihrer Befehlszeilenumgebung installiert, siehe Anweisungen zur Einrichtung von Helm.

Verfahren

Mit dem folgenden Verfahren werden Netzwerkrichtlinien für eine Microservices-Beispielanwendung eingerichtet, sodass Komponenten nur mit anderen Komponenten kommunizieren können, die für das Funktionieren der Anwendung erforderlich sind. Das Verfahren verwendet die Istio Bookinfo-Beispielanwendung für Microservices.

Die Bookinfo-Anwendung besteht aus vier separaten Microservices mit den folgenden Beziehungen:

Produktseite. Der Productpage-Microservice ruft die Details auf und überprüft die Microservices, um die Seite zu füllen.
Einzelheiten. Der Microservice „Details“ enthält Buchinformationen.
Bewertungen. Der Microservice für Rezensionen enthält Buchbesprechungen. Er bezeichnet die Bewertungen auch als Microservice.

Bewertungen. Der Microservice „Bewertungen“ enthält Informationen zur Buchrangfolge, die einer Buchrezension beigefügt werden.

Erstellen Sie die Beispielanwendung.


kubectl apply -f https://raw.githubusercontent.com/istio/istio/refs/heads/master/samples/bookinfo/platform/kube/bookinfo.yaml

Vergewissern Sie sich, dass die Anwendung erfolgreich ausgeführt wird, und notieren Sie sich die Pod-IP-Adresse für den Productpage-Microservice. Sie werden diese Pod-IP-Adresse verwenden, um in den nachfolgenden Schritten jeden Microservice abzufragen.


kubectl get pods -o wide


NAME                              READY   STATUS    RESTARTS   AGE   IP            NODE
details-v1-766844796b-9wff2       1/1     Running   0          7s    10.86.3.7     mi-0daa253999fe92daa
productpage-v1-54bb874995-lwfgg   1/1     Running   0          7s    10.86.2.193   mi-082f73826a163626e
ratings-v1-5dc79b6bcd-59njm       1/1     Running   0          7s    10.86.2.232   mi-082f73826a163626e
reviews-v1-598b896c9d-p2289       1/1     Running   0          7s    10.86.2.47    mi-026d6a261e355fba7
reviews-v2-556d6457d-djktc        1/1     Running   0          7s    10.86.3.58    mi-0daa253999fe92daa
reviews-v3-564544b4d6-g8hh4       1/1     Running   0          7s    10.86.2.69    mi-09183e8a3d755abf6

Erstellen Sie einen Pod, der durchgehend zum Testen der Netzwerkrichtlinien verwendet wird. Beachten Sie, dass der Pod im default Namespace mit dem Label access: true erstellt wird.


kubectl run curl-pod --image=curlimages/curl -i --tty --labels=access=true --namespace=default --overrides='{"spec": { "nodeSelector": {"eks.amazonaws.com/compute-type": "hybrid"}}}' -- /bin/sh

Testen Sie den Zugriff auf den Microservice der Produktseite. Im folgenden Beispiel verwenden wir die Pod-IP-Adresse des Productpage-Pods (10.86.2.193), um den Microservice abzufragen. Ersetzen Sie dies durch die Pod-IP-Adresse des Productpage-Pods in Ihrer Umgebung.
```
curl -s http://10.86.2.193:9080/productpage | grep -o "<title>.*</title>"
```
```
<title>Simple Bookstore App</title>
```
Sie können den Test-CURL-Pod durch Eingabe beenden exit und ihn erneut mit dem Pod verbinden, indem Sie den folgenden Befehl ausführen.
```
kubectl attach curl-pod -c curl-pod -i -t
```
Um die Auswirkungen der Netzwerkrichtlinien in den folgenden Schritten zu demonstrieren, erstellen wir zunächst eine Netzwerkrichtlinie, die den gesamten Datenverkehr für die Microservices verweigert. BookInfo Erstellen Sie eine Datei mit dem Namennetwork-policy-deny-bookinfo.yaml, die die Netzwerkrichtlinie zum Ablehnen definiert.
```
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: deny-bookinfo
  namespace: default
spec:
  podSelector:
    matchExpressions:
    - key: app
      operator: In
      values: ["productpage", "details", "reviews", "ratings"]
  policyTypes:
  - Ingress
  - Egress
```
Wenden Sie die Netzwerkrichtlinie „Deny“ auf Ihren Cluster an.
```
kubectl apply -f network-policy-default-deny-bookinfo.yaml
```
Testen Sie den Zugriff auf die BookInfo Anwendung. Im folgenden Beispiel verwenden wir die Pod-IP-Adresse des ProductPage-Pods (10.86.2.193), um den Microservice abzufragen. Ersetzen Sie dies durch die Pod-IP-Adresse des Productpage-Pods in Ihrer Umgebung.
```
curl http://10.86.2.193:9080/productpage --max-time 10
```
```
curl: (28) Connection timed out after 10001 milliseconds
```

Erstellen Sie eine Datei mit dem Namennetwork-policy-productpage.yaml, die die Produktseiten-Netzwerkrichtlinie definiert. Die Richtlinie hat die folgenden Regeln:

erlaubt eingehenden Datenverkehr von Pods mit dem Label access: true (dem im vorherigen Schritt erstellten Curl-Pod)
ermöglicht ausgehenden TCP-Verkehr auf dem Port 9080 für die Details, Rezensionen und Bewertungen der Microservices

ermöglicht ausgehenden TCP/UDP Verkehr auf dem Port 53 für CoreDNS, der im Namespace läuft kube-system


apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: productpage-policy
  namespace: default
spec:
  podSelector:
    matchLabels:
      app: productpage
  policyTypes:
  - Ingress
  - Egress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          access: "true"
  egress:
  - to:
    - podSelector:
        matchExpressions:
        - key: app
          operator: In
          values: ["details", "reviews", "ratings"]
    ports:
    - port: 9080
      protocol: TCP
  - to:
    - namespaceSelector:
        matchLabels:
          kubernetes.io/metadata.name: kube-system
      podSelector:
        matchLabels:
          k8s-app: kube-dns
    ports:
    - port: 53
      protocol: UDP
    - port: 53
      protocol: TCP

Wenden Sie die ProductPage-Netzwerkrichtlinie auf Ihren Cluster an.
```
kubectl apply -f network-policy-productpage.yaml
```

Connect zum Curl-Pod her und testen Sie den Zugriff auf die Bookinfo-Anwendung. Der Zugriff auf den Microservice auf der Produktseite ist jetzt erlaubt, aber die anderen Microservices werden weiterhin verweigert, da sie immer noch der Netzwerkverweigerungsrichtlinie unterliegen. In den folgenden Beispielen verwenden wir die Pod-IP-Adresse des Productpage-Pods (10.86.2.193), um den Microservice abzufragen. Ersetzen Sie dies durch die Pod-IP-Adresse des Productpage-Pods in Ihrer Umgebung.


kubectl attach curl-pod -c curl-pod -i -t


curl -s http://10.86.2.193:9080/productpage | grep -o "<title>.*</title>"
<title>Simple Bookstore App</title>


curl -s http://10.86.2.193:9080/api/v1/products/1
{"error": "Sorry, product details are currently unavailable for this book."}


curl -s http://10.86.2.193:9080/api/v1/products/1/reviews
{"error": "Sorry, product reviews are currently unavailable for this book."}


curl -s http://10.86.2.193:9080/api/v1/products/1/ratings
{"error": "Sorry, product ratings are currently unavailable for this book."}

Erstellen Sie eine Datei mit dem Namennetwork-policy-details.yaml, die die Details der Netzwerkrichtlinie definiert. Die Richtlinie erlaubt nur eingehenden Datenverkehr vom Microservice auf der Produktseite.


apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: details-policy
  namespace: default
spec:
  podSelector:
    matchLabels:
      app: details
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: productpage

Erstellen Sie eine Datei mit dem Namennetwork-policy-reviews.yaml, die die Netzwerkrichtlinie für Rezensionen definiert. Die Richtlinie erlaubt nur eingehenden Datenverkehr vom Microservice der Produktseite und nur ausgehenden Datenverkehr zu den Rating-Mikroservices und CoreDNS.


apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: reviews-policy
  namespace: default
spec:
  podSelector:
    matchLabels:
      app: reviews
  policyTypes:
  - Ingress
  - Egress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: productpage
  egress:
  - to:
    - podSelector:
        matchLabels:
          app: ratings
  - to:
    - namespaceSelector:
        matchLabels:
          kubernetes.io/metadata.name: kube-system
      podSelector:
        matchLabels:
          k8s-app: kube-dns
    ports:
    - port: 53
      protocol: UDP
    - port: 53
      protocol: TCP

Erstellen Sie eine Datei mit dem Namennetwork-policy-ratings.yaml, die die Richtlinien für das Bewertungsnetzwerk definiert. Die Richtlinie erlaubt nur eingehenden Traffic von der Produktseite und den Test-Microservices.


apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: ratings-policy
  namespace: default
spec:
  podSelector:
    matchLabels:
      app: ratings
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchExpressions:
        - key: app
          operator: In
          values: ["productpage", "reviews"]

Wenden Sie die Netzwerkrichtlinien für Details, Rezensionen und Bewertungen auf Ihren Cluster an.


kubectl apply -f network-policy-details.yaml
kubectl apply -f network-policy-reviews.yaml
kubectl apply -f network-policy-ratings.yaml

Connect zum Curl-Pod her und testen Sie den Zugriff auf die Bookinfo-Anwendung. In den folgenden Beispielen verwenden wir die Pod-IP-Adresse des Productpage-Pods (10.86.2.193), um den Microservice abzufragen. Ersetzen Sie dies durch die Pod-IP-Adresse des Productpage-Pods in Ihrer Umgebung.


kubectl attach curl-pod -c curl-pod -i -t

Testen Sie den Microservice mit den Details.


curl -s http://10.86.2.193:9080/api/v1/products/1


{"id": 1, "author": "William Shakespeare", "year": 1595, "type": "paperback", "pages": 200, "publisher": "PublisherA", "language": "English", "ISBN-10": "1234567890", "ISBN-13": "123-1234567890"}

Testen Sie den Microservice für Bewertungen.


curl -s http://10.86.2.193:9080/api/v1/products/1/reviews


{"id": "1", "podname": "reviews-v1-598b896c9d-p2289", "clustername": "null", "reviews": [{"reviewer": "Reviewer1", "text": "An extremely entertaining play by Shakespeare. The slapstick humour is refreshing!"}, {"reviewer": "Reviewer2", "text": "Absolutely fun and entertaining. The play lacks thematic depth when compared to other plays by Shakespeare."}]}

Testen Sie den Microservice für Bewertungen.


curl -s http://10.86.2.193:9080/api/v1/products/1/ratings


{"id": 1, "ratings": {"Reviewer1": 5, "Reviewer2": 4}}

Bereinigen Sie die Ressourcen, die Sie in diesem Verfahren erstellt haben.


kubectl delete -f network-policy-deny-bookinfo.yaml
kubectl delete -f network-policy-productpage.yaml
kubectl delete -f network-policy-details.yaml
kubectl delete -f network-policy-reviews.yaml
kubectl delete -f network-policy-ratings.yaml
kubectl delete -f https://raw.githubusercontent.com/istio/istio/refs/heads/master/samples/bookinfo/platform/kube/bookinfo.yaml
kubectl delete pod curl-pod

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

LoadBalancer Dienste konfigurieren

Funktionsweise