Sichern des Datenverkehrs zwischen Pods mit Netzwerkrichtlinien in Azure Kubernetes Service (AKS)

Azure CLI-Version 2.0.61 oder höher muss installiert und konfiguriert sein. Suchen Sie die Version mit dem az --version-Befehl. Informationen zum Durchführen einer Installation oder eines Upgrades finden Sie bei Bedarf unter Installieren der Azure CLI.

Statt einer systemseitig zugewiesenen Identität können Sie auch eine benutzerseitig zugewiesene Identität verwenden. Weitere Informationen finden Sie unter Verwenden verwalteter Identitäten.

• Terraform installiert, Version 1.6 oder höher.
• Azure CLI installiert und authentifiziert. Suchen Sie die Version mit dem az --version-Befehl. Informationen zum Durchführen einer Installation oder eines Upgrades finden Sie bei Bedarf unter Installieren der Azure CLI. Sie verwenden die Azure CLI, um eine Verbindung mit dem Cluster herzustellen, nachdem Terraform es erstellt hat.
• kubectl installiert. Sie können es lokal mit dem az aks install-cli Befehl installieren. Sie verwenden kubectl, um das Verhalten der Netzwerkrichtlinie zu überprüfen.

Erstellen eines AKS-Clusters mit Azure Network Policy Manager (Linux)

1. Legen Sie Umgebungsvariablen für den Ressourcengruppennamen, den Clusternamen und den Speicherort fest. Ersetzen Sie die Werte nach Bedarf.

   export RESOURCE_GROUP=myResourceGroup
   export CLUSTER_NAME=myAKSCluster
   export LOCATION=eastus
   

2. Erstellen Sie die Ressourcengruppe mithilfe des az group create Befehls.

   az group create --resource-group $RESOURCE_GROUP --location $LOCATION
   

3. Erstellen Sie einen AKS-Cluster mit az aks create und spezifizieren Sie azure für network-plugin und network-policy.

   az aks create \
       --resource-group $RESOURCE_GROUP \
       --name $CLUSTER_NAME \
       --node-count 1 \
       --network-plugin azure \
       --network-policy azure \
       --generate-ssh-keys
   

   Vorsicht

   Azure Network Policy Manager (NPM) für Linux-Knoten wird am 30. September 2028 eingestellt. Für neue Bereitstellungen empfehlen wir die Verwendung von Azure CNI Powered by Cilium mit der Cilium-Netzwerkrichtlinie. Informationen zum Migrieren vorhandener Cluster finden Sie unter Migrieren von NPM zu Cilium-Netzwerkrichtlinie.

Erstellen eines AKS-Clusters mit Calico

Erstellen Sie einen AKS-Cluster mithilfe des az aks create Befehls. Geben Sie --network-plugin azure und --network-policy calico an. Wenn Sie angeben--network-policy calico, aktivieren Sie Calico für Linux- und Windows-Knotenpools.

Wenn Sie Windows Knotenpools zu Ihrem Cluster hinzufügen möchten, schließen Sie die windows-admin-username Parameter und windows-admin-password Parameter ein, die den Windows Server Kennwortanforderungen entsprechen. Um einen Benutzernamen zu erstellen, der als Administratoranmeldeinformationen für Ihre Windows Server Container in Ihrem Cluster verwendet werden soll, werden Sie mit den folgenden Befehlen aufgefordert, einen Benutzernamen einzugeben. Legen Sie sie auf WINDOWS_USERNAME fest.

echo "Please enter the username to use as administrator credentials for Windows Server containers on your cluster: " && read WINDOWS_USERNAME

Installieren von Azure Network Policy Manager oder Calico auf einem vorhandenen Cluster

Aktualisieren Sie einen vorhandenen Cluster, um Azure NPM oder Calico mithilfe des az aks update-Befehls zu installieren, und geben Sie für den azure-Parameter calico oder --network-policy an. Der folgende Beispielbefehl zeigt, wie Sie entweder Azure NPM installieren:

az aks update \
  --resource-group $RESOURCE_GROUP \
  --name $CLUSTER_NAME \
  --network-policy azure

Upgrade eines vorhandenen Clusters mit Azure NPM oder Calico auf Cilium

Aktualisieren Sie für Cluster, die bereits Azure CNI verwenden, die Netzwerkdatenebene auf Cilium. Kubenet-Cluster müssen zuerst zu Azure CNI-Overlay migrieren und dann die Netzwerkdatenebene als separater Vorgang auf Cilium aktualisieren. Überprüfen Sie die Voraussetzungen, und führen Sie die Schritte im Upgrade eines vorhandenen Clusters auf Azure CNI Powered by Cilium aus.

Herstellen einer Verbindung mit dem AKS-Cluster

Konfigurieren Sie kubectl, um mithilfe des Befehls „az aks get-credentials“ eine Verbindung mit Ihrem Cluster herzustellen. Mit diesem Befehl werden die Anmeldeinformationen heruntergeladen, und die Kubernetes-Befehlszeilenschnittstelle wird für deren Verwendung konfiguriert.

az aks get-credentials --resource-group $RESOURCE_GROUP --name $CLUSTER_NAME

Überprüfen der Einrichtung von Netzwerkrichtlinien

Um mit der Überprüfung der Netzwerkrichtlinien zu beginnen, erstellen Sie eine Beispielanwendung und legen Verkehrsregeln fest.

1. Erstellen Sie einen Namespace mit dem Namen demo , um die Beispiel-Pods mithilfe des kubectl create namespace-Befehls auszuführen.

   kubectl create namespace demo
   

2. Erstellen Sie mit dem Befehl server einen Pod mit dem Namen kubectl run, der auf TCP-Port 80 ausgeführt wird.

   kubectl run server -n demo --image=k8s.gcr.io/e2e-test-images/agnhost:2.33 --labels="app=server" --port=80 --command -- /agnhost serve-hostname --tcp --http=false --port "80"
   

3. Erstellen Sie einen Pod mit dem Namen client , um Bash mithilfe des kubectl run Befehls auszuführen.

   kubectl run -it client -n demo --image=k8s.gcr.io/e2e-test-images/agnhost:2.33 --command -- bash
   

   Note

   Wenn Sie den Client oder den Server auf einem bestimmten Knoten planen möchten, fügen Sie das folgende Bit vor dem --command Argument im Befehl zum Erstellen kubectl run von Pods hinzu: --overrides='{"spec": { "nodeSelector": {"kubernetes.io/os": "linux|windows"}}}'

4. Rufen Sie in einem separaten Fenster die IP-Adresse des server-Pods mithilfe des kubectl get pod-Befehls ab.

   kubectl get pod --output=wide -n demo
   

   Ihre Ausgabe sollte in etwa wie die folgende Beispielausgabe aussehen:

   NAME     READY   STATUS    RESTARTS   AGE   IP            NODE             NOMINATED NODE   READINESS GATES
   server   1/1     Running   0          30s   10.224.0.72   akswin22000001   <none>           <none>
   

Testen der Konnektivität mit Netzwerkrichtlinien

1. Erstellen Sie eine Datei mit dem Namen demo-policy.yaml, und fügen Sie das folgende YAML-Manifest ein:

   apiVersion: networking.k8s.io/v1
   kind: NetworkPolicy
   metadata:
     name: demo-policy
     namespace: demo
   spec:
     podSelector:
       matchLabels:
         app: server
     ingress:
     - from:
       - podSelector:
           matchLabels:
             app: client
       ports:
       - port: 80
         protocol: TCP
   

2. Wenden Sie das Netzwerkrichtlinienmanifest mithilfe des kubectl apply Befehls an.

   kubectl apply -f demo-policy.yaml
   

3. Überprüfen Sie in der Clientshell die Verbindung mit dem Server mithilfe des folgenden /agnhost Befehls:

   /agnhost connect <server-ip>:80 --timeout=3s --protocol=tcp
   

   Die Verbindung mit dem Datenverkehr wird blockiert, weil der Server mit app=server gekennzeichnet ist, der Client aber nicht. Ihre Ausgabe sollte in etwa wie die folgende Beispielausgabe aussehen:

   TIMEOUT
   

4. Kennzeichnen Sie das client und überprüfen Sie die Verbindung mit dem Server mithilfe des kubectl label-Befehls.

   kubectl label pod client -n demo app=client
   

   Wenn die Verbindung erfolgreich ist, gibt es keine Ausgabe.

Migrieren zu selbstverwaltetem Calico

AKS unterstützt calico nur für Standardmäßige Kubernetes-Netzwerkrichtlinien und testt keine anderen Features. Wenn Sie zu selbstverwaltetem Calico wechseln möchten, folgen Sie den Tigera-Anweisungen bei Migrate von Azure-verwaltetem Calico zu selbstverwaltetem Calico. In der Tigera-Dokumentation wird erwähnt, dass man bei selbstverwaltetem Calico --network-policy none wie im Abschnitt Deinstallieren eingestellt.

Deinstallieren von Azure Network Policy Manager oder Calico (Vorschau)

Entfernen Sie Azure Network Policy Manager oder Calico aus einem vorhandenen Cluster mithilfe des Befehls az aks update und geben Sie none für den Parameter --network-policy an.

az aks update \
  --resource-group $RESOURCE_GROUP \
  --name $CLUSTER_NAME \
  --network-policy none

Ändern der Clusternetzwerkrichtlinie

Die folgenden Schritte zeigen, wie Sie die vorhandene Netzwerkrichtlinie eines Clusters in Calico ändern. Für das Verfahren muss die Netzwerkrichtlinie zu none geändert und dann zu calico geändert werden.

Die Befehle verwenden variablen, die weiter oben in diesem Artikel angegeben wurden : Erstellen eines AKS-Clusters mit Azure Network Policy Manager (Linux).The commands use variables specified earlier in this article Create an AKS cluster with Azure Network Policy Manager (Linux). Ersetzen Sie andernfalls $RESOURCE_GROUP durch die Ressourcengruppe und $CLUSTER_NAME durch den Namen Ihres Clusters.

1. Führen Sie den folgenden Befehl aus, um die vorhandene Netzwerkrichtlinie des Clusters anzuzeigen.

   az aks show \
     --resource-group $RESOURCE_GROUP \
     --name $CLUSTER_NAME \
     --query "networkProfile" \
     --output table
   

2. Führen Sie den folgenden Befehl aus, um die Netzwerkrichtlinie auf none festzulegen.

   az aks update --resource-group $RESOURCE_GROUP --name $CLUSTER_NAME --network-policy none
   

3. Führen Sie den folgenden Befehl aus, um die Netzwerkrichtlinie auf calico festzulegen.

   az aks update --resource-group $RESOURCE_GROUP --name $CLUSTER_NAME --network-policy calico
   

Bereinigen von Ressourcen

In diesem Artikel haben Sie einen Namespace und zwei Pods erstellt und eine Netzwerkrichtlinie angewendet. Wenn Sie diese Ressourcen nicht mehr benötigen, können Sie sie löschen.

Löschen Sie die Ressourcen mithilfe des kubectl delete Befehls.

kubectl delete namespace demo

Wenn Sie die Schritte in diesem Artikel zum Erstellen eines AKS-Clusters befolgt haben, verwenden Sie den Befehl az group delete, um die AKS-Ressourcengruppe und die zugehörige Ressourcengruppe zu löschen, deren Name mit MC_ beginnt.

az group delete --resource-group $RESOURCE_GROUP --no-wait --yes

Erstellen eines AKS-Clusters mit Cilium-Netzwerkrichtlinie mithilfe von Terraform

In diesem Abschnitt wird gezeigt, wie Sie terraform verwenden, um einen AKS-Cluster bereitzustellen, der Azure CNI Powered by Cilium für die Durchsetzung von Netzwerk- und Netzwerkrichtlinien verwendet, und dann eine Kubernetes-Ressource NetworkPolicy zum Steuern des Pod-zu-Pod-Datenverkehrs verwenden.

In diesem Beispiel wird Folgendes bereitgestellt:

• Eine Ressourcengruppe.
• Ein AKS-Cluster, der Azure CNI Overlay-Netzwerk mit Cilium als Netzwerkrichtlinienmodul und Netzwerkdatenplan verwendet.

1. Erstellen Sie ein Verzeichnis zum Testen und Ausführen des Terraform-Beispielcodes, und machen Sie es zum aktuellen Verzeichnis.

2. Erstellen Sie eine Datei namens main.tf, und fügen Sie den folgenden Code ein:

   terraform {
     required_version = ">= 1.6.0"
     required_providers {
       azurerm = {
         source  = "hashicorp/azurerm"
         version = "~> 4.0"
       }
     }
   }
   
   provider "azurerm" {
     features {}
   }
   
   resource "azurerm_resource_group" "example" {
     name     = "rg-aks-network-policy-example"
     location = "eastus"
   }
   
   resource "azurerm_kubernetes_cluster" "example" {
     name                = "aks-network-policy-example"
     location            = azurerm_resource_group.example.location
     resource_group_name = azurerm_resource_group.example.name
     dns_prefix          = "aksnetpolicyexample"
   
     default_node_pool {
       name       = "default"
       node_count = 1
       vm_size    = "Standard_D2s_v3"
   
       upgrade_settings {
         drain_timeout_in_minutes      = 0
         max_surge                     = "10%"
         node_soak_duration_in_minutes = 0
       }
     }
   
     identity {
       type = "SystemAssigned"
     }
   
     network_profile {
       network_plugin      = "azure"
       network_plugin_mode = "overlay"
       network_policy      = "cilium"
       network_data_plane  = "cilium"
       load_balancer_sku   = "standard"
     }
   }
   

3. Initialisieren Sie Terraform, indem Sie den terraform init Befehl ausführen. Dieser Befehl lädt den Azure-Anbieter herunter, der zum Verwalten von Azure-Ressourcen mit Terraform erforderlich ist.

   terraform init
   

4. Formatieren und validieren Sie die Konfiguration, indem Sie die Befehle terraform fmt und terraform validate ausführen.

   terraform fmt
   terraform validate
   

5. Erstellen Sie einen Terraform-Ausführungsplan, indem Sie den terraform plan Befehl ausführen. Dieser Befehl zeigt Ihnen die Ressourcen, die Terraform in Ihrem Azure-Abonnement erstellt oder ändert.

   terraform plan
   

6. Wenden Sie den Terraform-Ausführungsplan an, indem Sie den terraform apply Befehl ausführen. Mit diesem Befehl werden die ressourcen erstellt, die in Ihrer main.tf Datei in Ihrem Azure-Abonnement definiert sind.

   terraform apply
   

Herstellen einer Verbindung mit dem AKS-Cluster mithilfe von Terraform

1. Installieren Sie das Befehlszeilentool Kubernetes, indem Sie den az aks install-cli Befehl ausführen, und überprüfen Sie dann die Installation.

   az aks install-cli
   kubectl version --client
   

2. Konfigurieren Sie kubectl , um eine Verbindung mit Ihrem Cluster herzustellen, indem Sie den az aks get-credentials Befehl ausführen. Mit diesem Befehl werden die Anmeldeinformationen heruntergeladen, und die Kubernetes-Befehlszeilenschnittstelle wird für deren Verwendung konfiguriert.

   az aks get-credentials \
       --resource-group rg-aks-network-policy-example \
       --name aks-network-policy-example
   

3. Überprüfen Sie, ob der Cluster ausgeführt wird, indem Sie den kubectl get nodes Befehl ausführen.

   kubectl get nodes
   

Einrichtung der Netzwerkrichtlinie mit Terraform überprüfen

Um die Netzwerkrichtlinieneinrichtung zu überprüfen, erstellen Sie eine Beispielanwendung, und legen Sie Datenverkehrsregeln fest.

1. Erstellen Sie einen Namespace mit dem Namen demo , um die Beispiel-Pods mithilfe des kubectl create namespace Befehls auszuführen.

   kubectl create namespace demo
   

2. Erstellen Sie einen Pod mit dem Namen server, der auf TCP-Port 80 bereitgestellt wird, durch Ausführen des Befehls kubectl run.

   kubectl run server \
     -n demo \
     --image=k8s.gcr.io/e2e-test-images/agnhost:2.33 \
     --labels="app=server" \
     --port=80 \
     --command -- /agnhost serve-hostname --tcp --http=false --port "80"
   

3. Erstellen Sie einen Pod, der benannt ist client , um Bash mithilfe des kubectl run Befehls auszuführen.

   kubectl run -it client \
     -n demo \
     --image=k8s.gcr.io/e2e-test-images/agnhost:2.33 \
     --command -- bash
   

4. Rufen Sie in einem separaten Fenster die IP-Adresse des server Pods mithilfe des kubectl get pod Befehls ab.

   kubectl get pod --output=wide -n demo
   

   Verwenden Sie die serverPod-IP-Adresse, wenn Sie im nächsten Abschnitt die Verbindung aus der clientShell testen.

Testen der Konnektivität mit Netzwerkrichtlinien mithilfe von Terraform

Das Beispiel enthält ein Kubernetes-Manifest NetworkPolicy, das eingehenden Datenverkehr zu mit app=server gekennzeichneten Pods nur von mit app=client gekennzeichneten Pods über TCP-Port 80 zulässt.

1. Erstellen Sie eine Datei namens network-policy.yaml, und fügen Sie den folgenden Code ein:

   apiVersion: networking.k8s.io/v1
   kind: NetworkPolicy
   metadata:
     name: demo-policy
     namespace: demo
   spec:
     podSelector:
       matchLabels:
         app: server
     policyTypes:
       - Ingress
     ingress:
       - from:
           - podSelector:
               matchLabels:
                 app: client
         ports:
           - protocol: TCP
             port: 80
   

2. Wenden Sie die Netzwerkrichtlinie mithilfe des kubectl apply Befehls an.

   kubectl apply -f network-policy.yaml
   

3. Testen Sie in der client Shell die Verbindung mit dem Server mithilfe des folgenden /agnhost Befehls:

   /agnhost connect <server-ip>:80 --timeout=3s --protocol=tcp
   

   Die Konnektivität wird blockiert, weil der Server mit app=server gekennzeichnet ist, der Client jedoch nicht. Ihre Ausgabe sollte in etwa wie die folgende Beispielausgabe aussehen:

   TIMEOUT
   

4. Beschriften Sie das client und überprüfen Sie die Konnektivität mit dem Server mithilfe des Befehls kubectl label.

   kubectl label pod client -n demo app=client
   

5. Testen Sie in der client Shell die Verbindung mit dem Server erneut, indem Sie denselben /agnhost Befehl verwenden:

   /agnhost connect <server-ip>:80 --timeout=3s --protocol=tcp
   

   Wenn die Verbindung erfolgreich ist, gibt es keine Ausgabe.

6. Überprüfen Sie die Netzwerkrichtlinie mithilfe der kubectl get networkpolicy Und kubectl describe networkpolicy Befehle.

   kubectl get networkpolicy -n demo
   kubectl describe networkpolicy demo-policy -n demo
   

   Die Ausgabe zeigt, dass die mit app=server gekennzeichneten Pods ausgewählt sind, Ingress-Datenverkehr über TCP-Port 80 zugelassen wird und nur die mit app=client gekennzeichneten Pods Verbindungen initiieren können.

Bereinigen von Ressourcen mithilfe von Terraform

In diesem Abschnitt haben Sie einen Namespace, zwei Pods und eine Netzwerkrichtlinie erstellt. Wenn Sie diese Kubernetes-Ressourcen nicht mehr benötigen, löschen Sie sie, bevor Sie die zugrunde liegende Azure Infrastruktur entfernen.

Verwenden Sie den kubectl delete Befehl, um die Ressourcen zu löschen.

kubectl delete namespace demo

Entfernen Sie die Azure Ressourcen mithilfe des terraform destroy Befehls.

terraform destroy