Unterstützung für die Verbesserung dieser Seite beitragen

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.

Um zu diesem Benutzerhandbuch beizutragen, wählen Sie den GitHub Link Diese Seite bearbeiten auf, der sich im rechten Bereich jeder Seite befindet.

Konfiguration von Kubernetes-Netzwerkrichtlinien für Hybridknoten

AWS unterstützt Kubernetes-Netzwerkrichtlinien (Layer 3/Layer 4) für Pod-Ein- und -Ausgangs-Datenverkehr bei Verwendung von Cilium als CNI mit EKS-Hybridknoten. Wenn Sie EKS-Cluster mit Knoten in der AWS Cloud ausführen, unterstützt AWS das Amazon VPC CNI für Kubernetes-Netzwerkrichtlinien.

Dieses Thema beschreibt 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 vorgelagerten Kubernetes-Netzwerkrichtlinien und -Spezifikationen für Pod-Ingress und -Egress. AWS unterstützt derzeit CiliumNetworkPolicy oder CiliumClusterwideNetworkPolicy nicht.
Der policyEnforcementMode-Helm-Wert kann verwendet werden, um das Standardverhalten der Cilium-Richtliniendurchsetzung zu steuern. Das Standardverhalten lässt den gesamten ausgehenden und eingehenden Datenverkehr zu. Wenn ein Endpunkt durch eine Netzwerkrichtlinie ausgewählt wird, wechselt er in einen Standard-Verweigerungszustand, in dem nur ausdrücklich zugelassener Datenverkehr zugelassen wird. Weitere Informationen zum Standard-Richtlinienmodus und zu den Modi zur Durchsetzung von Richtlinien finden Sie in der Cilium-Dokumentation.
Wenn Sie policyEnforcementMode für eine vorhandene Cilium-Installation ändern, müssen Sie den Cilium Agent DaemonSet neu starten, um den neuen Modus zur Durchsetzung von Richtlinien anzuwenden.
Verwenden Sie namespaceSelector und podSelector, um Datenverkehr zu/von Namespaces und Pods mit übereinstimmenden Labels zuzulassen oder zu verweigern. Der namespaceSelector und podSelector kann mit matchLabels oder matchExpressions verwendet werden, um Namespaces und Pods basierend auf ihren Labels auszuwählen.
Verwenden Sie ingress.ports und egress.ports, um Datenverkehr zu/von Ports und Protokollen zuzulassen oder zu verweigern.
Das ipBlock-Feld kann nicht verwendet werden, um Datenverkehr zu/von Pod-IP-Adressen selektiv zuzulassen oder zu verweigern (#9209). Die Verwendung von ipBlock-Selektoren für Knoten-IPs ist ein Beta-Feature in Cilium und wird von AWS nicht unterstützt.
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 in CNI für Hybridknoten konfigurieren installiert.
Helm ist in Ihrer Befehlszeilenumgebung installiert. Weitere Informationen finden Sie unter Anweisungen zur Einrichtung von Helm.

Verfahren

Mit dem folgenden Verfahren werden Netzwerkrichtlinien für eine Beispiel-Microservices-Anwendung eingerichtet, sodass Komponenten nur mit anderen Komponenten kommunizieren können, die für die Funktion 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:

productpage. Der Microservice „productpage“ ruft die Details auf und überprüft die Microservices, um die Seite zu füllen.
details. Der Microservice „details“ enthält Buchinformationen.
reviews. Der Microservice „reviews“ enthält Buchbewertungen. Er ruft außerdem den Microservice „ratings“ auf.

ratings. Der Microservice „ratings“ enthält Informationen zur Buchbewertung, die einer Buchrezension beigefügt sind.

Erstellen Sie die Beispielanwendung.


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

Stellen Sie sicher, dass die Anwendung erfolgreich ausgeführt wird, und notieren Sie sich die Pod-IP-Adresse für den Mikroservice „productpage“. Diese Pod-IP-Adresse werden Sie in den folgenden Schritten verwenden, um 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 „productpage“. Im nachfolgenden 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 von exit verlassen und sich 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 BookInfo-Microservices verweigert. Erstellen Sie eine Datei mit dem Namen network-policy-deny-bookinfo.yaml, welche die Netzwerk-Verweigerungsrichtlinie 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 Netzwerk-Verweigerungsrichtlinie auf Ihren Cluster an.
```
kubectl apply -f network-policy-default-deny-bookinfo.yaml
```
Testen Sie den Zugriff auf die Anwendung BookInfo. Im nachfolgenden 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 Namen network-policy-productpage.yaml, welche die Netzwerkrichtlinie der Produktseite definiert. Die Richtlinie enthält die folgenden Regeln:

erlaubt eingehenden Datenverkehr von Pods mit dem Label access: true (der im vorherigen Schritt erstellte Curl-Pod).
erlaubt ausgehenden TCP-Datenverkehr auf Port 9080 für die Microservices „details“, „reviews“ und „ratings“.

erlaubt ausgehenden TCP/UDP-Datenverkehr auf Port 53 für CoreDNS, das im kube-system-Namespace ausgeführt wird.


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 Netzwerkrichtlinie „productpage“ auf Ihren Cluster an.
```
kubectl apply -f network-policy-productpage.yaml
```

Stellen Sie eine Verbindung zum Curl-Pod her und testen Sie den Zugriff auf die Bookinfo-Anwendung. Der Zugriff auf den Microservice „productpage“ ist nun erlaubt. Die anderen Microservices werden jedoch weiterhin verweigert, da sie weiterhin der Richtlinie „Netzwerk verweigern“ 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 Namen network-policy-details.yaml, welche die detaillierte Netzwerkrichtlinie definiert. Die Richtlinie lässt nur eingehenden Datenverkehr vom Microservice „productpage“ zu.


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 Namen network-policy-reviews.yaml, welche die Richtlinie für das Bewertungsnetzwerk definiert. Die Richtlinie lässt nur eingehenden Datenverkehr vom Microservice „productpage“ zu und nur ausgehenden Datenverkehr zum Microservice „ratings“ und zu 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 Namen network-policy-ratings.yaml, welche die Richtlinie für das Bewertungsnetzwerk definiert. Die Richtlinie lässt nur eingehenden Datenverkehr von der Produktseite und den Microservices „reviews“ zu.


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

Stellen Sie eine Verbindung 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 „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 „reviews“.


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 „ratings“.


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-Services konfigurieren

Funktionsweise