Skydda trafik mellan poddar med nätverksprinciper i Azure Kubernetes Service (AKS)

Important

Från och med den 30 september 2028 har Azure Kubernetes Service (AKS) inte längre stöd för Azure Network Policy Manager (NPM) på Linux-noder . För att undvika avbrott i tjänsten måste du migrera AKS-kluster som kör Linux-noder från NPM till Cilium Network Policy vid supportens slutdatum. För mer information om denna tillbakadragning, se meddelandet om tillbakadragning av Azure-uppdateringar. Om du vill hålla dig informerad om meddelanden och uppdateringar följer du AKS-versionsinformation.

Identifiera kluster som påverkas

Om du vill hitta AKS-kluster med Linux-nodpooler med Hjälp av Azure Network Policy Manager (NPM) kör du Azure Resource Graph-frågan som visar alla AKS-kluster där agentPool.osType != "Windows" och properties.networkProfile.networkPolicy == "azure".

Important

Från och med den 31 mars 2028 har Azure Kubernetes Service (AKS) inte längre stöd för kubenet-nätverk. För att undvika avbrott i tjänsten uppgraderar du till Azure Container Networking Interface (CNI) Överläggsnätverk före supportdatumet. Mer information om den här tillbakadragningen finns i GitHub-problemet för pensionering och meddelandet om azure-uppdateringars tillbakadragning. Om du vill hålla dig informerad om meddelanden och uppdateringar följer du AKS-versionsinformation.

Installera en nätverksprincipmotor och skapa Kubernetes-nätverksprinciper för att styra trafikflödet mellan poddar i AKS-kluster med hjälp av Azure CLI eller Terraform.

Översikt över nätverkspolicy

Som standard kan alla poddar i ett AKS-kluster skicka och ta emot trafik utan begränsningar. För att förbättra säkerheten kan du definiera regler som styr trafikflödet.

Nätverksprincip är en Kubernetes-specifikation som definierar åtkomstprinciper för kommunikation mellan poddar. När du använder nätverksprinciper definierar du en ordnad uppsättning regler för att skicka och ta emot trafik. Du tillämpar reglerna på en samling poddar som matchar en eller flera etikettväljare.

Du definierar nätverksprincipreglerna som YAML-manifest och du kan inkludera dem i bredare manifest som också skapar en distribution eller tjänst.

Alternativ för nätverksprinciper i AKS

Azure tillhandahåller tre nätverksprincipmotorer för att framtvinga nätverksprinciper:

  • Cilium (för AKS-kluster som använder Azure CNI som drivs av Cilium)
  • Azure Network Policy Manager (NPM)
  • Calico (en nätverks- och nätverkssäkerhetslösning med öppen källkod grundad av Tigera)

Vi rekommenderar att du använder Cilium, som ger robust stöd för Kubernetes-inbyggda principer, utökade funktioner som Layer 7-princip och FQDN-filtrering och ett eBPF-baserat dataplan som ger bättre prestanda, skalbarhet och säkerhet jämfört med IPTables-baserade lösningar.

För att framtvinga de angivna principerna använder Azure NPM IPTables för Linux-noder. Principer översätts till uppsättningar med tillåtna och otillåtna IP-adresspar. Systemet programmerar dessa par som IPTable filterregler.

Skillnader mellan nätverksprincipmotorer: Cilium, Azure NPM och Calico

Policy-motor för nätverk Plattformar som stöds Nätverksalternativ som stöds Efterlevnad av Kubernetes-specifikation Andra funktioner Support
Cilium Linux Azure CNI Stöder alla principtyper FQDN, L3/4, L7 Azures support- och teknikteam
Azure NPM Linux Azure CNI Stöder alla principtyper N/A Azures support- och teknikteam
Calico Linux, Windows Server 2019, Windows Server 2022 Azure CNI (Linux, Windows Server 2019, Windows Server 2022) och kubenet (Linux) Stöder alla principtyper AKS testar eller stöder inte funktioner utöver tillämpning av networking.k8s.io principer. Azures support- och teknikteam

Azure begränsningar i Network Policy Manager

Azure NPM har följande begränsningar:

  • Skalning utöver 250 noder och 20 000 poddar stöds inte. Om du försöker skala utanför dessa gränser kan det uppstå OOM-fel (Out of Memory). För bättre skalbarhet och IPv6-stöd rekommenderar vi att du använder eller uppgraderar till Azure CNI Powered by Cilium för din nätverksprincipmotor.
  • IPv6 stöds inte. Annars har den fullt stöd för nätverksprincipspecifikationerna i Linux.
  • Från och med den 30 september 2026 stöder Azure Kubernetes Service (AKS) inte längre Azure Network Policy Manager (NPM) på Windows noder.

Kända problem med Azure Network Policy Manager

Du kan uppleva tillfälliga anslutningsproblem för nya anslutningar till/från poddar på de berörda noderna när du antingen redigerar eller tar bort en tillräckligt stor nätverkspolicy. Att nå det här tävlingstillståndet påverkar aldrig aktiva anslutningar.

Om detta löstillstånd inträffar för en nod hamnar Azure NPM-podden på den noden i ett läge där den inte kan uppdatera säkerhetsreglerna, vilket kan leda till oväntad anslutningsmöjlighet för nya förbindelser till/från poddar på den berörda noden. För att åtgärda problemet startar Azure NPM-podden automatiskt om cirka 15 sekunder efter att den har gått in i detta tillstånd. Medan Azure NPM startas om på den berörda noden tas alla säkerhetsregler bort och säkerhetsreglerna för alla nätverksprinciper återskapas. Alla säkerhetsregler tillämpas på nytt, men det finns en risk för tillfällig, oväntad anslutning för nya anslutningar till/från poddar på den berörda noden.

Om du vill begränsa risken för att träffa det här kapplöpningstillståndet kan du minska storleken på nätverkspolicyn. Det här problemet inträffar troligen för en nätverksprincip med flera ipBlock avsnitt. Det är mindre troligt att en nätverksprincip med fyra eller färreipBlock avsnitt stöter på problemet.

Calico-begränsningar

  • AKS stöder inte körning av AKS-hanterad Calico tillsammans med Calico Cloud eller Calico Enterprise, eftersom den här kombinationen kan orsaka konflikter och oavsiktligt beteende. Om du använder Calico Cloud eller Enterprise rekommenderar Microsoft starkt att du inaktiverar AKS-hanterad Calico. Kontakta Tigera för support för de produkterna.
  • AKS-hanterad Calico stöder endast networking.k8s.io nätverksprinciper. Om du tänker använda projectcalico.org/v3 policyer kan du överväga att migrera till en lokalt installerad lösning, till exempel Calico Cloud, Calico Enterprise eller BYOCNI.

Lastbalanseringstjänster och nätverksprinciper

Kubernetes-tjänstroutning för både inkommande och utgående tjänster handlar ofta om att skriva om käll- och mål-IP-adresserna för trafik som bearbetas, inklusive trafik som kommer in i klustret från en LoadBalancer tjänst. Det här omskrivningsbeteendet innebär att nätverksprinciperna kanske inte bearbetar trafik som tas emot från eller skickas till en extern tjänst korrekt. Mer information finns i dokumentationen om Kubernetes-nätverksprinciper.

Om du vill begränsa vilka källor som kan skicka trafik till en lastbalanserare använder du spec.loadBalancerSourceRanges för att konfigurera trafikblockering som gäller innan eventuella omskrivningar sker. Mer information finns i dokumentationen om AKS Standard-lastbalanseraren.

Innan du börjar

Du behöver Azure CLI version 2.0.61 eller senare installerad och konfigurerad. Hitta versionen med kommandot az --version . Om du behöver installera eller uppgradera, se Installera Azure CLI.

I stället för att använda en systemtilldelad identitet kan du också använda en användartilldelad identitet. Mer information finns i Använda hanterade identiteter.

  • Terraform installerat, version 1.6 eller senare.
  • Azure CLI installerat och autentiserat. Hitta versionen med kommandot az --version . Om du behöver installera eller uppgradera, se Installera Azure CLI. Du använder Azure CLI för att ansluta till klustret när Terraform har skapat det.
  • kubectl installerat. Du kan installera den lokalt med hjälp av az aks install-cli kommandot . Du använder kubectl för att verifiera nätverksprincipbeteendet.

Skapa ett AKS-kluster med Azure Network Policy Manager (Linux)

  1. Ange miljövariabler för resursgruppens namn, klusternamn och plats. Ersätt värdena efter behov.

    export RESOURCE_GROUP=myResourceGroup
    export CLUSTER_NAME=myAKSCluster
    export LOCATION=eastus
    
  2. Skapa resursgruppen med kommandot az group create .

    az group create --resource-group $RESOURCE_GROUP --location $LOCATION
    
  3. Skapa ett AKS-kluster med hjälp av az aks create och ange azure för network-plugin och network-policy.

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

    Försiktighet

    Azure Network Policy Manager (NPM) för Linux-noder dras tillbaka den 30 september 2028. För nya distributioner rekommenderar vi att använda Azure CNI Powered by Cilium tillsammans med Cilium Network Policy. Information om hur du migrerar befintliga kluster finns i Migrera från NPM till Cilium-nätverksprincip.

Skapa ett AKS-kluster med Calico

Skapa ett AKS-kluster med hjälp az aks create av kommandot . Specificera --network-plugin azure och --network-policy calico. När du anger --network-policy calicoaktiverar du Calico i både Linux- och Windows nodpooler.

Om du planerar att lägga till Windows nodpooler i klustret inkluderar du parametrarna windows-admin-username och windows-admin-password som uppfyller Windows Server lösenordskrav. Om du vill skapa ett användarnamn som ska användas som administratörsautentiseringsuppgifter för dina Windows Server containrar i klustret uppmanas du att ange ett användarnamn i följande kommando. Ställ in den på WINDOWS_USERNAME.

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

Important

För närvarande är det tillgängligt att använda Calico-nätverksprinciper med Windows-noder i nya kluster med Kubernetes version 1.20 eller senare med Calico 3.17.2 och kräver att du använder Azure CNI-nätverk. Windows-noder i AKS-kluster med Calico aktiverat har också flytande IP aktiverat som standard.

För kluster med endast Linux-nodpooler som kör Kubernetes 1.20 med tidigare versioner av Calico uppgraderas Calico-versionen automatiskt till 3.17.2.

Installera Azure Network Policy Manager eller Calico på ett befintligt kluster

Warning

Tänk på följande när du installerar Azure NPM eller Calico i ett befintligt kluster:

  • Uppgraderingsprocessen utlöser att varje nodpool återskapas samtidigt. Det går inte att uppgradera varje nodpool separat.
  • I varje nodpool följer noderna samma omimeringsprocess som standardåtgärder för Kubernetes-versionsuppgradering. Det här beteendet innebär att buffertnoder tillfälligt läggs till för att minimera avbrott i program som körs under nodombildningsprocessen. Eventuella störningar som kan uppstå liknar vad du kan stöta på under en uppgradering av nodbilden eller uppgraderingen av Kubernetes-versionen.

Följande information gäller för uppgraderingar från kubenet med Calico till Azure CNI Overlay med Calico:

  • I kubenet-kluster med Calico aktiverat används Calico som både en CNI- och nätverksprincipmotor.
  • I Azure CNI-kluster används Calico endast för nätverksprincipframtvingande, inte som CNI. Detta kan orsaka en kort fördröjning mellan när podden startar och när Calico tillåter utgående trafik från podden.

Uppdatera ett befintligt kluster för att installera Azure NPM eller Calico med hjälp av az aks update kommandot och ange azure eller calico för parametern --network-policy . Följande exempelkommando visar hur du installerar antingen Azure NPM:

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

Uppgradera ett befintligt kluster med Azure NPM eller Calico till Cilium

För kluster som redan använder Azure CNI uppdaterar du nätverksdataplanet till Cilium. Kubenet-kluster måste först migreras till Azure CNI-överlägg och sedan uppdatera nätverksdataplanet till Cilium som en separat åtgärd. Granska förutsättningarna och följ stegen i Uppgradera ett befintligt kluster för att Azure CNI som drivs av Cilium.

Ansluta till AKS-klustret

Konfigurera kubectl för att ansluta till klustret med hjälp av az aks get-credentials kommandot . Det här kommandot laddar ned autentiseringsuppgifter och konfigurerar Kubernetes CLI för att använda dem.

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

Verifiera konfigurationen av nätverksprinciper

Om du vill börja verifiera nätverksprincipen skapar du ett exempelprogram och anger trafikregler.

  1. Skapa ett namnområde med namnet demo för att köra exempelpoddar med kommandot kubectl create namespace .

    kubectl create namespace demo
    
  2. Skapa en podd med namnet server som ska användas på TCP-port 80 med kommandot 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. Skapa en podd med namnet client för att köra Bash med kommandot kubectl run .

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

    Note

    Om du vill schemalägga klienten eller servern på en viss nod lägger du till följande bit före --command argumentet i kommandot för att skapa kubectl run poddar: --overrides='{"spec": { "nodeSelector": {"kubernetes.io/os": "linux|windows"}}}'.

  4. I ett separat fönster hämtar du IP-adressen för server podden med kommandot kubectl get pod .

    kubectl get pod --output=wide -n demo
    

    Dina utdata bör likna följande exempelutdata:

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

Testa anslutningen med nätverksprinciper

Tips/Råd

Om du vill testa anslutningen utan nätverksprinciper kör du följande kommando i klientgränssnittet: /agnhost connect <server-ip>:80 --timeout=3s --protocol=tcp. Ersätt <server-ip> med IP-adressen för serverpodden. Om anslutningen lyckas, visas ingen information.

  1. Skapa en fil med namnet demo-policy.yaml och klistra in följande YAML-manifest:

    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. Använd nätverksprincipmanifestet kubectl apply med kommandot .

    kubectl apply -f demo-policy.yaml
    
  3. I klientgränssnittet kontrollerar du anslutningen till servern med hjälp av följande /agnhost kommando:

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

    Anslutningen till trafiken blockeras eftersom servern är märkt med app=server, men klienten är inte märkt. Dina utdata bör likna följande exempelutdata:

    TIMEOUT
    
  4. client Märk och verifiera anslutningen till servern med hjälp av kubectl label kommandot .

    kubectl label pod client -n demo app=client
    

    Om anslutningen lyckas, visas ingen information.

Migrera till självhanterad Calico

AKS stöder endast Calico för kubernetes-standardnätverksprinciper och testar inte andra funktioner. Om du vill flytta till självhanterad Calico följer du Tigera-instruktionerna på Migrera från Azure-hanterad Calico till självhanterad Calico. Tigera-dokumentationen nämner att du för självhanterad Calico anger --network-policy none som i avsnittet för avinstallation.

Avinstallera Azure Network Policy Manager eller Calico

Note

Tänk på följande när du avinstallerar Azure NPM eller Calico från ett kluster:

  • Avinstallationsprocessen tar inte bort anpassade resursdefinitioner (CRD) och anpassade resurser (CR) som används av Calico. Dessa CRD och CRs har alla namn som slutar med antingen projectcalico.org eller tigera.io. Du kan ta bort dessa CRD:er och associerade cd-skivor manuellt när du har avinstallerat Calico.
  • Uppgraderingen tar inte bort några nätverksprincipresurser i klustret, men principerna tillämpas inte längre efter avinstallationsprocessen.

Ta bort Azure Network Policy Manager eller Calico från ett befintligt kluster med kommandot az aks update och ange none parametern --network-policy .

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

Ändra klusternätverksprincip

Följande steg visar hur du ändrar ett klusters befintliga nätverksprincip till Calico. Proceduren kräver att nätverksprincipen ändras till none och sedan ändras till calico.

Kommandona använder variabler som angavs tidigare i den här artikeln Skapa ett AKS-kluster med Azure Network Policy Manager (Linux). Annars ersätter $RESOURCE_GROUP och $CLUSTER_NAME med klustrets resursgrupp och namn.

  1. Kör följande kommando för att visa klustrets befintliga nätverksprincip.

    az aks show \
      --resource-group $RESOURCE_GROUP \
      --name $CLUSTER_NAME \
      --query "networkProfile" \
      --output table
    
  2. Kör följande kommando för att ange nätverksprincipen till none.

    az aks update --resource-group $RESOURCE_GROUP --name $CLUSTER_NAME --network-policy none
    
  3. Kör följande kommando för att ange nätverksprincipen till calico.

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

Rensa resurser

I den här artikeln har du skapat ett namnområde och två poddar och tillämpat en nätverksprincip. Om du inte längre behöver dessa resurser kan du ta bort dem.

Ta bort resurserna med kommandot kubectl delete .

kubectl delete namespace demo

Om du har följt den här artikelns steg för att skapa ett AKS-kluster använder du az group delete kommandot för att ta bort AKS-resursgruppen och dess relaterade resursgrupp med ett namn som börjar med MC_.

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

Skapa ett AKS-kluster med en Cilium-nätverksprincip med Terraform

Det här avsnittet visar hur du använder Terraform för att driftsätta ett AKS-kluster som använder Azure CNI Powered by Cilium för nätverk och tillämpning av nätverksprinciper, och sedan hur du använder en Kubernetes-resurs NetworkPolicy för att styra pod-till-pod-trafik.

Det här exemplet distribuerar:

  • En resursgrupp.
  • Ett AKS-kluster som använder Azure CNI Overlay-nätverk med Cilium som nätverksprincipmotor och nätverksdataplan.
  1. Skapa en katalog för att testa och köra Terraform-exempelkoden och gör den till den aktuella katalogen.

  2. Skapa en fil med namnet main.tfoch infoga följande kod:

    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. Initiera Terraform genom att terraform init köra kommandot . Det här kommandot laddar ned den Azure-provider som krävs för att hantera Azure-resurser med Terraform.

    terraform init
    
  4. Formatera och verifiera konfigurationen genom att köra kommandona terraform fmt och terraform validate .

    terraform fmt
    terraform validate
    
  5. Skapa en Terraform-exekveringsplan genom att köra kommandot terraform plan. Det här kommandot visar de resurser som Terraform skapar eller ändrar i din Azure prenumeration.

    terraform plan
    
  6. Tillämpa Terraform-körningsplanen genom att köra kommandot terraform apply. Det här kommandot skapar de resurser som definierats i main.tf filen i din Azure-prenumeration.

    terraform apply
    

Ansluta till AKS-klustret med Terraform

  1. Installera kommandoradsverktyget Kubernetes genom att köra az aks install-cli kommandot och verifiera sedan installationen.

    az aks install-cli
    kubectl version --client
    
  2. Konfigurera kubectl så att den ansluter till ditt kluster genom att köra kommandot az aks get-credentials. Det här kommandot laddar ned autentiseringsuppgifter och konfigurerar Kubernetes CLI för att använda dem.

    az aks get-credentials \
        --resource-group rg-aks-network-policy-example \
        --name aks-network-policy-example
    
  3. Kontrollera att klustret är igång genom att köra kommandot kubectl get nodes.

    kubectl get nodes
    

Verifiera konfigurationen av nätverksprinciper med Terraform

Om du vill verifiera konfigurationen av nätverksprincipen skapar du ett exempelprogram och anger trafikregler.

  1. Skapa en namnrymd med namnet demo för att köra exempelpoddar med kommandot kubectl create namespace.

    kubectl create namespace demo
    
  2. Skapa en podd med namnet server som ska användas på TCP-port 80 genom att kubectl run köra kommandot .

    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. Skapa en podd med namnet client för att köra Bash med hjälp kubectl run av kommandot .

    kubectl run -it client \
      -n demo \
      --image=k8s.gcr.io/e2e-test-images/agnhost:2.33 \
      --command -- bash
    
  4. I ett separat fönster hämtar du IP-adressen för server podden med hjälp kubectl get pod av kommandot .

    kubectl get pod --output=wide -n demo
    

    Använd poddens server IP-adress när du testar anslutningen från client gränssnittet i nästa avsnitt.

Testa anslutningen med nätverksprinciper med Terraform

Exemplet innehåller ett Kubernetes-manifest NetworkPolicy som tillåter inkommande trafik till poddar som endast är app=server märkta från poddar märkta app=client på TCP-port 80.

  1. Skapa en fil med namnet network-policy.yamloch infoga följande kod:

    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. Använd nätverksprincipen kubectl apply med hjälp av kommandot .

    kubectl apply -f network-policy.yaml
    
  3. I client shellen testar du anslutningen till servern med hjälp av följande /agnhost-kommando:

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

    Anslutningen blockeras eftersom servern är märkt med app=server, men klienten är inte märkt. Dina utdata bör likna följande exempelutdata:

    TIMEOUT
    
  4. Märk client och verifiera anslutningen till servern med kommandot kubectl label.

    kubectl label pod client -n demo app=client
    
  5. client I gränssnittet testar du anslutningen till servern igen med samma /agnhost kommando:

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

    Om anslutningen lyckas, visas ingen information.

  6. Verifiera nätverksprincipen med hjälp av kommandona kubectl get networkpolicy och kubectl describe networkpolicy .

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

    Utdata visar att poddar som är märkta app=server är markerade, inkommande trafik tillåts på TCP-port 80 och endast poddar som är märkta app=client kan initiera anslutningar.

Rensa resurser med Terraform

I det här avsnittet skapade du ett namnområde, två poddar och en nätverksprincip. Om du inte längre behöver dessa Kubernetes-resurser tar du bort dem innan du tar bort den underliggande Azure infrastrukturen.

kubectl delete Använd kommandot för att ta bort resurserna.

kubectl delete namespace demo

Warning

Följande kommando tar bort resursgruppen, AKS-klustret och alla andra resurser som är associerade med resursgruppen som skapats för det här exemplet. Om du har distribuerat andra resurser i den här resursgruppen tar kommandot också bort dem.

Ta bort Azure-resurserna med kommandot terraform destroy.

terraform destroy