{"id":32641,"date":"2019-10-31T21:48:11","date_gmt":"2019-10-31T18:48:11","guid":{"rendered":"https:\/\/prohoster.info\/blog\/vvedenie-v-setevye-politiki-kubernetes-dlya-spetsialistov-po-bezopasnosti\/"},"modified":"2019-10-31T21:48:11","modified_gmt":"2019-10-31T18:48:11","slug":"vvedenie-v-setevye-politiki-kubernetes-dlya-spetsialistov-po-bezopasnosti","status":"publish","type":"post","link":"https:\/\/prohoster.info\/de\/blog\/administrirovanie\/vvedenie-v-setevye-politiki-kubernetes-dlya-spetsialistov-po-bezopasnosti","title":{"rendered":"Einf\u00fchrung in die Netzwerkpolitik von Kubernetes f\u00fcr Sicherheitsexperten","gt_translate_keys":[{"key":"rendered","format":"text"}]},"content":{"rendered":"<p><img decoding=\"async\" alt=\"Einf\u00fchrung in die Netzwerkpolitik von Kubernetes f\u00fcr Sicherheitsexperten\" src=\"\/wp-content\/uploads\/2019\/04\/6972a1e1385463b1fcc723c09036a565.png\" style=\"display:block;margin: 0 auto;\" \/><br \/>\n<br \/>\n<i><b>Hinweis.<\/b>: Der Autor des Artikels, Reuven Harrison, bringt \u00fcber 20 Jahre Erfahrung in der Softwareentwicklung mit und ist derzeit technischer Direktor und Mitgr\u00fcnder von Tufin, einem Unternehmen, das L\u00f6sungen zur Verwaltung von Sicherheitsrichtlinien entwickelt. W\u00e4hrend er Kubernetes-Netzwerkrichtlinien als ein kraftvolles Mittel zur Netzwerksegmentierung innerhalb von Clustern sieht, ist er gleichzeitig der Meinung, dass deren praktische Anwendung nicht so einfach ist. Dieser umfangreiche Beitrag soll das Bewusstsein der Fachleute zu diesem Thema sch\u00e4rfen und ihnen helfen, die erforderlichen Konfigurationen zu erstellen.<\/i><noindex><a rel=\"nofollow\" name=\"habracut\"><\/a><\/noindex><\/p>\n<p>Heute entscheiden sich immer mehr Unternehmen daf\u00fcr, Kubernetes zur Ausf\u00fchrung ihrer Anwendungen zu nutzen. Das Interesse an dieser Software ist so gro\u00df, dass manche Kubernetes als \"das neue Betriebssystem f\u00fcr Rechenzentren\" bezeichnen. Allm\u00e4hlich wird Kubernetes (oder k8s) als eine kritische Komponente f\u00fcr Unternehmen wahrgenommen, die eine reife Organisation der Gesch\u00e4ftsprozesse erfordert, einschlie\u00dflich der Gew\u00e4hrleistung der Netzwerksicherheit.<\/p>\n<p>F\u00fcr Sicherheitsexperten, die sich mit Kubernetes auseinandersetzen, kann die Standardpolitik dieser Plattform eine echte Offenbarung sein: alles zuzulassen.<\/p>\n<p>Dieses Handbuch hilft, die inneren Abl\u00e4ufe der Netzwerkpolitiken zu verstehen und die Unterschiede zu den Regeln herk\u00f6mmlicher Firewalls zu erkennen. Au\u00dferdem werden einige Fallstricke beleuchtet und Empfehlungen gegeben, die helfen, Anwendungen in Kubernetes zu sch\u00fctzen.<\/p>\n<h2>Netzwerkpolitiken von Kubernetes<\/h2>\n<p>\nDer Mechanismus der Netzwerkpolitiken von Kubernetes erm\u00f6glicht die Steuerung der Interaktion von in der Plattform bereitgestellten Anwendungen auf Netzwerkschicht (der dritten Schicht im OSI-Modell). Netzwerkpolitiken bieten nicht die erweiterten Funktionen moderner Firewalls, wie etwa die Kontrolle auf Schicht 7 des OSI-Modells und Bedrohungserkennung, gew\u00e4hrleisten jedoch ein grundlegendes Ma\u00df an Netzwerksicherheit, das einen guten Ausgangspunkt darstellt.<\/p>\n<h2>Netzwerkrichtlinien steuern die Kommunikation zwischen Pods.<\/h2>\n<p>\nArbeitslasten in Kubernetes werden auf Pods verteilt, die aus einem oder mehreren zusammen bereitgestellten Containern bestehen. Kubernetes weist jedem Pod eine IP-Adresse zu, die von anderen Pods aus erreichbar ist. Die Netzwerkrichtlinien von Kubernetes legen Zugriffsrechte f\u00fcr Gruppen von Pods fest, \u00e4hnlich wie Sicherheitsgruppen in der Cloud verwendet werden, um den Zugriff auf virtuelle Maschinen zu steuern.<\/p>\n<h2>Definition von Netzwerkrichtlinien<\/h2>\n<p>\nWie andere Ressourcen in Kubernetes werden Netzwerkrichtlinien im YAML-Format definiert. Im folgenden Beispiel wird der Anwendung <code>balance<\/code> Zugriff gew\u00e4hrt auf <code>postgres<\/code>:<\/p>\n<pre><code class=\"plaintext\">apiVersion: networking.k8s.io\/v1\nkind: NetworkPolicy\nmetadata:\n  name: default.postgres\n  namespace: default\nspec:\n  podSelector:\n    matchLabels:\n      app: postgres\n  ingress:\n  - from:\n    - podSelector:\n        matchLabels:\n          app: balance\n  policyTypes:\n  - Ingress<\/code><\/pre>\n<p>\n<img decoding=\"async\" alt=\"Einf\u00fchrung in die Netzwerkpolitik von Kubernetes f\u00fcr Sicherheitsexperten\" src=\"\/wp-content\/uploads\/2019\/04\/ff5857af2641e62558b035bab9c413dc.png\" style=\"display:block;margin: 0 auto;\" \/><br \/>\n<br \/>\n<i>(<b>Hinweis.<\/b>: Dieser Screenshot, wie alle folgenden \u00e4hnlichen, wurde nicht mit nativen Mitteln von Kubernetes erstellt, sondern mit dem Tool Tufin Orca, das von der Firma des Autors des Originalartikels entwickelt wurde und am Ende des Materials erw\u00e4hnt wird.<\/i><\/p>\n<p>F\u00fcr die Festlegung der eigenen Netzwerkrichtlinien sind grundlegende Kenntnisse in YAML erforderlich. Diese Sprache basiert auf Einr\u00fcckungen (die durch Leerzeichen und nicht durch Tabulatoren erstellt werden). Ein einger\u00fccktes Element geh\u00f6rt zum n\u00e4chstgelegenen \u00fcbergeordneten Element mit einer Einr\u00fcckung. Ein neues Listenelement beginnt mit einem Bindestrich, alle anderen Elemente erscheinen als <i>Schl\u00fcssel-Wert-Paar<\/i>.<\/p>\n<p>Nachdem Sie die Richtlinie in YAML beschrieben haben, verwenden Sie <noindex><a rel=\"nofollow\" href=\"https:\/\/kubernetes.io\/docs\/reference\/kubectl\/kubectl\/\">kubectl<\/a><\/noindex>, um sie im Cluster zu erstellen:<\/p>\n<pre><code class=\"bash\">kubectl create -f policy.yaml<\/code><\/pre>\n<p><\/p>\n<h2>Spezifikation der Netzwerkrichtlinie<\/h2>\n<p>\nDie Spezifikation der Kubernetes-Netzwerkrichtlinie umfasst vier Elemente:<\/p>\n<ol>\n<li> <code>podSelector<\/code>: definiert die von dieser Richtlinie betroffenen Pods (Ziele) \u2013 obligatorisch;<\/li>\n<li> <code>policyTypes<\/code>: gibt an, welche Arten von Richtlinien in dieser enthalten sind: ingress und\/oder egress \u2013 optional, ich empfehle jedoch, dies in allen F\u00e4llen ausdr\u00fccklich anzugeben;<\/li>\n<li> <code>ingress<\/code>: definiert den erlaubten <b>eingehenden<\/b> der Datenverkehr zu den Ziel-Pods \u2013 optional;<\/li>\n<li> <code>egress<\/code>: definiert den erlaubten <b>ausgehenden<\/b> der Datenverkehr aus den Ziel-Pods \u2013 optional.<\/li>\n<\/ol>\n<p>\nEin Beispiel, das von der Kubernetes-Website entnommen wurde (ich habe <code>role<\/code> findet man <code>app<\/code>), zeigt, wie alle vier Elemente verwendet werden:<\/p>\n<pre><code class=\"plaintext\">apiVersion: networking.k8s.io\/v1\nkind: NetworkPolicy\nmetadata:\n  name: test-network-policy\n  namespace: default\nspec:\n  podSelector:    # &lt;&lt;&lt;\n    matchLabels:\n      app: db\n  policyTypes:    # &lt;&lt;&lt;\n  - Ingress\n  - Egress\n  ingress:        # &lt;&lt;&lt;\n  - from:\n    - ipBlock:\n        cidr: 172.17.0.0\/16\n        except:\n        - 172.17.1.0\/24\n    - namespaceSelector:\n        matchLabels:\n          project: myproject\n    - podSelector:\n        matchLabels:\n          role: frontend\n    ports:\n    - protocol: TCP\n      port: 6379\n  egress:         # &lt;&lt;&lt;\n  - to:\n    - ipBlock:\n        cidr: 10.0.0.0\/24\n    ports:\n    - protocol: TCP\n      port: 5978<\/code><\/pre>\n<p>\n<img decoding=\"async\" alt=\"Einf\u00fchrung in die Netzwerkpolitik von Kubernetes f\u00fcr Sicherheitsexperten\" src=\"\/wp-content\/uploads\/2019\/04\/f01e748410564756d6272095093e52e2.png\" style=\"display:block;margin: 0 auto;\" \/><br \/>\n<img decoding=\"async\" alt=\"Einf\u00fchrung in die Netzwerkpolitik von Kubernetes f\u00fcr Sicherheitsexperten\" src=\"\/wp-content\/uploads\/2019\/04\/997282073ee6b5c4d6b7af45cdc11295.png\" style=\"display:block;margin: 0 auto;\" \/><br \/>\n<br \/>\nBitte beachten Sie, dass das Einf\u00fcgen aller vier Elemente nicht zwingend erforderlich ist. Nur <code>podSelector<\/code>ist Pflicht; die \u00fcbrigen Parameter k\u00f6nnen nach Bedarf verwendet werden.<\/p>\n<p>Wenn Sie weglassen <code>policyTypes<\/code>, wird die Richtlinie folgenderma\u00dfen interpretiert:<\/p>\n<ul>\n<li> Standardm\u00e4\u00dfig wird angenommen, dass sie die Ingress-Seite definiert. Wenn keine expliziten Hinweise dazu in der Richtlinie enthalten sind, wird das System annehmen, dass der gesamte Verkehr verboten ist.<\/li>\n<li> Das Verhalten auf der Egress-Seite wird durch das Vorhandensein oder Fehlen des entsprechenden Egress-Parameters bestimmt.<\/li>\n<\/ul>\n<p>\nUm Fehler zu vermeiden, empfehle ich, <b>immer explizit anzugeben. <code>policyTypes<\/code><\/b>.<\/p>\n<p>Gem\u00e4\u00df der oben genannten Logik wird die Richtlinie, falls die Parameter <code>ingress<\/code> und\/oder <code>egress<\/code> weggelassen werden, den gesamten Verkehr blockieren (siehe \"Clearance-Regel\" unten).<\/p>\n<h2>Standardpolitik - Erlauben<\/h2>\n<p>\nWenn keine Richtlinien festgelegt sind, erlaubt Kubernetes standardm\u00e4\u00dfig jeglichen Datenverkehr. Alle Pods k\u00f6nnen frei Informationen untereinander austauschen. Aus sicherheitstechnischer Sicht mag dies unlogisch erscheinen, aber bedenken Sie, dass Kubernetes urspr\u00fcnglich von Entwicklern entworfen wurde, um die Interoperabilit\u00e4t von Anwendungen zu f\u00f6rdern. Die Netzwerkrichtlinien wurden sp\u00e4ter hinzugef\u00fcgt.<\/p>\n<h2>Namespaces<\/h2>\n<p>\nNamespaces (Namensr\u00e4ume) sind ein Mechanismus f\u00fcr die Zusammenarbeit in Kubernetes. Sie dienen dazu, logische Umgebungen voneinander zu isolieren, wobei der Datenaustausch zwischen den Namensr\u00e4umen standardm\u00e4\u00dfig erlaubt ist.<\/p>\n<p>Wie die meisten Komponenten von Kubernetes gibt es Netzwerkrichtlinien innerhalb eines bestimmten Namensraums. Im Block <code>metadata<\/code> kann angegeben werden, zu welchem Namensraum die Richtlinie geh\u00f6rt:<\/p>\n<pre><code class=\"plaintext\">apiVersion: networking.k8s.io\/v1\nkind: NetworkPolicy\nmetadata:\n  name: test-network-policy\n  namespace: my-namespace  # &lt;&lt;&lt;\nspec:\n...<\/code><\/pre>\n<p>\nWenn der Namensraum in den Metadaten nicht ausdr\u00fccklich angegeben ist, verwendet das System den Namensraum, der in kubectl angegeben ist (standardm\u00e4\u00dfig <code>namespace=default<\/code>):<\/p>\n<pre><code class=\"bash\">kubectl apply -n my-namespace -f namespace.yaml<\/code><\/pre>\n<p>\nIch empfehle <b>den Namensraum ausdr\u00fccklich anzugeben<\/b>, es sei denn, Sie schreiben eine Richtlinie, die f\u00fcr mehrere Namespaces gleichzeitig g\u00fcltig ist.<\/p>\n<p><b>Haupt<\/b> Element <code>podSelector<\/code> In der Richtlinie werden Pods aus dem Namensraum ausgew\u00e4hlt, dem die Richtlinie angeh\u00f6rt (sie haben keinen Zugriff auf Pods aus einem anderen Namensraum).<\/p>\n<p>\u00c4hnlich wird der podSelector verwendet, <b>in Ingress- und Egress-Blocks<\/b> nur Pods aus ihrem eigenen Namespace ausw\u00e4hlen, es sei denn, Sie kombinieren sie mit <code>namespaceSelector<\/code> dar\u00fcber wird im Abschnitt \u201eFilter nach Namensr\u00e4umen und Pods\u201c gesprochen.<\/p>\n<h2>Namensgebung von Richtlinien<\/h2>\n<p>\nRichtliniennamen sind innerhalb eines einzelnen Namespaces einzigartig. Es kann keine zwei Richtlinien mit dem gleichen Namen in einem Namespace geben, aber es kann Richtlinien mit denselben Namen in verschiedenen Namespaces geben. Dies ist praktisch, wenn Sie dieselbe Richtlinie in mehreren Namespaces wiederverwenden m\u00f6chten.<\/p>\n<p>Besonders gef\u00e4llt mir eine der Methoden zur Namensgebung. Sie besteht darin, den Namen des Namespaces mit den Ziel-Pods zu kombinieren. Zum Beispiel:<\/p>\n<pre><code class=\"plaintext\">apiVersion: networking.k8s.io\/v1\nkind: NetworkPolicy\nmetadata:\n  name: default.postgres  # &lt;&lt;&lt;\n  namespace: default\nspec:\n  podSelector:\n    matchLabels:\n      app: postgres\n  ingress:\n  - from:\n    - podSelector:\n        matchLabels:\n          app: admin\n  policyTypes:\n  - Ingress<\/code><\/pre>\n<p>\n<img decoding=\"async\" alt=\"Einf\u00fchrung in die Netzwerkpolitik von Kubernetes f\u00fcr Sicherheitsexperten\" src=\"\/wp-content\/uploads\/2019\/04\/18318c320d6e37eeb01c51f251550639.png\" style=\"display:block;margin: 0 auto;\" \/><br \/>\n<\/p>\n<h2>Labels<\/h2>\n<p>\nBenutzerdefinierte Labels k\u00f6nnen an Kubernetes-Objekte wie Pods und Namespaces angeheftet werden. Labels (<i>labels<\/i> \u2014 Tags) sind das \u00c4quivalent von Tags in der Cloud. Kubernetes-Netzwerkrichtlinien verwenden Labels zur Auswahl <b>Pods,<\/b>, auf die sie angewendet werden:<\/p>\n<pre><code class=\"plaintext\">podSelector:\n  matchLabels:\n    role: db<\/code><\/pre>\n<p>\n\u2026 oder <b>Namespaces<\/b>auf die sie angewendet werden. In diesem Beispiel werden alle Pods in den Namensr\u00e4umen mit den entsprechenden Labels ausgew\u00e4hlt:<\/p>\n<pre><code class=\"plaintext\">namespaceSelector:\n  matchLabels:\n    project: myproject<\/code><\/pre>\n<p>\nEine Warnung: Bei der Verwendung von <code>namespaceSelector<\/code> <b>stellen Sie sicher, dass die ausgew\u00e4hlten Namespaces das erforderliche Label enthalten<\/b>. Bedenken Sie, dass systemeigene Namespaces wie <code>default<\/code> und <code>kube-system<\/code>, standardm\u00e4\u00dfig keine Labels enthalten.<\/p>\n<p>Ein Label kann zu einem Namespace wie folgt hinzugef\u00fcgt werden:<\/p>\n<pre><code class=\"bash\">kubectl label namespace default namespace=default<\/code><\/pre>\n<p>\nDabei sollte der Namespace im Abschnitt <code>metadata<\/code> auf den tats\u00e4chlichen Namen des Namespaces verweisen, nicht auf das Label:<\/p>\n<pre><code class=\"plaintext\">apiVersion: networking.k8s.io\/v1\nkind: NetworkPolicy\nmetadata:\n  name: test-network-policy\n  namespace: default   # &lt;&lt;&lt;\nspec:\n...<\/code><\/pre>\n<p><\/p>\n<h2>Quelle und Ziel<\/h2>\n<p>\nFirewall-Richtlinien bestehen aus Regeln mit Quellen und Empf\u00e4ngern. Kubernetes-Netzwerkrichtlinien werden f\u00fcr das Ziel definiert \u2013 eine Gruppe von Pods, auf die sie angewendet werden, und legen dann Regeln f\u00fcr den eingehenden (Ingress) und\/oder den ausgehenden (Egress) Datenverkehr fest. In unserem Beispiel wird das Ziel der Richtlinie alle Pods im Namensraum sein, <code>default<\/code> mit dem Label mit dem Schl\u00fcssel <code>app<\/code> und dem Wert <code>db<\/code>:<\/p>\n<pre><code class=\"plaintext\">apiVersion: networking.k8s.io\/v1\nkind: NetworkPolicy\nmetadata:\n  name: test-network-policy\n  namespace: default\nspec:\n  podSelector:\n    matchLabels:\n      app: db   # &lt;&lt;&lt;\n  policyTypes:\n  - Ingress\n  - Egress\n  ingress:\n  - from:\n    - ipBlock:\n        cidr: 172.17.0.0\/16\n        except:\n        - 172.17.1.0\/24\n    - namespaceSelector:\n        matchLabels:\n          project: myproject\n    - podSelector:\n        matchLabels:\n          role: frontend\n    ports:\n    - protocol: TCP\n      port: 6379\n  egress:\n  - to:\n    - ipBlock:\n        cidr: 10.0.0.0\/24\n    ports:\n    - protocol: TCP\n      port: 5978<\/code><\/pre>\n<p>\n<img decoding=\"async\" alt=\"Einf\u00fchrung in die Netzwerkpolitik von Kubernetes f\u00fcr Sicherheitsexperten\" src=\"\/wp-content\/uploads\/2019\/04\/5fcb3f78e26ae1ed5635541ad69ef69f.png\" style=\"display:block;margin: 0 auto;\" \/><br \/>\n<img decoding=\"async\" alt=\"Einf\u00fchrung in die Netzwerkpolitik von Kubernetes f\u00fcr Sicherheitsexperten\" src=\"\/wp-content\/uploads\/2019\/04\/c753f559ecc3ba54f8b55e29851428c4.png\" style=\"display:block;margin: 0 auto;\" \/><br \/>\n<br \/>\nAbschnitt <code>ingress<\/code> in dieser Richtlinie \u00f6ffnet den eingehenden Datenverkehr zu den Ziel-Pods. Mit anderen Worten, Ingress fungiert als Quelle und das Ziel als entsprechender Empf\u00e4nger. Ebenso ist Egress der Empf\u00e4nger, w\u00e4hrend das Ziel seine Quelle ist.<\/p>\n<p><img decoding=\"async\" alt=\"Einf\u00fchrung in die Netzwerkpolitik von Kubernetes f\u00fcr Sicherheitsexperten\" src=\"\/wp-content\/uploads\/2019\/04\/a0d865de57a7620849074424770832cd.png\" style=\"display:block;margin: 0 auto;\" \/><br \/>\n<br \/>\n<i>Dies entspricht zwei Regeln f\u00fcr die Firewall: Ingress \u2192 Ziel; Ziel \u2192 Egress.<\/i><\/p>\n<h2>Egress und DNS (wichtig!)<\/h2>\n<p>\nBei der Begrenzung des ausgehenden Datenverkehrs <b>sollten Sie besonders auf DNS achten.<\/b> \u2014 Kubernetes verwendet diesen Dienst, um Dienste mit IP-Adressen zu verkn\u00fcpfen. Zum Beispiel wird die folgende Richtlinie nicht funktionieren, da Sie der Anwendung nicht erlaubt haben, <code>balance<\/code> auf DNS zuzugreifen:<\/p>\n<pre><code class=\"plaintext\">apiVersion: networking.k8s.io\/v1\nkind: NetworkPolicy\nmetadata:\n  name: default.balance\n  namespace: default\nspec:\n  podSelector:\n    matchLabels:\n      app: balance\n  egress:\n  - to:\n    - podSelector:\n        matchLabels:\n          app: postgres\n  policyTypes:\n  - Egress<\/code><\/pre>\n<p>\n<img decoding=\"async\" alt=\"Einf\u00fchrung in die Netzwerkpolitik von Kubernetes f\u00fcr Sicherheitsexperten\" src=\"\/wp-content\/uploads\/2019\/04\/5857a44cc5e06de708f0d3b5b0f49628.png\" style=\"display:block;margin: 0 auto;\" \/><br \/>\n<br \/>\nSie k\u00f6nnen dies beheben, indem Sie den Zugriff auf den DNS-Dienst \u00f6ffnen:<\/p>\n<pre><code class=\"plaintext\">apiVersion: networking.k8s.io\/v1\nkind: NetworkPolicy\nmetadata:\n  name: default.balance\n  namespace: default\nspec:\n  podSelector:\n    matchLabels:\n      app: balance\n  egress:\n  - to:\n    - podSelector:\n        matchLabels:\n          app: postgres\n  - to:               # &lt;&lt;,&lt;\n    ports:            # &lt;&lt;,&lt;\n    - protocol: UDP   # &lt;&lt;,&lt;\n      port: 53        # &lt;&lt;,&lt;\n  policyTypes:\n  - Egress<\/code><\/pre>\n<p>\n<img decoding=\"async\" alt=\"Einf\u00fchrung in die Netzwerkpolitik von Kubernetes f\u00fcr Sicherheitsexperten\" src=\"\/wp-content\/uploads\/2019\/04\/a396bb2ae94fca94c3b62aef2cb07552.png\" style=\"display:block;margin: 0 auto;\" \/><br \/>\n<br \/>\nDas letzte Element <code>zu<\/code> \u2014 leer und w\u00e4hlt somit indirekt <b>alle Pods in allen Namensr\u00e4umen.<\/b>, wodurch <code>balance<\/code> DNS-Anfragen an den entsprechenden Kubernetes-Dienst gesendet werden (dieser l\u00e4uft normalerweise im Namespace <code>kube-system<\/code>).<\/p>\n<p>Dieser Ansatz funktioniert, ist jedoch <b>\u00fcberm\u00e4\u00dfig permissiv und unsicher<\/b>, da es erm\u00f6glicht, DNS-Anfragen au\u00dferhalb des Clusters zu senden.<\/p>\n<p>Sie k\u00f6nnen es in drei aufeinanderfolgenden Schritten verbessern.<\/p>\n<p>1. Erlauben Sie DNS-Anfragen nur <b>innerhalb<\/b> des Clusters, indem Sie <code>namespaceSelector<\/code>:<\/p>\n<pre><code class=\"plaintext\">apiVersion: networking.k8s.io\/v1\nkind: NetworkPolicy\nmetadata:\n  name: default.balance\n  namespace: default\nspec:\n  podSelector:\n    matchLabels:\n      app: balance\n  egress:\n  - to:\n    - podSelector:\n        matchLabels:\n          app: postgres\n  - to:\n    - namespaceSelector: {} # &lt;&lt;&lt;\n    ports:\n    - protocol: UDP\n      port: 53\n  policyTypes:\n  - Egress<\/code><\/pre>\n<p>\n<img decoding=\"async\" alt=\"Einf\u00fchrung in die Netzwerkpolitik von Kubernetes f\u00fcr Sicherheitsexperten\" src=\"\/wp-content\/uploads\/2019\/04\/5920a043229676e0780d691d302c5ade.png\" style=\"display:block;margin: 0 auto;\" \/><br \/>\n<br \/>\n2. Erlauben Sie DNS-Abfragen nur im Namespace <code>kube-system<\/code>.<\/p>\n<p>Dazu muss ein Label zum Namespace hinzugef\u00fcgt werden <code>kube-system<\/code>: <code>kubectl label namespace kube-system namespace=kube-system<\/code> \u2014 und es in die Richtlinie eingetragen werden <code>namespaceSelector<\/code>:<\/p>\n<pre><code class=\"plaintext\">apiVersion: networking.k8s.io\/v1\nkind: NetworkPolicy\nmetadata:\n  name: default.balance\n  namespace: default\nspec:\n  podSelector:\n    matchLabels:\n      app: balance\n  egress:\n  - to:\n    - podSelector:\n        matchLabels:\n          app: postgres\n  - to:\n    - namespaceSelector:         # &lt;&lt;&lt;\n        matchLabels:             # &lt;&lt;&lt;\n          namespace: kube-system # &lt;&lt;&lt;\n    ports:\n    - protocol: UDP\n      port: 53\n  policyTypes:\n  - Egress<\/code><\/pre>\n<p>\n<img decoding=\"async\" alt=\"Einf\u00fchrung in die Netzwerkpolitik von Kubernetes f\u00fcr Sicherheitsexperten\" src=\"\/wp-content\/uploads\/2019\/04\/2a1dd0975c58e6d277baffc7c3ac6e48.png\" style=\"display:block;margin: 0 auto;\" \/><br \/>\n<br \/>\n3. Paranoide k\u00f6nnen noch weiter gehen und die DNS-Abfragen auf einen bestimmten DNS-Dienst beschr\u00e4nken <code>kube-system<\/code>Im Abschnitt \u201eFilter nach Namensr\u00e4umen und Pods\u201c erfahren Sie, wie dies zu erreichen ist.<\/p>\n<p>Eine andere M\u00f6glichkeit besteht darin, DNS auf Namespace-Ebene zu erlauben. In diesem Fall muss es nicht f\u00fcr jeden Dienst ge\u00f6ffnet werden:<\/p>\n<pre><code class=\"plaintext\">apiVersion: networking.k8s.io\/v1\nkind: NetworkPolicy\nmetadata:\n  name: default.dns\n  namespace: default\nspec:\n  podSelector: {} # &lt;&lt;&lt;\n  egress:\n  - to:\n    - namespaceSelector: {}\n    ports:\n    - protocol: UDP\n      port: 53\n  policyTypes:\n  - Egress<\/code><\/pre>\n<p>\nLeer <code>podSelector<\/code> w\u00e4hlt alle Pods im Namensraum aus.<\/p>\n<p><img decoding=\"async\" alt=\"Einf\u00fchrung in die Netzwerkpolitik von Kubernetes f\u00fcr Sicherheitsexperten\" src=\"\/wp-content\/uploads\/2019\/04\/5d6b627b69da980477b3910fbf4de6c1.png\" style=\"display:block;margin: 0 auto;\" \/><br \/>\n<\/p>\n<h2>Erstes \u00dcbereinstimmung und Regelreihenfolge<\/h2>\n<p>\nIn herk\u00f6mmlichen Firewalls wird die Aktion (\u201eErlauben\u201c oder \u201eVerbieten\u201c) f\u00fcr ein Paket durch die erste Regel bestimmt, die erf\u00fcllt wird. <b>In Kubernetes spielt die Reihenfolge der Richtlinien keine Rolle.<\/b><\/p>\n<p>Standardm\u00e4\u00dfig sind, wenn keine Richtlinien festgelegt sind, die Kommunikationen zwischen Pods erlaubt, und sie k\u00f6nnen frei Informationen austauschen. Sobald Sie jedoch beginnen, Richtlinien zu formulieren, wird jeder Pod, der von einer dieser Richtlinien betroffen ist, entsprechend der Disjunktion (logisches ODER) aller Richtlinien isoliert, die ihn betreffen. Pods, die von keiner Richtlinie betroffen sind, bleiben offen.<\/p>\n<p>Solches Verhalten kann durch eine Bereinigungregel ge\u00e4ndert werden.<\/p>\n<h2>Bereinigungsregel (\u201eVerbieten\u201c)<\/h2>\n<p>\nFirewall-Richtlinien verbieten in der Regel jeglichen ausdr\u00fccklich nicht erlaubten Verkehr.<\/p>\n<p><b>In Kubernetes gibt es keine Aktion \u201everbieten\u201c (deny),<\/b>, jedoch kann ein \u00e4hnlicher Effekt mit einer allgemeinen (erlaubenden) Richtlinie erzielt werden, indem eine leere Gruppe von Quell-Pods (ingress) ausgew\u00e4hlt wird:<\/p>\n<pre><code class=\"plaintext\">apiVersion: networking.k8s.io\/v1\nkind: NetworkPolicy\nmetadata:\n  name: deny-all\n  namespace: default\nspec:\n  podSelector: {}\n  policyTypes:\n  - Ingress<\/code><\/pre>\n<p>\n<img decoding=\"async\" alt=\"Einf\u00fchrung in die Netzwerkpolitik von Kubernetes f\u00fcr Sicherheitsexperten\" src=\"\/wp-content\/uploads\/2019\/04\/8b3ced50ec5a1de70940d53f467966fe.png\" style=\"display:block;margin: 0 auto;\" \/><br \/>\n<br \/>\nDiese Richtlinie w\u00e4hlt alle Pods im Namensraum aus und l\u00e4sst ingress undefiniert, wodurch jeglicher eingehender Verkehr verboten wird.<\/p>\n<p>In \u00e4hnlicher Weise kann der gesamte ausgehende Verkehr aus dem Namensraum eingeschr\u00e4nkt werden:<\/p>\n<pre><code class=\"plaintext\">apiVersion: networking.k8s.io\/v1\nkind: NetworkPolicy\nmetadata:\n  name: deny-all-egress\n  namespace: default\nspec:\n  podSelector: {}\n  policyTypes:\n  - Egress<\/code><\/pre>\n<p>\n<img decoding=\"async\" alt=\"Einf\u00fchrung in die Netzwerkpolitik von Kubernetes f\u00fcr Sicherheitsexperten\" src=\"\/wp-content\/uploads\/2019\/04\/be22e11efef0098f2665331c09d748f2.png\" style=\"display:block;margin: 0 auto;\" \/><br \/>\n<br \/>\nBitte beachten Sie, dass <b>Alle zus\u00e4tzlichen Richtlinien, die Verkehr zu Pods im Namensraum erlauben, haben Vorrang vor dieser Regel.<\/b> (vergleichbar mit dem Hinzuf\u00fcgen einer Erlaubungsregel vor einer Verweigerungsregel in der Firewall-Konfiguration).<\/p>\n<h2>Alle erlauben (Any-Any-Any-Allow)<\/h2>\n<p>\nUm eine \"Alle erlauben\"-Richtlinie zu erstellen, muss die oben genannte Verweigerungsrichtlinie mit einem leeren Element erg\u00e4nzt werden. <code>ingress<\/code>:<\/p>\n<pre><code class=\"plaintext\">apiVersion: networking.k8s.io\/v1\nkind: NetworkPolicy\nmetadata:\n  name: allow-all\n  namespace: default\nspec:\n  podSelector: {}\n  ingress: # &lt;&lt;&lt;\n  - {}     # &lt;&lt;&lt;\n  policyTypes:\n  - Ingress<\/code><\/pre>\n<p>\n<img decoding=\"async\" alt=\"Einf\u00fchrung in die Netzwerkpolitik von Kubernetes f\u00fcr Sicherheitsexperten\" src=\"\/wp-content\/uploads\/2019\/04\/7322351493211388fe772b8dc270108d.png\" style=\"display:block;margin: 0 auto;\" \/><br \/>\n<br \/>\nSie erm\u00f6glicht den Zugriff von <b>Alle Pods in allen Namensr\u00e4umen (und allen IPs) zu einem beliebigen Pod im Namensraum. <code>default<\/code><\/b>. Dieses Verhalten ist standardm\u00e4\u00dfig aktiviert, daher muss es normalerweise nicht zus\u00e4tzlich definiert werden. In einigen F\u00e4llen kann es jedoch erforderlich sein, bestimmte Erlaubnisse vor\u00fcbergehend zu deaktivieren, um ein Problem zu diagnostizieren.<\/p>\n<p>Die Regel kann eingeschr\u00e4nkt und der Zugang nur zu <b>einer bestimmten Gruppe von Pods.<\/b> (<code>app:balance<\/code>) im Namensraum <code>default<\/code>:<\/p>\n<pre><code class=\"plaintext\">apiVersion: networking.k8s.io\/v1\nkind: NetworkPolicy\nmetadata:\n  name: allow-all-to-balance\n  namespace: default\nspec:\n  podSelector:\n    matchLabels:\n      app: balance\n  ingress: \n  - {}\n  policyTypes:\n  - Ingress<\/code><\/pre>\n<p>\n<img decoding=\"async\" alt=\"Einf\u00fchrung in die Netzwerkpolitik von Kubernetes f\u00fcr Sicherheitsexperten\" src=\"\/wp-content\/uploads\/2019\/04\/d8c9cb85003f489acec815d1c2b53497.png\" style=\"display:block;margin: 0 auto;\" \/><br \/>\n<br \/>\nDie folgende Richtlinie erlaubt den gesamten eingehenden (ingress) und ausgehenden (egress) Verkehr, einschlie\u00dflich Zugriff auf jede IP au\u00dferhalb des Clusters:<\/p>\n<pre><code class=\"plaintext\">apiVersion: networking.k8s.io\/v1\nkind: NetworkPolicy\nmetadata:\n  name: allow-all\nspec:\n  podSelector: {}\n  ingress:\n  - {}\n  egress:\n  - {}\n  policyTypes:\n  - Ingress\n  - Egress<\/code><\/pre>\n<p>\n<img decoding=\"async\" alt=\"Einf\u00fchrung in die Netzwerkpolitik von Kubernetes f\u00fcr Sicherheitsexperten\" src=\"\/wp-content\/uploads\/2019\/04\/2477f18d3d228f80bc5169d9ec3be2fc.png\" style=\"display:block;margin: 0 auto;\" \/><br \/>\n<img decoding=\"async\" alt=\"Einf\u00fchrung in die Netzwerkpolitik von Kubernetes f\u00fcr Sicherheitsexperten\" src=\"\/wp-content\/uploads\/2019\/04\/3502b892713cdac8850e812b2eff3ea3.png\" style=\"display:block;margin: 0 auto;\" \/><br \/>\n<\/p>\n<h2>Kombination mehrerer Richtlinien<\/h2>\n<p>\nRichtlinien werden durch logisches ODER auf drei Ebenen kombiniert; die Berechtigungen jedes Pods werden entsprechend der Disjunktion aller Richtlinien festgelegt, die ihn betreffen:<\/p>\n<p>1. In den Feldern <code>from<\/code> und <code>zu<\/code> k\u00f6nnen drei Typen von Elementen definiert werden (alle werden durch ODER kombiniert):<\/p>\n<ul>\n<li> <code>namespaceSelector<\/code> \u2014 w\u00e4hlt den Namensraum vollst\u00e4ndig aus;<\/li>\n<li> <code>podSelector<\/code> \u2014 w\u00e4hlt Pods aus;<\/li>\n<li> <code>ipBlock<\/code> \u2014 w\u00e4hlt das Subnetz aus.<\/li>\n<\/ul>\n<p>\nDie Anzahl der Elemente (auch identische) in den Unterbereichen <code>from<\/code>\/<code>zu<\/code> ist dabei nicht begrenzt. Alle werden durch logisches ODER kombiniert.<\/p>\n<pre><code class=\"plaintext\">apiVersion: networking.k8s.io\/v1\nkind: NetworkPolicy\nmetadata:\n  name: default.postgres\n  namespace: default\nspec:\n  ingress:\n  - from:\n    - podSelector:\n        matchLabels:\n          app: indexer\n    - podSelector:\n        matchLabels:\n          app: admin\n  podSelector:\n    matchLabels:\n      app: postgres\n  policyTypes:\n  - Ingress<\/code><\/pre>\n<p>\n<img decoding=\"async\" alt=\"Einf\u00fchrung in die Netzwerkpolitik von Kubernetes f\u00fcr Sicherheitsexperten\" src=\"\/wp-content\/uploads\/2019\/04\/717e745720f39260a8508fb2b2bb6f65.png\" style=\"display:block;margin: 0 auto;\" \/><br \/>\n<br \/>\n2. Im Abschnitt der Richtlinie <code>ingress<\/code> kann es mehrere Elemente geben <code>from<\/code> (die durch eine logische ODER-Verkn\u00fcpfung verbunden sind). Ebenso kann der Abschnitt <code>egress<\/code> viele Elemente enthalten <code>zu<\/code> (die ebenfalls durch Disjunktion verbunden sind):<\/p>\n<pre><code class=\"plaintext\">apiVersion: networking.k8s.io\/v1\nkind: NetworkPolicy\nmetadata:\n  name: default.postgres\n  namespace: default\nspec:\n  ingress:\n  - from:\n    - podSelector:\n        matchLabels:\n          app: indexer\n  - from:\n    - podSelector:\n        matchLabels:\n          app: admin\n  podSelector:\n    matchLabels:\n      app: postgres\n  policyTypes:\n  - Ingress<\/code><\/pre>\n<p>\n<img decoding=\"async\" alt=\"Einf\u00fchrung in die Netzwerkpolitik von Kubernetes f\u00fcr Sicherheitsexperten\" src=\"\/wp-content\/uploads\/2019\/04\/b579e1f4b97acd92fb38cd6703aa1983.png\" style=\"display:block;margin: 0 auto;\" \/><br \/>\n<br \/>\n3. Verschiedene Richtlinien werden ebenfalls durch logische ODER-Verkn\u00fcpfung kombiniert<\/p>\n<p>Es gibt jedoch eine Einschr\u00e4nkung, die bei deren Kombination <noindex><a rel=\"nofollow\" href=\"https:\/\/medium.com\/sainsburys-engineering\/considerations-with-k8s-networkpolicy-cee7eacf5469\">erw\u00e4hnt wurde<\/a><\/noindex> <noindex><a rel=\"nofollow\" href=\"https:\/\/medium.com\/@chriscooney\">Chris Cooney<\/a><\/noindex>: Kubernetes kann Richtlinien nur mit unterschiedlichen <code>policyTypes<\/code> (<code>Ingress<\/code> oder <code>Egress<\/code>). Richtlinien, die ingress (oder egress) definieren, \u00fcberschreiben sich gegenseitig.<\/p>\n<h2>Kommunikation zwischen Namespaces<\/h2>\n<p>\nStandardm\u00e4\u00dfig ist der Informationsaustausch zwischen Namespaces erlaubt. Dies kann durch eine einschr\u00e4nkende Richtlinie ge\u00e4ndert werden, die den ausgehenden und\/oder eingehenden Datenverkehr in den Namespace einschr\u00e4nkt (siehe \u201eCleanup-Regel\u201c oben).<\/p>\n<p>Durch das Blockieren des Zugriffs auf den Namensraum (siehe \u201eBereinigungsregel\u201c oben) k\u00f6nnen Sie Ausnahmen in die Sperrpolitik einf\u00fcgen, indem Sie Verbindungen aus einem bestimmten Namensraum erlauben mit <code>namespaceSelector<\/code>:<\/p>\n<pre><code class=\"plaintext\">apiVersion: networking.k8s.io\/v1\nkind: NetworkPolicy\nmetadata:\n  name: database.postgres\n  namespace: database\nspec:\n  podSelector:\n    matchLabels:\n      app: postgres\n  ingress:\n  - from:\n    - namespaceSelector:\n        matchLabels:\n          namespace: default\n  policyTypes:\n  - Ingress<\/code><\/pre>\n<p>\n<img decoding=\"async\" alt=\"Einf\u00fchrung in die Netzwerkpolitik von Kubernetes f\u00fcr Sicherheitsexperten\" src=\"\/wp-content\/uploads\/2019\/04\/5a3d2baed1ff9b813ef0651fe500ad8a.png\" style=\"display:block;margin: 0 auto;\" \/><br \/>\n<br \/>\nInfolgedessen erhalten alle Pods im Namensraum <code>default<\/code> erhalten Zugang zu Pods. <code>postgres<\/code> im Namespace <code>database<\/code>. Aber was, wenn Sie nur bestimmten Pods im Namensraum Zugriff gew\u00e4hren m\u00f6chten? <code>postgres<\/code> nur spezifische Pods im Namespace <code>default<\/code>?<\/p>\n<h2>Filter nach Namespaces und Pods<\/h2>\n<p>\nmit logischem UND zu kombinieren. So sieht es aus: <code>namespaceSelector<\/code> und <code>podSelector<\/code> apiVersion: networking.k8s.io\/v1\nkind: NetworkPolicy\nmetadata:\n  name: database.postgres\n  namespace: database\nspec:\n  podSelector:\n    matchLabels:\n      app: postgres\n  ingress:\n  - from:\n    - namespaceSelector:\n        matchLabels:\n          namespace: default\n      podSelector:\n        matchLabels:\n          app: admin\n  policyTypes:\n  - Ingress<\/p>\n<pre><code class=\"plaintext\">Warum wird dies als UND und nicht als \u00fcbliches ODER interpretiert?<\/code><\/pre>\n<p>\n<img decoding=\"async\" alt=\"Einf\u00fchrung in die Netzwerkpolitik von Kubernetes f\u00fcr Sicherheitsexperten\" src=\"\/wp-content\/uploads\/2019\/04\/e933e449d9f9c10505e45930d1477b2c.png\" style=\"display:block;margin: 0 auto;\" \/><br \/>\n<br \/>\nBeachten Sie, dass<\/p>\n<p>nicht mit einem Bindestrich beginnt. In YAML bedeutet dies, dass <code>podSelector<\/code> und das davorstehende <code>podSelector<\/code> und vor ihm stehend <code>namespaceSelector<\/code> geh\u00f6ren zu dasselbe Listenelement. Daher werden sie logisch mit UND kombiniert.<\/p>\n<p>Das Hinzuf\u00fcgen eines Bindestrichs vor <code>podSelector<\/code> f\u00fchrt zur Erzeugung eines neuen Listenelements, das mit dem vorhergehenden kombiniert wird <code>namespaceSelector<\/code> mittels logischem ODER.<\/p>\n<p>Um Pods mit einem bestimmten Label auszuw\u00e4hlen <b>in allen Namensr\u00e4umen<\/b>, geben Sie ein leeres <code>namespaceSelector<\/code>:<\/p>\n<pre><code class=\"plaintext\">apiVersion: networking.k8s.io\/v1\nkind: NetworkPolicy\nmetadata:\n  name: database.postgres\n  namespace: database\nspec:\n  podSelector:\n    matchLabels:\n      app: postgres\n  ingress:\n  - from:\n    - namespaceSelector: {}\n      podSelector:\n        matchLabels:\n          app: admin\n  policyTypes:\n  - Ingress<\/code><\/pre>\n<p>\n<img decoding=\"async\" alt=\"Einf\u00fchrung in die Netzwerkpolitik von Kubernetes f\u00fcr Sicherheitsexperten\" src=\"\/wp-content\/uploads\/2019\/04\/e79e4a8067fa254f85fa8be105c3ad34.png\" style=\"display:block;margin: 0 auto;\" \/><br \/>\n<\/p>\n<h2>Mehrere Labels werden mit UND kombiniert<\/h2>\n<p>\nRegeln f\u00fcr die Firewall mit mehreren Objekten (Hosts, Netzwerken, Gruppen) werden mit logischen ODER kombiniert. Die folgende Regel funktioniert, wenn die Quelle des Pakets \u00fcbereinstimmt mit <code>Host_1<\/code> ODER <code>Host_2<\/code>:<\/p>\n<pre><code class=\"plaintext\">| Quelle | Ziel | Dienst | Aktion |\n| ----------------------------------------|\n| Host_1 | Subnetz_A | HTTPS | Erlauben |\n| Host_2 |             |         |        |\n| ----------------------------------------|<\/code><\/pre>\n<p>\nIm Gegensatz dazu werden in Kubernetes verschiedene Labels in <code>podSelector<\/code> oder <code>namespaceSelector<\/code> logisch mit UND kombiniert. Zum Beispiel w\u00e4hlt die folgende Regel Pods aus, die beide Labels haben, <code>role=db<\/code> Und <code>version=v2<\/code>:<\/p>\n<pre><code class=\"plaintext\">podSelector:\n  matchLabels:\n    role: db\n    version: v2<\/code><\/pre>\n<p>\nDie gleiche Logik gilt f\u00fcr alle Arten von Operatoren: Zielen der Richtlinienauswahl, Pod-W\u00e4hlern und Namespace-W\u00e4hlern.<\/p>\n<h2>Subnetze und IP-Adressen (IPBlocks)<\/h2>\n<p>\nZur Segmentierung des Netzwerks verwenden Firewalls VLANs, IP-Adressen und Subnetze.<\/p>\n<p>In Kubernetes werden IP-Adressen automatisch Pods zugewiesen und k\u00f6nnen sich h\u00e4ufig \u00e4ndern; daher werden Labels zur Auswahl von Pods und Namespaces in Netzwerkrichtlinien verwendet.<\/p>\n<p>Subnetze (<code>ipBlocks<\/code>) werden bei der Verwaltung eingehender (Ingress) oder ausgehender (Egress) externer (North-South) Verbindungen verwendet. Zum Beispiel er\u00f6ffnet diese Richtlinie allen Pods im Namespace <code>default<\/code> Zugriff auf den DNS-Dienst von Google:<\/p>\n<pre><code class=\"plaintext\">apiVersion: networking.k8s.io\/v1\nkind: NetworkPolicy\nmetadata:\n  name: egress-dns\n  namespace: default\nspec:\n  podSelector: {}\n  policyTypes:\n  - Egress\n  egress:\n  - to:\n    - ipBlock:\n        cidr: 8.8.8.8\/32\n    ports:\n    - protocol: UDP\n      port: 53<\/code><\/pre>\n<p>\n<img decoding=\"async\" alt=\"Einf\u00fchrung in die Netzwerkpolitik von Kubernetes f\u00fcr Sicherheitsexperten\" src=\"\/wp-content\/uploads\/2019\/04\/42e1194e28331e667a094f19c88e0934.png\" style=\"display:block;margin: 0 auto;\" \/><br \/>\n<br \/>\nEin leerer Pod-Selector in diesem Beispiel bedeutet \u201ew\u00e4hle alle Pods im Namespace\u201c.<\/p>\n<p>Diese Richtlinie erlaubt nur den Zugriff auf 8.8.8.8; der Zugriff auf jede andere IP ist verboten. Somit haben Sie im Grunde den Zugriff auf den internen Kubernetes DNS-Dienst blockiert. Wenn Sie diesen jedoch \u00f6ffnen m\u00f6chten, geben Sie dies explizit an.<\/p>\n<p>Normalerweise <code>ipBlocks<\/code> und <code>podSelectors<\/code> sind gegenseitig ausschlie\u00dfend, da interne IP-Adressen von Pods nicht in <code>ipBlocks<\/code>. Wenn Sie <b>internen IPs von Pods<\/b>, erlauben Sie tats\u00e4chlich Verbindungen zu\/von Pods mit diesen Adressen. In der Praxis werden Sie nicht wissen, welche IP-Adresse zu verwenden ist, weshalb sie nicht zur Auswahl von Pods verwendet werden sollten.<\/p>\n<p>Als Gegenbeispiel umfasst die folgende Richtlinie alle IP-Adressen und erlaubt somit den Zugang zu allen anderen Pods:<\/p>\n<pre><code class=\"plaintext\">apiVersion: networking.k8s.io\/v1\nkind: NetworkPolicy\nmetadata:\n  name: egress-any\n  namespace: default\nspec:\n  podSelector: {}\n  policyTypes:\n  - Egress\n  egress:\n  - to:\n    - ipBlock:\n        cidr: 0.0.0.0\/0<\/code><\/pre>\n<p>\n<img decoding=\"async\" alt=\"Einf\u00fchrung in die Netzwerkpolitik von Kubernetes f\u00fcr Sicherheitsexperten\" src=\"\/wp-content\/uploads\/2019\/04\/d99dfdead1c96b071b1643cb5c572878.png\" style=\"display:block;margin: 0 auto;\" \/><br \/>\n<br \/>\nMan kann den Zugang nur zu externen IP-Adressen \u00f6ffnen und die internen IP-Adressen der Pods ausschlie\u00dfen. Zum Beispiel, wenn das Subnetz Ihres Pods 10.16.0.0\/14 ist:<\/p>\n<pre><code class=\"plaintext\">apiVersion: networking.k8s.io\/v1\nkind: NetworkPolicy\nmetadata:\n  name: egress-any\n  namespace: default\nspec:\n  podSelector: {}\n  policyTypes:\n  - Egress\n  egress:\n  - to:\n    - ipBlock:\n        cidr: 0.0.0.0\/0\n        except:\n        - 10.16.0.0\/14<\/code><\/pre>\n<p>\n<img decoding=\"async\" alt=\"Einf\u00fchrung in die Netzwerkpolitik von Kubernetes f\u00fcr Sicherheitsexperten\" src=\"\/wp-content\/uploads\/2019\/04\/b157cfe0f1cd4677cf0defd9fdfa8a13.png\" style=\"display:block;margin: 0 auto;\" \/><br \/>\n<\/p>\n<h2>Ports und Protokolle<\/h2>\n<p>\nIn der Regel lauschen Pods auf einem Port. Das bedeutet, dass man die Portnummern in den Richtlinien einfach weglassen und alles auf die Standardwerte setzen kann. Es wird jedoch empfohlen, die Richtlinien m\u00f6glichst restriktiv zu gestalten, weshalb man in einigen F\u00e4llen dennoch Ports angeben kann:<\/p>\n<pre><code class=\"plaintext\">apiVersion: networking.k8s.io\/v1\nkind: NetworkPolicy\nmetadata:\n  name: default.postgres\n  namespace: default\nspec:\n  ingress:\n  - from:\n    - podSelector:\n        matchLabels:\n          app: indexer\n    - podSelector:\n        matchLabels:\n          app: admin\n    ports:\n      - port: 443\n        protocol: TCP\n      - port: 80\n        protocol: TCP\n  podSelector:\n    matchLabels:\n      app: postgres\n  policyTypes:\n  - Ingress<\/code><\/pre>\n<p>\n<img decoding=\"async\" alt=\"Einf\u00fchrung in die Netzwerkpolitik von Kubernetes f\u00fcr Sicherheitsexperten\" src=\"\/wp-content\/uploads\/2019\/04\/4c778cd46c54e2ae0f4527ffa9e1e740.png\" style=\"display:block;margin: 0 auto;\" \/><br \/>\n<br \/>\nBitte beachten Sie, dass der Selektor <code>ports<\/code> auf alle Elemente im Block angewendet wird, in dem er enthalten ist. Um verschiedene Ports f\u00fcr unterschiedliche Sets von Elementen anzugeben, unterteilen Sie <code>zu<\/code> oder <code>from<\/code>in mehrere Unterabschnitte mit <code>ingress<\/code> oder <code>egress<\/code> und geben Sie in jedem Ihre Ports an: <code>zu<\/code> oder <code>from<\/code> und trag deine Ports in jede ein:<\/p>\n<pre><code class=\"plaintext\">apiVersion: networking.k8s.io\/v1\nkind: NetworkPolicy\nmetadata:\n  name: default.postgres\n  namespace: default\nspec:\n  ingress:\n  - from:\n    - podSelector:\n        matchLabels:\n          app: indexer\n    ports:\n     - port: 443\n       protocol: TCP\n  - from:\n    - podSelector:\n        matchLabels:\n          app: admin\n    ports:\n     - port: 80\n       protocol: TCP\n  podSelector:\n    matchLabels:\n      app: postgres\n  policyTypes:\n  - Ingress<\/code><\/pre>\n<p>\n<img decoding=\"async\" alt=\"Einf\u00fchrung in die Netzwerkpolitik von Kubernetes f\u00fcr Sicherheitsexperten\" src=\"\/wp-content\/uploads\/2019\/04\/b9ac1d8af491e992cac0be184005a278.png\" style=\"display:block;margin: 0 auto;\" \/><br \/>\n<br \/>\nStandardverhalten der Ports:<\/p>\n<ul>\n<li> Wenn Sie die Portdefinition vollst\u00e4ndig weglassen (<code>ports<\/code>), bedeutet dies alle Protokolle und alle Ports;<\/li>\n<li> Wenn Sie die Protokolldefinition weglassen (<code>protocol<\/code>), bedeutet dies TCP;<\/li>\n<li> Wenn Sie die Portdefinition weglassen (<code>port<\/code>), bedeutet dies alle Ports.<\/li>\n<\/ul>\n<p>\nBeste Praxis: Verlassen Sie sich nicht auf Standardwerte, geben Sie die erforderlichen Werte explizit an.<\/p>\n<p>Bitte beachten Sie, dass die Ports der Pods und nicht die der Dienste verwendet werden m\u00fcssen (weiterf\u00fchrende Informationen dazu im n\u00e4chsten Absatz).<\/p>\n<h2>Sind die Richtlinien f\u00fcr Pods oder f\u00fcr Dienste definiert?<\/h2>\n<p>\nIn der Regel kommunizieren Pods in Kubernetes \u00fcber Dienste \u2013 einen virtuellen Lastenausgleich, der den Datenverkehr zu den Pods leitet, die den Dienst bereitstellen. Man k\u00f6nnte denken, dass die Netzwerkrichtlinien den Zugang zu den Diensten kontrollieren, aber das ist nicht der Fall. <b>Die Netzwerkrichtlinien von Kubernetes arbeiten mit den Ports der Pods und nicht mit denen der Dienste.<\/b><\/p>\n<p>Wenn ein Dienst beispielsweise Port 80 h\u00f6rt, aber den Verkehr an Port 8080 seiner Pods weiterleitet, muss in der Netzwerkrichtlinie ausdr\u00fccklich Port 8080 angegeben werden.<\/p>\n<p>Ein solches Verfahren ist als suboptimal zu betrachten: Bei \u00c4nderungen der internen Struktur des Dienstes (dessen Ports von den Pods \u00fcberwacht werden) m\u00fcssen die Netzwerkrichtlinien aktualisiert werden.<\/p>\n<p>Ein neuer architektonischer Ansatz mit Service Mesh <i>(siehe beispielsweise unten zu Istio \u2014 Anm. der \u00dcbers.)<\/i> hilft, dieses Problem zu l\u00f6sen.<\/p>\n<h2>M\u00fcssen sowohl Ingress als auch Egress angegeben werden?<\/h2>\n<p>\nDie kurze Antwort ist ja: Damit Pod A mit Pod B kommunizieren kann, muss es die Erlaubnis haben, eine ausgehende Verbindung herzustellen (dazu ist die Konfiguration einer Egress-Policy erforderlich), und Pod B muss die M\u00f6glichkeit haben, eine eingehende Verbindung entgegenzunehmen (hierf\u00fcr ist eine Ingress-Policy notwendig).<\/p>\n<p>In der Praxis kann man jedoch auf die Standardrichtlinie vertrauen, die Verbindungen in eine oder beide Richtungen erlaubt.<\/p>\n<p>Wenn ein Pod<b>Quelle<\/b> von einer oder mehreren <b>egress<\/b>-Richtlinien ausgew\u00e4hlt wird, bestimmen die auferlegten Einschr\u00e4nkungen deren Disjunktion. In diesem Fall muss die Verbindung zu dem Pod<b>-Ziel<\/b>explizit erlaubt werden. Wenn ein Pod nicht von einer Richtlinie ausgew\u00e4hlt wird, ist sein ausgehender (Egress-) Datenverkehr standardm\u00e4\u00dfig erlaubt.<\/p>\n<p>\u00c4hnlich wird das Schicksal des Pods-<b>-Ziel<\/b>, der von einer oder mehreren <b>ingress<\/b>-Politiken durch ihre Disjunktion bestimmt. In diesem Fall muss ihm ausdr\u00fccklich erlaubt werden, Verkehr von dem Pods-Quelle zu empfangen. Wenn der Pod von keiner Richtlinie ausgew\u00e4hlt wird, ist der gesamte eingehende (Ingress-) Verkehr standardm\u00e4\u00dfig f\u00fcr ihn erlaubt.<\/p>\n<p>Siehe Punkt \"Stateful oder Stateless\" unten.<\/p>\n<h2>Protokolle<\/h2>\n<p>\nDie Netzwerkpolicy von Kubernetes kann den Datenverkehr nicht protokollieren. Das erschwert die Feststellung, ob die Richtlinie ordnungsgem\u00e4\u00df funktioniert und kompliziert die Sicherheitsanalysen erheblich.<\/p>\n<h2>\u00dcberwachung des Datenverkehrs zu externen Diensten<\/h2>\n<p>\nDie Netzwerkpolicy von Kubernetes erlaubt es nicht, einen vollwertigen Domainnamen (DNS) in den Egress-Abschnitten anzugeben. Dies f\u00fchrt zu erheblichen Unannehmlichkeiten, wenn versucht wird, den Datenverkehr zu externen Adressen ohne feste IP-Adresse (wie aws.com) einzuschr\u00e4nken.<\/p>\n<h2>Richtlinienpr\u00fcfung<\/h2>\n<p>\nFirewalls werden Sie warnen oder sogar eine fehlerhafte Richtlinie zur\u00fcckweisen. Kubernetes f\u00fchrt ebenfalls eine gewisse \u00dcberpr\u00fcfung durch. Wenn Sie eine Netzwerkpolicy \u00fcber kubectl festlegen, kann Kubernetes angeben, dass sie fehlerhaft ist und die Annahme verweigern. In anderen F\u00e4llen akzeptiert Kubernetes die Richtlinie und erg\u00e4nzt sie um fehlende Details. Diese finden Sie mit dem Befehl:<\/p>\n<pre><code class=\"plaintext\">kubernetes get networkpolicy  -o yaml<\/code><\/pre>\n<p>\nBitte beachten Sie, dass das \u00dcberpr\u00fcfungssystem von Kubernetes nicht narrensicher ist und einige Arten von Fehlern \u00fcbersehen kann.<\/p>\n<h2>Ausf\u00fchrung<\/h2>\n<p>\nKubernetes implementiert keine Netzwerkpolitiken eigenst\u00e4ndig, sondern fungiert lediglich als API-Gateway, das die Kontrolle an das darunterliegende System, die Container Networking Interface (CNI), delegiert. Das Festlegen von Politiken in einem Kubernetes-Cluster ohne Zuordnung einer passenden CNI ist vergleichbar mit dem Erstellen von Politiken auf einem Firewall-Management-Server, ohne diese anschlie\u00dfend in die Firewalls zu integrieren. Sie m\u00fcssen selbst sicherstellen, dass eine geeignete CNI vorhanden ist oder, im Falle von cloudbasierten Kubernetes-Plattformen, sich darauf verlassen, <i>(die Liste der Anbieter finden Sie hier <noindex>hier<\/noindex> \u2014 Anmerkung des \u00dcbersetzers.)<\/i>, die Netzwerkpolitiken implementiert, die die CNI f\u00fcr Sie einrichten.<\/p>\n<p>Bitte beachten Sie, dass Kubernetes Sie nicht warnen wird, wenn Sie eine Netzwerkpolitik ohne die entsprechende unterst\u00fctzende CNI definieren.<\/p>\n<h3>Stateful oder Stateless?<\/h3>\n<p>\nAlle CNI in Kubernetes, die ich kennengelernt habe, sind zustandsbehaftet (zum Beispiel verwendet Calico Linux conntrack). Dadurch kann ein Pod Antworten auf eine von ihm initiierte TCP-Verbindung erhalten, ohne sie neu aufbauen zu m\u00fcssen. Mir ist jedoch kein Kubernetes-Standard bekannt, der die Speicherung von Zust\u00e4nden (Statefulness) garantieren w\u00fcrde.<\/p>\n<h2>Erweiterte Sicherheitsrichtlinienverwaltung<\/h2>\n<p>\nHier sind einige M\u00f6glichkeiten, die Effektivit\u00e4t der Durchsetzung von Sicherheitsrichtlinien in Kubernetes zu steigern:<\/p>\n<ol>\n<li> Das Architekturmuster Service Mesh verwendet Sidecar-Container, um detaillierte Telemetriedaten und Verkehrskontrolle auf Diensteebene zu gew\u00e4hrleisten. Ein Beispiel daf\u00fcr ist <noindex><a rel=\"nofollow\" href=\"https:\/\/istio.io\/\">Istio<\/a><\/noindex>.<\/li>\n<li> Einige der CNI-Anbieter haben ihre Tools erweitert, um \u00fcber die Netzwerkrichtlinien von Kubernetes hinauszugehen.<\/li>\n<li> <noindex><a rel=\"nofollow\" href=\"https:\/\/www.tufin.com\/products\/tufin-orca\">Tufin Orca<\/a><\/noindex> stellt Transparenz und Automatisierung der Netzwerkrichtlinien in Kubernetes sicher.<\/li>\n<\/ol>\n<p>\nDas Tufin Orca-Paket verwaltet die Netzwerkrichtlinien in Kubernetes (und dient als Quelle f\u00fcr die oben genannten Screenshots).<\/p>\n<h2>Zus\u00e4tzliche Informationen<\/h2>\n<p><\/p>\n<ul>\n<li> <noindex><a rel=\"nofollow\" href=\"https:\/\/github.com\/ahmetb\/kubernetes-network-policy-recipes\">Beispiele f\u00fcr Netzwerkrichtlinien, vorbereitet von Ahmet Alp Balkan aus GKE<\/a><\/noindex>;<\/li>\n<li> <noindex><a rel=\"nofollow\" href=\"https:\/\/kubernetes.io\/docs\/concepts\/services-networking\/network-policies\/\">Dokumentation von der offiziellen Kubernetes-Website<\/a><\/noindex>;<\/li>\n<li> <noindex><a rel=\"nofollow\" href=\"https:\/\/sookocheff.com\/post\/kubernetes\/understanding-kubernetes-networking-model\/\">Leitfaden zum Netzwerkmodell von Kubernetes<\/a><\/noindex>;<\/li>\n<li> <noindex><a rel=\"nofollow\" href=\"https:\/\/github.com\/Tufin\/test-network-policies\">Skript zur \u00dcberpr\u00fcfung von Netzwerkrichtlinien<\/a><\/noindex>.<\/li>\n<\/ul>\n<p><\/p>\n<h2>Fazit<\/h2>\n<p>\nKubernetes-Netzwerkrichtlinien bieten eine ansprechende Palette von Werkzeugen zur Segmentierung von Clustern, allerdings sind sie nicht intuitiv und haben viele Feinheiten. Ich bin der Meinung, dass aufgrund dieser Komplexit\u00e4t viele der existierenden Clusterfehler enthalten. M\u00f6gliche L\u00f6sungen f\u00fcr dieses Problem sind die Automatisierung der Richtliniendefinitionen oder die Anwendung anderer Segmentierungsmittel.<\/p>\n<p>Ich hoffe, dass dieses Handbuch einige Fragen kl\u00e4rt und Probleme l\u00f6st, auf die Sie m\u00f6glicherweise sto\u00dfen.<\/p>\n<h2>P.S. vom \u00dcbersetzer<\/h2>\n<p>\nLesen Sie auch in unserem Blog:<\/p>\n<ul>\n<li> \u201eZur\u00fcck zu Microservices mit Istio\u201c: <noindex><a rel=\"nofollow\" href=\"https:\/\/habr.com\/ru\/company\/flant\/blog\/438426\/\">Teil 1 (Einf\u00fchrung in die grundlegenden Funktionen)<\/a><\/noindex>, <noindex><a rel=\"nofollow\" href=\"https:\/\/habr.com\/ru\/company\/flant\/blog\/440378\/\">Teil 2 (Routing, Traffic-Management)<\/a><\/noindex>, <noindex><a rel=\"nofollow\" href=\"https:\/\/habr.com\/ru\/company\/flant\/blog\/443668\/\">Teil 3 (Sicherheit)<\/a><\/noindex>;<\/li>\n<li> \u201eIllustriertes Handbuch zur Netzwerkausstattung in Kubernetes\u201c: <noindex><a rel=\"nofollow\" href=\"https:\/\/habr.com\/ru\/company\/flant\/blog\/346304\/\">Teile 1 und 2 (Netzwerkmodell, Overlay-Netzwerke)<\/a><\/noindex>, <noindex><a rel=\"nofollow\" href=\"https:\/\/habr.com\/ru\/company\/flant\/blog\/433382\/\">Teil 3 (Dienste und Traffic-Handling)<\/a><\/noindex>;<\/li>\n<li> \u00ab<noindex><a rel=\"nofollow\" href=\"https:\/\/habr.com\/ru\/company\/flant\/blog\/440504\/\">Docker und Kubernetes in sicherheitskritischen Umgebungen.<\/a><\/noindex>\u00bb;<\/li>\n<li> \u00ab<noindex><a rel=\"nofollow\" href=\"https:\/\/habr.com\/ru\/company\/flant\/blog\/436300\/\">9 bew\u00e4hrte Praktiken zur Sicherstellung der Sicherheit in Kubernetes.<\/a><\/noindex>\u00bb;<\/li>\n<li> \u00ab<noindex><a rel=\"nofollow\" href=\"https:\/\/habr.com\/ru\/company\/flant\/blog\/417905\/\">11 Wege, (nicht) Opfer eines Hacks in Kubernetes zu werden<\/a><\/noindex>\u00bb.<\/li>\n<\/ul>\n<p>Quelle: <a content=\"nofollow\" rel=\"nofollow\" href=\"https:\/\/habr.com\/ru\/company\/flant\/blog\/443190\/\">habr.com<\/a><\/p>","protected":false,"gt_translate_keys":[{"key":"rendered","format":"html"}]},"excerpt":{"rendered":"<p>\u041f\u0440\u0438\u043c. \u043f\u0435\u0440\u0435\u0432.: \u0410\u0432\u0442\u043e\u0440 \u0441\u0442\u0430\u0442\u044c\u0438 \u2014 Reuven Harrison \u2014 \u0438\u043c\u0435\u0435\u0442 \u0431\u043e\u043b\u0435\u0435 20 \u043b\u0435\u0442 \u043e\u043f\u044b\u0442\u0430 \u0432 \u0440\u0430\u0437\u0440\u0430\u0431\u043e\u0442\u043a\u0435 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u043d\u043e\u0433\u043e \u043e\u0431\u0435\u0441\u043f\u0435\u0447\u0435\u043d\u0438\u044f, \u0430 \u043d\u0430 \u0441\u0435\u0433\u043e\u0434\u043d\u044f\u0448\u043d\u0438\u0439 \u0434\u0435\u043d\u044c \u044f\u0432\u043b\u044f\u0435\u0442\u0441\u044f \u0442\u0435\u0445\u043d\u0438\u0447\u0435\u0441\u043a\u0438\u043c \u0434\u0438\u0440\u0435\u043a\u0442\u043e\u0440\u043e\u043c \u0438 \u0441\u043e\u0443\u0447\u0440\u0435\u0434\u0438\u0442\u0435\u043b\u0435\u043c \u043a\u043e\u043c\u043f\u0430\u043d\u0438\u0438 Tufin, \u0441\u043e\u0437\u0434\u0430\u044e\u0449\u0435\u0439 \u0440\u0435\u0448\u0435\u043d\u0438\u044f \u0434\u043b\u044f \u0443\u043f\u0440\u0430\u0432\u043b\u0435\u043d\u0438\u044f \u043f\u043e\u043b\u0438\u0442\u0438\u043a\u0430\u043c\u0438 \u0431\u0435\u0437\u043e\u043f\u0430\u0441\u043d\u043e\u0441\u0442\u0438. \u0420\u0430\u0441\u0441\u043c\u0430\u0442\u0440\u0438\u0432\u0430\u044f \u0441\u0435\u0442\u0435\u0432\u044b\u0435 \u043f\u043e\u043b\u0438\u0442\u0438\u043a\u0438 Kubernetes \u043a\u0430\u043a \u0434\u043e\u0441\u0442\u0430\u0442\u043e\u0447\u043d\u043e \u043c\u043e\u0449\u043d\u043e\u0435 \u0441\u0440\u0435\u0434\u0441\u0442\u0432\u043e \u0434\u043b\u044f \u0441\u0435\u0433\u043c\u0435\u043d\u0442\u0430\u0446\u0438\u0438 \u0441\u0435\u0442\u0438 \u0432 \u043a\u043b\u0430\u0441\u0442\u0435\u0440\u0435, \u043e\u043d \u0432 \u0442\u043e \u0436\u0435 \u0432\u0440\u0435\u043c\u044f \u0441\u0447\u0438\u0442\u0430\u0435\u0442, \u0447\u0442\u043e \u043e\u043d\u0438 [&hellip;]<\/p>\n","protected":false,"gt_translate_keys":[{"key":"rendered","format":"html"}]},"author":1,"featured_media":24432,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[688],"tags":[],"class_list":["post-32641","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-administrirovanie"],"aioseo_notices":[],"aioseo_head":"\n\t\t<!-- All in One SEO 4.9.10 - aioseo.com -->\n\t<meta name=\"description\" content=\"\u041f\u0440\u0438\u043c. \u043f\u0435\u0440\u0435\u0432.: \u0410\u0432\u0442\u043e\u0440 \u0441\u0442\u0430\u0442\u044c\u0438 \u2014 Reuven Harrison \u2014 \u0438\u043c\u0435\u0435\u0442 \u0431\u043e\u043b\u0435\u0435 20 \u043b\u0435\u0442 \u043e\u043f\u044b\u0442\u0430 \u0432 \u0440\u0430\u0437\u0440\u0430\u0431\u043e\u0442\u043a\u0435 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u043d\u043e\u0433\u043e \u043e\u0431\u0435\u0441\u043f\u0435\u0447\u0435\u043d\u0438\u044f, \u0430 \u043d\u0430 \u0441\u0435\u0433\u043e\u0434\u043d\u044f\u0448\u043d\u0438\u0439 \u0434\u0435\u043d\u044c \u044f\u0432\u043b\u044f\u0435\u0442\u0441\u044f \u0442\u0435\u0445\u043d\u0438\u0447\u0435\u0441\u043a\u0438\u043c \u0434\u0438\u0440\u0435\u043a\u0442\u043e\u0440\u043e\u043c \u0438 \u0441\u043e\u0443\u0447\u0440\u0435\u0434\u0438\u0442\u0435\u043b\u0435\u043c \u043a\u043e\u043c\u043f\u0430\u043d\u0438\u0438 Tufin, \u0441\u043e\u0437\u0434\u0430\u044e\u0449\u0435\u0439 \u0440\u0435\u0448\u0435\u043d\u0438\u044f \u0434\u043b\u044f \u0443\u043f\u0440\u0430\u0432\u043b\u0435\u043d\u0438\u044f \u043f\u043e\u043b\u0438\u0442\u0438\u043a\u0430\u043c\u0438 \u0431\u0435\u0437\u043e\u043f\u0430\u0441\u043d\u043e\u0441\u0442\u0438. \u0420\u0430\u0441\u0441\u043c\u0430\u0442\u0440\u0438\u0432\u0430\u044f \u0441\u0435\u0442\u0435\u0432\u044b\u0435 \u043f\u043e\u043b\u0438\u0442\u0438\u043a\u0438 Kubernetes \u043a\u0430\u043a \u0434\u043e\u0441\u0442\u0430\u0442\u043e\u0447\u043d\u043e \u043c\u043e\u0449\u043d\u043e\u0435 \u0441\u0440\u0435\u0434\u0441\u0442\u0432\u043e \u0434\u043b\u044f \u0441\u0435\u0433\u043c\u0435\u043d\u0442\u0430\u0446\u0438\u0438 \u0441\u0435\u0442\u0438 \u0432 \u043a\u043b\u0430\u0441\u0442\u0435\u0440\u0435, \u043e\u043d \u0432 \u0442\u043e \u0436\u0435 \u0432\u0440\u0435\u043c\u044f \u0441\u0447\u0438\u0442\u0430\u0435\u0442, \u0447\u0442\u043e \u043e\u043d\u0438\" \/>\n\t<meta name=\"robots\" content=\"max-image-preview:large\" \/>\n\t<meta name=\"author\" content=\"Yuri Gagarin\"\/>\n\t<link rel=\"canonical\" href=\"https:\/\/prohoster.info\/de\/blog\/administrirovanie\/vvedenie-v-setevye-politiki-kubernetes-dlya-spetsialistov-po-bezopasnosti\" \/>\n\t<meta name=\"generator\" content=\"All in One SEO (AIOSEO) 4.9.10\" \/>\n\t\t<meta property=\"og:locale\" content=\"de_DE\" \/>\n\t\t<meta property=\"og:site_name\" content=\"ProHoster | \u041a\u0443\u043f\u0438\u0442\u044c \u043d\u0430\u0434\u0435\u0436\u043d\u044b\u0439 \u0445\u043e\u0441\u0442\u0438\u043d\u0433 \u0434\u043b\u044f \u0441\u0430\u0439\u0442\u043e\u0432 \u0441 \u0437\u0430\u0449\u0438\u0442\u043e\u0439 \u043e\u0442 DDoS, VPS VDS \u0441\u0435\u0440\u0432\u0435\u0440\u044b\" \/>\n\t\t<meta property=\"og:type\" content=\"article\" \/>\n\t\t<meta property=\"og:title\" content=\"\ud83e\udd47\u0412\u0432\u0435\u0434\u0435\u043d\u0438\u0435 \u0432 \u0441\u0435\u0442\u0435\u0432\u044b\u0435 \u043f\u043e\u043b\u0438\u0442\u0438\u043a\u0438 Kubernetes \u0434\u043b\u044f \u0441\u043f\u0435\u0446\u0438\u0430\u043b\u0438\u0441\u0442\u043e\u0432 \u043f\u043e \u0431\u0435\u0437\u043e\u043f\u0430\u0441\u043d\u043e\u0441\u0442\u0438 | ProHoster\" \/>\n\t\t<meta property=\"og:description\" content=\"\u041f\u0440\u0438\u043c. \u043f\u0435\u0440\u0435\u0432.: \u0410\u0432\u0442\u043e\u0440 \u0441\u0442\u0430\u0442\u044c\u0438 \u2014 Reuven Harrison \u2014 \u0438\u043c\u0435\u0435\u0442 \u0431\u043e\u043b\u0435\u0435 20 \u043b\u0435\u0442 \u043e\u043f\u044b\u0442\u0430 \u0432 \u0440\u0430\u0437\u0440\u0430\u0431\u043e\u0442\u043a\u0435 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u043d\u043e\u0433\u043e \u043e\u0431\u0435\u0441\u043f\u0435\u0447\u0435\u043d\u0438\u044f, \u0430 \u043d\u0430 \u0441\u0435\u0433\u043e\u0434\u043d\u044f\u0448\u043d\u0438\u0439 \u0434\u0435\u043d\u044c \u044f\u0432\u043b\u044f\u0435\u0442\u0441\u044f \u0442\u0435\u0445\u043d\u0438\u0447\u0435\u0441\u043a\u0438\u043c \u0434\u0438\u0440\u0435\u043a\u0442\u043e\u0440\u043e\u043c \u0438 \u0441\u043e\u0443\u0447\u0440\u0435\u0434\u0438\u0442\u0435\u043b\u0435\u043c \u043a\u043e\u043c\u043f\u0430\u043d\u0438\u0438 Tufin, \u0441\u043e\u0437\u0434\u0430\u044e\u0449\u0435\u0439 \u0440\u0435\u0448\u0435\u043d\u0438\u044f \u0434\u043b\u044f \u0443\u043f\u0440\u0430\u0432\u043b\u0435\u043d\u0438\u044f \u043f\u043e\u043b\u0438\u0442\u0438\u043a\u0430\u043c\u0438 \u0431\u0435\u0437\u043e\u043f\u0430\u0441\u043d\u043e\u0441\u0442\u0438. \u0420\u0430\u0441\u0441\u043c\u0430\u0442\u0440\u0438\u0432\u0430\u044f \u0441\u0435\u0442\u0435\u0432\u044b\u0435 \u043f\u043e\u043b\u0438\u0442\u0438\u043a\u0438 Kubernetes \u043a\u0430\u043a \u0434\u043e\u0441\u0442\u0430\u0442\u043e\u0447\u043d\u043e \u043c\u043e\u0449\u043d\u043e\u0435 \u0441\u0440\u0435\u0434\u0441\u0442\u0432\u043e \u0434\u043b\u044f \u0441\u0435\u0433\u043c\u0435\u043d\u0442\u0430\u0446\u0438\u0438 \u0441\u0435\u0442\u0438 \u0432 \u043a\u043b\u0430\u0441\u0442\u0435\u0440\u0435, \u043e\u043d \u0432 \u0442\u043e \u0436\u0435 \u0432\u0440\u0435\u043c\u044f \u0441\u0447\u0438\u0442\u0430\u0435\u0442, \u0447\u0442\u043e \u043e\u043d\u0438\" \/>\n\t\t<meta property=\"og:url\" content=\"https:\/\/prohoster.info\/de\/blog\/administrirovanie\/vvedenie-v-setevye-politiki-kubernetes-dlya-spetsialistov-po-bezopasnosti\" \/>\n\t\t<meta property=\"og:image\" content=\"https:\/\/prohoster.info\/wp-content\/uploads\/2021\/11\/logo-350.jpg\" \/>\n\t\t<meta property=\"og:image:secure_url\" content=\"https:\/\/prohoster.info\/wp-content\/uploads\/2021\/11\/logo-350.jpg\" \/>\n\t\t<meta property=\"og:image:width\" content=\"350\" \/>\n\t\t<meta property=\"og:image:height\" content=\"350\" \/>\n\t\t<meta property=\"article:published_time\" content=\"2019-10-31T18:48:11+00:00\" \/>\n\t\t<meta property=\"article:modified_time\" content=\"2019-10-31T18:48:11+00:00\" \/>\n\t\t<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/prohoster\" \/>\n\t\t<meta property=\"article:author\" content=\"https:\/\/www.facebook.com\/prohoster\" \/>\n\t\t<!-- All in One SEO -->\n\n","aioseo_head_json":{"title":"\ud83e\udd47Einf\u00fchrung in Kubernetes-Netzwerkrichtlinien f\u00fcr Sicherheitsexperten | ProHoster","description":"Hinweis: Der Autor des Artikels, Reuven Harrison, verf\u00fcgt \u00fcber mehr als 20 Jahre Erfahrung in der Softwareentwicklung und ist derzeit technischer Direktor und Mitbegr\u00fcnder von Tufin, einem Unternehmen, das L\u00f6sungen f\u00fcr das Sicherheitsrichtlinienmanagement anbietet. W\u00e4hrend er Kubernetes-Netzwerkrichtlinien als ein \u00e4u\u00dferst effektives Mittel zur Netzwerksegmentierung innerhalb eines Clusters betrachtet, ist er gleichzeitig der Meinung, dass sie","canonical_url":"https:\/\/prohoster.info\/de\/blog\/administrirovanie\/vvedenie-v-setevye-politiki-kubernetes-dlya-spetsialistov-po-bezopasnosti","robots":"max-image-preview:large","keywords":"","webmasterTools":{"miscellaneous":""},"schema":null,"og:locale":"de_DE","og:site_name":"ProHoster | \u041a\u0443\u043f\u0438\u0442\u044c \u043d\u0430\u0434\u0435\u0436\u043d\u044b\u0439 \u0445\u043e\u0441\u0442\u0438\u043d\u0433 \u0434\u043b\u044f \u0441\u0430\u0439\u0442\u043e\u0432 \u0441 \u0437\u0430\u0449\u0438\u0442\u043e\u0439 \u043e\u0442 DDoS, VPS VDS \u0441\u0435\u0440\u0432\u0435\u0440\u044b","og:type":"article","og:title":"\ud83e\udd47\u0412\u0432\u0435\u0434\u0435\u043d\u0438\u0435 \u0432 \u0441\u0435\u0442\u0435\u0432\u044b\u0435 \u043f\u043e\u043b\u0438\u0442\u0438\u043a\u0438 Kubernetes \u0434\u043b\u044f \u0441\u043f\u0435\u0446\u0438\u0430\u043b\u0438\u0441\u0442\u043e\u0432 \u043f\u043e \u0431\u0435\u0437\u043e\u043f\u0430\u0441\u043d\u043e\u0441\u0442\u0438 | ProHoster","og:description":"\u041f\u0440\u0438\u043c. \u043f\u0435\u0440\u0435\u0432.: \u0410\u0432\u0442\u043e\u0440 \u0441\u0442\u0430\u0442\u044c\u0438 \u2014 Reuven Harrison \u2014 \u0438\u043c\u0435\u0435\u0442 \u0431\u043e\u043b\u0435\u0435 20 \u043b\u0435\u0442 \u043e\u043f\u044b\u0442\u0430 \u0432 \u0440\u0430\u0437\u0440\u0430\u0431\u043e\u0442\u043a\u0435 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u043d\u043e\u0433\u043e \u043e\u0431\u0435\u0441\u043f\u0435\u0447\u0435\u043d\u0438\u044f, \u0430 \u043d\u0430 \u0441\u0435\u0433\u043e\u0434\u043d\u044f\u0448\u043d\u0438\u0439 \u0434\u0435\u043d\u044c \u044f\u0432\u043b\u044f\u0435\u0442\u0441\u044f \u0442\u0435\u0445\u043d\u0438\u0447\u0435\u0441\u043a\u0438\u043c \u0434\u0438\u0440\u0435\u043a\u0442\u043e\u0440\u043e\u043c \u0438 \u0441\u043e\u0443\u0447\u0440\u0435\u0434\u0438\u0442\u0435\u043b\u0435\u043c \u043a\u043e\u043c\u043f\u0430\u043d\u0438\u0438 Tufin, \u0441\u043e\u0437\u0434\u0430\u044e\u0449\u0435\u0439 \u0440\u0435\u0448\u0435\u043d\u0438\u044f \u0434\u043b\u044f \u0443\u043f\u0440\u0430\u0432\u043b\u0435\u043d\u0438\u044f \u043f\u043e\u043b\u0438\u0442\u0438\u043a\u0430\u043c\u0438 \u0431\u0435\u0437\u043e\u043f\u0430\u0441\u043d\u043e\u0441\u0442\u0438. \u0420\u0430\u0441\u0441\u043c\u0430\u0442\u0440\u0438\u0432\u0430\u044f \u0441\u0435\u0442\u0435\u0432\u044b\u0435 \u043f\u043e\u043b\u0438\u0442\u0438\u043a\u0438 Kubernetes \u043a\u0430\u043a \u0434\u043e\u0441\u0442\u0430\u0442\u043e\u0447\u043d\u043e \u043c\u043e\u0449\u043d\u043e\u0435 \u0441\u0440\u0435\u0434\u0441\u0442\u0432\u043e \u0434\u043b\u044f \u0441\u0435\u0433\u043c\u0435\u043d\u0442\u0430\u0446\u0438\u0438 \u0441\u0435\u0442\u0438 \u0432 \u043a\u043b\u0430\u0441\u0442\u0435\u0440\u0435, \u043e\u043d \u0432 \u0442\u043e \u0436\u0435 \u0432\u0440\u0435\u043c\u044f \u0441\u0447\u0438\u0442\u0430\u0435\u0442, \u0447\u0442\u043e \u043e\u043d\u0438","og:url":"https:\/\/prohoster.info\/de\/blog\/administrirovanie\/vvedenie-v-setevye-politiki-kubernetes-dlya-spetsialistov-po-bezopasnosti","og:image":"https:\/\/prohoster.info\/wp-content\/uploads\/2021\/11\/logo-350.jpg","og:image:secure_url":"https:\/\/prohoster.info\/wp-content\/uploads\/2021\/11\/logo-350.jpg","og:image:width":350,"og:image:height":350,"article:published_time":"2019-10-31T18:48:11+00:00","article:modified_time":"2019-10-31T18:48:11+00:00","article:publisher":"https:\/\/www.facebook.com\/prohoster","article:author":"https:\/\/www.facebook.com\/prohoster"},"aioseo_meta_data":{"post_id":"32641","title":null,"description":null,"keywords":null,"keyphrases":null,"primary_term":null,"canonical_url":null,"og_title":null,"og_description":null,"og_object_type":"default","og_image_type":"default","og_image_url":null,"og_image_width":null,"og_image_height":null,"og_image_custom_url":null,"og_image_custom_fields":null,"og_video":null,"og_custom_url":null,"og_article_section":null,"og_article_tags":null,"twitter_use_og":false,"twitter_card":"default","twitter_image_type":"default","twitter_image_url":null,"twitter_image_custom_url":null,"twitter_image_custom_fields":null,"twitter_title":null,"twitter_description":null,"schema":{"blockGraphs":[],"customGraphs":[],"default":{"data":{"Article":[],"Course":[],"Dataset":[],"FAQPage":[],"Movie":[],"Person":[],"Product":[],"ProductReview":[],"Car":[],"Recipe":[],"Service":[],"SoftwareApplication":[],"WebPage":[]},"graphName":"","isEnabled":true},"graphs":[]},"schema_type":null,"schema_type_options":null,"pillar_content":false,"robots_default":true,"robots_noindex":false,"robots_noarchive":false,"robots_nosnippet":false,"robots_nofollow":false,"robots_noimageindex":false,"robots_noodp":false,"robots_notranslate":false,"robots_max_snippet":null,"robots_max_videopreview":null,"robots_max_imagepreview":"large","priority":null,"frequency":null,"local_seo":null,"seo_analyzer_scan_date":"2026-01-21 11:53:20","breadcrumb_settings":null,"limit_modified_date":false,"reviewed_by":null,"ai":null,"created":"2021-03-01 02:55:23","updated":"2026-01-21 11:53:20"},"gt_translate_keys":[{"key":"link","format":"url"}],"_links":{"self":[{"href":"https:\/\/prohoster.info\/de\/wp-json\/wp\/v2\/posts\/32641","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/prohoster.info\/de\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/prohoster.info\/de\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/prohoster.info\/de\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/prohoster.info\/de\/wp-json\/wp\/v2\/comments?post=32641"}],"version-history":[{"count":0,"href":"https:\/\/prohoster.info\/de\/wp-json\/wp\/v2\/posts\/32641\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/prohoster.info\/de\/wp-json\/wp\/v2\/media\/24432"}],"wp:attachment":[{"href":"https:\/\/prohoster.info\/de\/wp-json\/wp\/v2\/media?parent=32641"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/prohoster.info\/de\/wp-json\/wp\/v2\/categories?post=32641"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/prohoster.info\/de\/wp-json\/wp\/v2\/tags?post=32641"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}