**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.
# Pod-Netzwerk-Datenverkehr mit Kubernetes-Netzwerkrichtlinien einschränken
Sie können eine Kubernetes-Netzwerkrichtlinie verwenden, um den Netzwerk-Datenverkehr zu und von Ihren Pods einzuschränken. Weitere Informationen finden Sie unter [Netzwerk-Richtlinien](https://kubernetes.io/docs/concepts/services-networking/network-policies/) in der Kubernetes-Dokumentation.
Um dieses Feature nutzen zu können, müssen Sie Folgendes konfigurieren:
1. Richten Sie die Richtlinien-Durchsetzung beim Pod-Startup ein. Dies erfolgt im `aws-node`-Container des VPC-CNI-`DaemonSet`.
1. Aktivieren Sie den Netzwerkrichtlinienparameter für das Add-On.
1. Cluster für die Verwendung der Kubernetes-Netzwerkrichtlinie konfigurieren
Lesen Sie die Überlegungen noch einmal durch, bevor Sie beginnen. Weitere Informationen finden Sie unter [Überlegungen](cni-network-policy.md#cni-network-policy-considerations).
## Voraussetzungen
Für das Feature gelten folgende Voraussetzungen:
### Minimale Cluster-Version
Ein vorhandener Amazon-EKS-Cluster. Informationen zum Bereitstellen finden Sie unter [Erste Schritte mit Amazon EKS](getting-started.md). Auf dem Cluster muss eine der in der folgenden Tabelle aufgeführten Kubernetes-Versionen und Plattform-Versionen ausgeführt werden. Beachten Sie, dass alle Kubernetes- und Plattformversionen, die über die aufgeführten hinausgehen, ebenfalls unterstützt werden. Sie können Ihre aktuelle Kubernetes-Version überprüfen, indem Sie *my-cluster* den folgenden Befehl durch den Namen Ihres Clusters ersetzen und dann den geänderten Befehl ausführen:
```
aws eks describe-cluster --name my-cluster --query cluster.version --output text
```
| Kubernetes-Version | Plattformversion |
| --- | --- |
| `1.27.4` | `eks.5` |
| `1.26.7` | `eks.6` |
### VPC-CNI-Mindestversion
Um sowohl Standard-Kubernetes-Netzwerkrichtlinien als auch Admin-Netzwerkrichtlinien zu erstellen, müssen Sie die Version `1.21` des VPC-CNI-Plug-ins ausführen. Sie können Ihre aktuelle Version mit dem folgenden Befehl überprüfen:
```
kubectl describe daemonset aws-node --namespace kube-system | grep amazon-k8s-cni: | cut -d : -f 3
```
Wenn Ihre Version älter als `1.21` ist, finden Sie unter [Aktualisieren der Amazon VPC CNI (Amazon-EKS-Add-On)](vpc-add-on-update.md) Informationen zum Aktualisieren des Plugins auf Version `1.21` oder höher.
### Linux-Kernel-Mindestversion
Ihre Knoten müssen eine Linux-Kernelversion ab Version `5.10` haben. Sie können Ihre Kernelversion mit `uname -r` überprüfen. Wenn Sie die neuesten Versionen von Amazon EKS-optimiertem Amazon Linux, Amazon EKS-optimiertem beschleunigtem Amazon Linux und Bottlerocket AMIs verwenden AMIs, verfügen diese bereits über die erforderliche Kernelversion.
Amazon-EKS-optimierte Amazon-Linux-AMI-Versionen ab `v20231116` verfügen über Kernel-Version `5.10`.
## Schritt 1: Richtlinien-Durchsetzung beim Startup des Pods einrichten
Das Amazon-VPC-CNI-Plugin für Kubernetes konfiguriert die Netzwerkrichtlinien für Pods parallel zur Pod-Bereitstellung. Bis alle Richtlinien für den neuen Pod konfiguriert sind, starten die Container im neuen Pod mit einer *Standard-Zulassungsrichtlinie*. Dies wird als *Standardmodus* bezeichnet. Eine Standard-Zulassungsrichtlinie bedeutet, dass der gesamte eingehende und ausgehende Datenverkehr zu und von den neuen Pods zugelassen wird. Beispielsweise werden für die Pods keine Firewall-Regeln durchgesetzt (der gesamte Datenverkehr ist zulässig), bis der neue Pod mit den aktiven Richtlinien aktualisiert wird.
Wenn die `NETWORK_POLICY_ENFORCING_MODE`-Variable auf `strict` gesetzt ist, starten Pods, die VPC CNI verwenden, mit einer *Standard-Verweigerungsrichtlinie*, anschließend werden die Richtlinien konfiguriert. Dies wird als *strikter Modus* bezeichnet. Im strikten Modus müssen Sie für jeden Endpunkt in Ihrem Cluster, auf den Ihre Pods zugreifen müssen, eine Netzwerkrichtlinie haben. Beachten Sie, dass diese Anforderung für die CoreDNS-Pods gilt. Die Standard-Verweigerungsrichtlinie ist für Pods mit Host-Netzwerk nicht konfiguriert.
Sie können die Standard-Netzwerkrichtlinie ändern, indem Sie die Umgebungsvariable `NETWORK_POLICY_ENFORCING_MODE` im `aws-node`-Container des VPC-CNI-`DaemonSet` auf `strict` setzen.
```
env:
- name: NETWORK_POLICY_ENFORCING_MODE
value: "strict"
```
## Schritt 2: Netzwerk-Richtlinienparameter für das Add-On aktivieren
Das Netzwerkrichtlinien-Feature verwendet standardmäßig den Port `8162` auf dem Knoten für Metriken. Außerdem verwendet die Funktion den Port `8163` für Gesundheitstests. Wenn Sie eine andere Anwendung auf die Knoten oder innerhalb von Pods ausführen, die diese Ports verwenden müssen, kann die App nicht ausgeführt werden. Ab der VPC CNI-Version `v1.14.1` oder höher können Sie diese Ports ändern.
Führen Sie die folgenden Schritte aus, um den Netzwerk-Richtlinienparameter für das Add-On zu aktivieren.
### AWS-Managementkonsole
1. Öffnen Sie die [Amazon-EKS-Konsole](https://console.aws.amazon.com/eks/home#/clusters).
1. Wählen Sie im linken Navigationsbereich die Option **Cluster** aus. Wählen Sie dann den Namen des Clusters aus, für den Sie das Amazon-VPC-CNI-Add-on konfigurieren möchten.
1. Wählen Sie die Registerkarte **Add-ons**.
1. Wählen Sie das Kästchen oben rechts in der Add-On-Box aus und wählen Sie dann **Edit** (Bearbeiten).
1. Auf der Seite **`Amazon VPC CNI` konfigurieren**:
1. Wählen Sie in der Liste **Version** eine Version vom Typ `v1.14.0-eksbuild.3` oder höher aus.
1. Erweitern Sie **Optionale Konfigurationseinstellungen**.
1. Geben Sie den JSON-Schlüssel `"enableNetworkPolicy":` und den Wert `"true"` in **Konfigurationswerte** ein. Der resultierende Text muss ein gültiges JSON-Objekt sein. Wenn dieser Schlüssel und dieser Wert die einzigen Daten im Textfeld sind, setzen Sie den Schlüssel und den Wert in geschweifte Klammern `{ }`.
Im folgenden Beispiel ist das Netzwerkrichtlinien-Feature aktiviert, und Metriken und Integritätsprüfungen sind auf die Standardportnummern eingestellt:
```
{
"enableNetworkPolicy": "true",
"nodeAgent": {
"healthProbeBindAddr": "8163",
"metricsBindAddr": "8162"
}
}
```
### Helm
Wenn Sie das Amazon-VPC-CNI-Plugin für Kubernetes über `helm` installiert haben, können Sie die Konfiguration aktualisieren, um die Ports zu ändern.
1. Führen Sie den folgenden Befehl aus, um die Ports zu ändern. Legen Sie die Portnummer im Wert für Schlüssel `nodeAgent.metricsBindAddr` bzw. Schlüssel `nodeAgent.healthProbeBindAddr` fest.
```
helm upgrade --set nodeAgent.metricsBindAddr=8162 --set nodeAgent.healthProbeBindAddr=8163 aws-vpc-cni --namespace kube-system eks/aws-vpc-cni
```
### kubectl
1. Öffnen Sie das `DaemonSet` `aws-node` in Ihrem Editor.
```
kubectl edit daemonset -n kube-system aws-node
```
1. Ersetzen Sie die Portnummern in den folgenden Befehlsargumenten im `args:` im `aws-network-policy-agent`-Container im `aws-node`-DaemonSet-Manifest von VPC CNI.
```
- args:
- --metrics-bind-addr=:8162
- --health-probe-bind-addr=:8163
```
## Schritt 3: Cluster für die Verwendung von Kubernetes-Netzwerkrichtlinien konfigurieren
Sie können dies für ein Amazon-EKS-Add-On oder ein selbstverwaltetes Add-On einstellen.
### Amazon-EKS-Add-On
Mithilfe der AWS CLI können Sie den Cluster für die Verwendung von Kubernetes-Netzwerkrichtlinien konfigurieren, indem Sie den folgenden Befehl ausführen. Ersetzen Sie `my-cluster` durch den Namen Ihres Clusters und den IAM-Rollen-ARN durch die Rolle, die Sie verwenden.
```
aws eks update-addon --cluster-name my-cluster --addon-name vpc-cni --addon-version v1.14.0-eksbuild.3 \
--service-account-role-arn arn:aws: iam::123456789012:role/AmazonEKSVPCCNIRole \
--resolve-conflicts PRESERVE --configuration-values '{"enableNetworkPolicy": "true"}'
```
Gehen Sie wie folgt vor, um dies mit der AWS Management Console zu konfigurieren:
1. Öffnen Sie die [Amazon-EKS-Konsole](https://console.aws.amazon.com/eks/home#/clusters).
1. Wählen Sie im linken Navigationsbereich die Option **Cluster** aus. Wählen Sie dann den Namen des Clusters aus, für den Sie das Amazon-VPC-CNI-Add-on konfigurieren möchten.
1. Wählen Sie die Registerkarte **Add-ons**.
1. Wählen Sie das Kästchen oben rechts in der Add-On-Box aus und wählen Sie dann **Edit** (Bearbeiten).
1. Auf der Seite **`Amazon VPC CNI` konfigurieren**:
1. Wählen Sie in der Liste **Version** eine Version vom Typ `v1.14.0-eksbuild.3` oder höher aus.
1. Erweitern Sie **Optionale Konfigurationseinstellungen**.
1. Geben Sie den JSON-Schlüssel `"enableNetworkPolicy":` und den Wert `"true"` in **Konfigurationswerte** ein. Der resultierende Text muss ein gültiges JSON-Objekt sein. Wenn dieser Schlüssel und dieser Wert die einzigen Daten im Textfeld sind, setzen Sie den Schlüssel und den Wert in geschweifte Klammern `{ }`. Das folgende Beispiel veranschaulicht, dass die Netzwerkrichtlinie aktiviert ist:
```
{ "enableNetworkPolicy": "true" }
```
Der folgende Screenshot zeigt ein Beispiel für dieses Szenario.
![\[ zeigt das VPC-CNI-Add-On mit Netzwerkrichtlinie in der optionalen Konfiguration.\]](http://docs.aws.amazon.com/de_de/eks/latest/userguide/images/console-cni-config-network-policy.png)
### Selbstverwaltetes Add-On
Wenn Sie das Amazon-VPC-CNI-Plugin für Kubernetes über `helm` installiert haben, können Sie die Konfiguration aktualisieren, um die Netzwerkrichtlinie zu aktivieren.
1. Führen Sie den folgenden Befehl aus, um die Netzwerkrichtlinie zu aktivieren.
```
helm upgrade --set enableNetworkPolicy=true aws-vpc-cni --namespace kube-system eks/aws-vpc-cni
```
1. Öffnen Sie das `ConfigMap` `amazon-vpc-cni` in Ihrem Editor.
```
kubectl edit configmap -n kube-system amazon-vpc-cni -o yaml
```
1. Fügen Sie `data` in `ConfigMap` die folgende Zeile hinzu:
```
enable-network-policy-controller: "true"
```
Sobald Sie die Zeile hinzugefügt haben, sollte `ConfigMap` wie das folgende Beispiel aussehen.
```
apiVersion: v1
kind: ConfigMap
metadata:
name: amazon-vpc-cni
namespace: kube-system
data:
enable-network-policy-controller: "true"
```
1. Öffnen Sie das `DaemonSet` `aws-node` in Ihrem Editor.
```
kubectl edit daemonset -n kube-system aws-node
```
1. Ersetzen Sie im Befehlsargument `--enable-network-policy=false` in `args:` im Container `aws-network-policy-agent` im DaemonSet-Manifest `aws-node` von VPC CNI den Wert `false` durch `true`.
```
- args:
- --enable-network-policy=true
```
## Schritt 4. Nächste Schritte
Nachdem Sie die Konfiguration abgeschlossen haben, überprüfen Sie, ob die `aws-node`-Pods in Ihrem Cluster ausgeführt werden.
```
kubectl get pods -n kube-system | grep 'aws-node\|amazon'
```
Eine Beispielausgabe sieht wie folgt aus.
```
aws-node-gmqp7 2/2 Running 1 (24h ago) 24h
aws-node-prnsh 2/2 Running 1 (24h ago) 24h
```
In den `aws-node`-Pods der Versionen `1.14` und höher befinden sich zwei Container. In früheren Versionen und wenn die Netzwerkrichtlinie deaktiviert ist, gibt es nur einen einzigen Container in den `aws-node`-Pods.
Sie können nun Kubernetes-Netzwerkrichtlinien in Ihrem Cluster bereitstellen.
Um Kubernetes-Netzwerkrichtlinien zu implementieren, können Sie Kubernetes `NetworkPolicy` oder `ClusterNetworkPolicy` Objekte erstellen und diese in Ihrem Cluster bereitstellen. `NetworkPolicy`Objekte sind auf einen Namespace beschränkt, während `ClusterNetworkPolicy` Objekte auf den gesamten Cluster oder mehrere Namespaces beschränkt werden können. Sie implementieren Richtlinien, um Datenverkehr zwischen Pods auf der Grundlage von Bezeichnungsselektoren, Namespaces und IP-Adressbereichen zuzulassen oder zu verweigern. Weitere Informationen zum Erstellen von `NetworkPolicy`-Objekten finden Sie unter [Netzwerkrichtlinien](https://kubernetes.io/docs/concepts/services-networking/network-policies/#networkpolicy-resource) in der Kubernetes-Dokumentation.
Die Durchsetzung von Kubernetes-`NetworkPolicy`-Objekten wird mithilfe des Extended Berkeley Packet Filter (eBPF) implementiert. Im Vergleich zu `iptables`-basierten Implementierungen bietet er geringere Latenzzeiten und Leistungsmerkmale, einschließlich einer geringeren CPU-Auslastung und der Vermeidung sequenzieller Suchvorgänge. Darüber hinaus bieten eBPF-Proben Zugriff auf kontextreiche Daten, die bei der Fehlersuche in komplexen Problemen auf Kernel-Ebene helfen und die Beobachtbarkeit verbessern. Amazon EKS unterstützt einen eBPF-basierten Exporter, der die Proben nutzt, um Richtlinienergebnisse auf jedem Knoten zu protokollieren und die Daten an externe Protokollsammler zu exportieren, um bei der Fehlersuche zu helfen. Weitere Informationen finden Sie in der [eBPF-Dokumentation](https://ebpf.io/what-is-ebpf/#what-is-ebpf).