**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.
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.
# 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](cni-network-policy.md).
Dieses Thema beschreibt die Konfiguration von Cilium- und Kubernetes-Netzwerkrichtlinien mit EKS-Hybridknoten. Ausführliche Informationen zu Kubernetes-Netzwerkrichtlinien finden Sie unter [Kubernetes-Netzwerkrichtlinien](https://kubernetes.io/docs/concepts/services-networking/network-policies/) 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](https://docs.cilium.io/en/stable/security/policy/intro/#policy-mode-default) und zu den [Modi zur Durchsetzung von Richtlinien](https://docs.cilium.io/en/stable/security/policy/intro/#policy-enforcement-modes) 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 ([\$19209](https://github.com/cilium/cilium/issues/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](https://kubernetes.io/docs/concepts/services-networking/network-policies/#networkpolicy-resource) in der Kubernetes-Dokumentation.
### Voraussetzungen
+ Cilium wurde gemäß den Anweisungen in [CNI für Hybridknoten konfigurieren](hybrid-nodes-cni.md) installiert.
+ Helm ist in Ihrer Befehlszeilenumgebung installiert. Weitere Informationen finden Sie unter [Anweisungen zur Einrichtung von Helm](helm.md).
### 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](https://istio.io/latest/docs/examples/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.
1. Erstellen Sie die Beispielanwendung.
```
kubectl apply -f https://raw.githubusercontent.com/istio/istio/refs/heads/master/samples/bookinfo/platform/kube/bookinfo.yaml
```
1. 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
```
1. 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
```
1. 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 ".*"
```
```
Simple Bookstore App
```
1. 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
```
1. 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
```
1. Wenden Sie die Netzwerk-Verweigerungsrichtlinie auf Ihren Cluster an.
```
kubectl apply -f network-policy-default-deny-bookinfo.yaml
```
1. 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
```
1. 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
```
1. Wenden Sie die Netzwerkrichtlinie „productpage“ auf Ihren Cluster an.
```
kubectl apply -f network-policy-productpage.yaml
```
1. 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 ".*"
Simple Bookstore App
```
```
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."}
```
1. 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
```
1. 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
```
1. 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"]
```
1. 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
```
1. 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}}
```
1. 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
```