Skapa ett nätverksisolerad Azure Kubernetes Service-kluster (AKS)

• Använd Bash-miljön i Azure Cloud Shell. Mer information finns i Kom igång med Azure Cloud Shell.

  

• Om du föredrar att köra CLI-referenskommandon lokalt installerar du Azure CLI. Om du kör i Windows eller macOS kan du köra Azure CLI i en Docker-container. Mer information finns i Så här kör du Azure CLI i en Docker-container.

  • Om du använder en lokal installation loggar du in på Azure CLI med hjälp av kommandot az login. Slutför autentiseringsprocessen genom att följa stegen som visas i terminalen. Andra inloggningsalternativ finns i Autentisera till Azure med Azure CLI.

  • När du uppmanas att installera Azure CLI-tillägget vid första användningen. Mer information om tillägg finns i Använda och hantera tillägg med Azure CLI.

  • Kör az version om du vill hitta versionen och de beroende bibliotek som är installerade. Om du vill uppgradera till den senaste versionen kör du az upgrade.

• Den här artikeln kräver version 2.73.0 eller senare av Azure CLI. Om du använder Azure Cloud Shell är den senaste versionen redan installerad där.
• Du bör installera aks-preview Azure CLI-tillägget version 9.0.0b2 eller senare om du använder utgående typ block (förhandsversion).
  • Om du inte redan har aks-preview tillägget installerar du det med kommandot az extension add .

    az extension add --name aks-preview
    

  • Om du redan har aks-preview tillägget uppdaterar du det så att du har den senaste versionen med kommandot az extension update .

    az extension update --name aks-preview
    

Ange miljövariabler

Ange de miljövariabler som används i hela den här artikeln. ACR-namnet måste vara globalt unikt och endast innehålla alfanumeriska tecken i gemener.

RESOURCE_GROUP="myResourceGroup"
LOCATION="eastus"
AKS_NAME="myAKSCluster"
VNET_NAME="myVNet"
AKS_SUBNET_NAME="aksSubnet"
ACR_SUBNET_NAME="acrSubnet"
APISERVER_SUBNET_NAME="apiServerSubnet"
REGISTRY_NAME="myregistry${RANDOM}"
CLUSTER_IDENTITY_NAME="clusterIdentity"
KUBELET_IDENTITY_NAME="kubeletIdentity"

az group create --name ${RESOURCE_GROUP} --location ${LOCATION}

• Ett Azure-konto med en aktiv prenumeration. Om du inte har ett konto kan du skapa ett kostnadsfritt konto innan du börjar.
• Installera och konfigurera Terraform.
• Azure CLI installerat och inloggat med hjälp av az login, används för att verifiera driftsättningen och ansluta till klustret. Installera Azure CLI om du inte redan har det.
• kubectl installerat för att ansluta till klustret. Om du använder Azure Cloud Shell är kubectl redan installerat. Om du vill installera det lokalt använder du az aks install-cli kommandot .
• jq installerad och används för att tolka Terraform-status när driftsättningen verifieras. Azure Cloud Shell har redan jq installerat.

Distribuera ett nätverksisolerat kluster med AKS-hanterad ACR

AKS skapar, hanterar och stämmer av en ACR-resurs i detta alternativ. Du behöver inte tilldela några behörigheter eller hantera ACR. AKS hanterar cacheregler, privat länk och privat slutpunkt som används i det isolerade nätverksklustret.

Skapa ett isolerat nätverkskluster

När du skapar ett nätverksisolerade AKS-kluster väljer du något av följande privata klusterlägen: privat länkbaserad eller API Server VNet-integrering.

Ange artefaktkällan och utgående typ baserat på dina krav på nätverksisolering.

Baserat på privat länk

Skapa ett privat länkbaserat isolerat nätverkskluster genom att köra kommandot az aks create med --bootstrap-artifact-sourceparametrarna , --enable-private-clusteroch --outbound-type .

az aks create --resource-group ${RESOURCE_GROUP} --name ${AKS_NAME} --bootstrap-artifact-source Cache --outbound-type none --network-plugin azure --enable-private-cluster

Integrering av VNet för API-server

Skapa ett isolerat nätverkskluster som konfigurerats med API Server VNet-integrering genom att köra kommandot az aks create med --bootstrap-artifact-sourceparametrarna , --enable-private-cluster--enable-apiserver-vnet-integration och --outbound-type .

az aks create --resource-group ${RESOURCE_GROUP} --name ${AKS_NAME} --bootstrap-artifact-source Cache --outbound-type none --network-plugin azure --enable-private-cluster --enable-apiserver-vnet-integration

Uppdatera ett befintligt AKS-kluster till en isolerad nätverkstyp

Om du hellre vill aktivera nätverksisolering i ett befintligt AKS-kluster i stället för att skapa ett nytt kluster använder du kommandot az aks update .

Om du vill aktivera den isolerade nätverksfunktionen i ett befintligt AKS-kluster kör du först följande kommando för att uppdatera bootstrap-artifact-source:

az aks update --resource-group ${RESOURCE_GROUP} --name ${AKS_NAME} --bootstrap-artifact-source Cache

Sedan måste du manuellt återskapa alla befintliga nodpooler:

az aks upgrade --resource-group ${RESOURCE_GROUP} --name ${AKS_NAME} --node-image-only

NODEPOOLS=$(az aks nodepool list \
--resource-group "${RESOURCE_GROUP}" \
--cluster-name "${AKS_NAME}" \
--query "[].name" -o tsv)
for NODEPOOL in $NODEPOOLS; do
echo "Waiting for node pool $NODEPOOL to finish upgrading..."
az aks nodepool wait \
--resource-group "${RESOURCE_GROUP}" \
--cluster-name "${AKS_NAME}" \
--name "$NODEPOOL" \
--updated
echo "Node pool $NODEPOOL upgrade succeeded."
done

Vänta och se till att återimering har slutförts och kör sedan följande kommando för att uppdatera outbound-type:

az aks update --resource-group ${RESOURCE_GROUP} --name ${AKS_NAME} --outbound-type none

Distribuera ett isolerat nätverkskluster med bring your own ACR

AKS har stöd för att ta med din egen (BYO) ACR. För att stödja BYO ACR-scenariot måste du konfigurera en privat ACR-slutpunkt och en privat DNS-zon innan du skapar AKS-klustret.

Följande steg visar hur du förbereder dessa resurser:

• Anpassat virtuellt nätverk och undernät för AKS och ACR.
• ACR, ACR-cacheregel, privat slutpunkt och privat DNS-zon.
• Anpassad kontrollplansidentitet och kubelet-identitet.

Steg 1: Skapa det virtuella nätverket och undernäten

az network vnet create  --resource-group ${RESOURCE_GROUP} --name ${VNET_NAME} --address-prefixes 192.168.0.0/16

az network vnet subnet create --name ${AKS_SUBNET_NAME} --vnet-name ${VNET_NAME} --resource-group ${RESOURCE_GROUP} --address-prefixes 192.168.1.0/24

SUBNET_ID=$(az network vnet subnet show --name ${AKS_SUBNET_NAME} --vnet-name ${VNET_NAME} --resource-group ${RESOURCE_GROUP} --query 'id' --output tsv)

az network vnet subnet create --name ${ACR_SUBNET_NAME} --vnet-name ${VNET_NAME} --resource-group ${RESOURCE_GROUP} --address-prefixes 192.168.2.0/24 --private-endpoint-network-policies Disabled

Steg 2: Inaktivera utgående anslutning för virtuellt nätverk (valfritt)

Gör till exempel AKS-undernätet privat genom att ange dess standardutgående åtkomst till false.

az network vnet subnet update --resource-group ${RESOURCE_GROUP} --vnet-name ${VNET_NAME} --name ${AKS_SUBNET_NAME} --default-outbound false

Andra metoder som stöds och övergångsöverväganden finns i Inaktivera utgående anslutning för virtuella nätverk.

Steg 3: Skapa ACR och aktivera artefaktcache

1. Skapa ACR med åtkomst till offentligt nätverk inaktiverad.

   az acr create --resource-group ${RESOURCE_GROUP} --name ${REGISTRY_NAME} --sku Premium --public-network-enabled false
   
   REGISTRY_ID=$(az acr show --name ${REGISTRY_NAME} -g ${RESOURCE_GROUP}  --query 'id' --output tsv)
   

2. Skapa en ACR-cacheregel med hjälp av följande kommando för att tillåta användare att cachelagrar MAR-containeravbildningar och binärfiler i den nya ACR. Namnet på cacheregeln och lagringsplatsens namn måste följa riktlinjerna i nästa avsnitt.

   az acr cache create -n aks-managed-mcr -r ${REGISTRY_NAME} -g ${RESOURCE_GROUP} --source-repo "mcr.microsoft.com/*" --target-repo "aks-managed-repository/*"
   

Steg 4: Skapa en privat slutpunkt för ACR

az network private-endpoint create --name myPrivateEndpoint --resource-group ${RESOURCE_GROUP} --vnet-name ${VNET_NAME} --subnet ${ACR_SUBNET_NAME} --private-connection-resource-id ${REGISTRY_ID} --group-id registry --connection-name myConnection

NETWORK_INTERFACE_ID=$(az network private-endpoint show --name myPrivateEndpoint --resource-group ${RESOURCE_GROUP} --query 'networkInterfaces[0].id' --output tsv)

REGISTRY_PRIVATE_IP=$(az network nic show --ids ${NETWORK_INTERFACE_ID} --query "ipConfigurations[?privateLinkConnectionProperties.requiredMemberName=='registry'].privateIPAddress" --output tsv)

DATA_ENDPOINT_PRIVATE_IP=$(az network nic show --ids ${NETWORK_INTERFACE_ID} --query "ipConfigurations[?privateLinkConnectionProperties.requiredMemberName=='registry_data_$LOCATION'].privateIPAddress" --output tsv)

Steg 5: Skapa en privat DNS-zon och lägg till resurser

Skapa en privat DNS-zon med namnet privatelink.azurecr.io. Lägg till posterna för registrets REST-slutpunkt {REGISTRY_NAME}.azurecr.io och registerdata-slutpunkten {REGISTRY_NAME}.{LOCATION}.data.azurecr.io.

az network private-dns zone create --resource-group ${RESOURCE_GROUP} --name "privatelink.azurecr.io"

az network private-dns link vnet create --resource-group ${RESOURCE_GROUP} --zone-name "privatelink.azurecr.io" --name MyDNSLink --virtual-network ${VNET_NAME} --registration-enabled false

az network private-dns record-set a create --name ${REGISTRY_NAME} --zone-name "privatelink.azurecr.io" --resource-group ${RESOURCE_GROUP}

az network private-dns record-set a add-record --record-set-name ${REGISTRY_NAME} --zone-name "privatelink.azurecr.io" --resource-group ${RESOURCE_GROUP} --ipv4-address ${REGISTRY_PRIVATE_IP}

az network private-dns record-set a create --name ${REGISTRY_NAME}.${LOCATION}.data --zone-name "privatelink.azurecr.io" --resource-group ${RESOURCE_GROUP}

az network private-dns record-set a add-record --record-set-name ${REGISTRY_NAME}.${LOCATION}.data --zone-name "privatelink.azurecr.io" --resource-group ${RESOURCE_GROUP} --ipv4-address ${DATA_ENDPOINT_PRIVATE_IP}

Steg 6: Skapa kontrollplan och kubelet-identiteter

Kontrollplansidentitet

az identity create --name ${CLUSTER_IDENTITY_NAME} --resource-group ${RESOURCE_GROUP}

CLUSTER_IDENTITY_RESOURCE_ID=$(az identity show --name ${CLUSTER_IDENTITY_NAME} --resource-group ${RESOURCE_GROUP} --query 'id' -o tsv)

CLUSTER_IDENTITY_PRINCIPAL_ID=$(az identity show --name ${CLUSTER_IDENTITY_NAME} --resource-group ${RESOURCE_GROUP} --query 'principalId' -o tsv)

Kubelet-identitet

az identity create --name ${KUBELET_IDENTITY_NAME} --resource-group ${RESOURCE_GROUP}

KUBELET_IDENTITY_RESOURCE_ID=$(az identity show --name ${KUBELET_IDENTITY_NAME} --resource-group ${RESOURCE_GROUP} --query 'id' -o tsv)

KUBELET_IDENTITY_PRINCIPAL_ID=$(az identity show --name ${KUBELET_IDENTITY_NAME} --resource-group ${RESOURCE_GROUP} --query 'principalId' -o tsv)

Om du uppdaterar ett befintligt AKS-kluster hoppar du över föregående kommandon för att skapa identiteter och hämtar det befintliga kubelet-identitetsobjekt-ID:t:

KUBELET_IDENTITY_PRINCIPAL_ID=$(az aks show --resource-group ${RESOURCE_GROUP} --name ${AKS_NAME} --query identityProfile.kubeletidentity.objectId -o tsv)

Bevilja pullbehörighet för ACR till kubelet-identiteten

Kontrollera registrets behörighetsläge för rolltilldelning och välj motsvarande pull-roll. ABAC-aktiverade register använder Container Registry Repository Reader rollen. Icke-ABAC-aktiverade register använder AcrPull rollen.

ROLE_ASSIGNMENT_MODE=$(az acr show --name ${REGISTRY_NAME} --resource-group ${RESOURCE_GROUP} --query roleAssignmentMode -o tsv)

if [[ "${ROLE_ASSIGNMENT_MODE}" == "rbac-abac" ]]; then
  ACR_PULL_ROLE="Container Registry Repository Reader"
else
  ACR_PULL_ROLE="AcrPull"
fi

az role assignment create --role "${ACR_PULL_ROLE}" --scope ${REGISTRY_ID} --assignee-object-id ${KUBELET_IDENTITY_PRINCIPAL_ID} --assignee-principal-type ServicePrincipal

När du har konfigurerat dessa resurser kan du fortsätta att skapa det nätverksisolerade AKS-klustret med BYO ACR.

Steg 7: Skapa ett isolerat nätverkskluster med BYO ACR

När du skapar ett isolerat nätverkskluster väljer du något av följande privata klusterlägen: privat länkbaserad eller API Server VNet-integrering.

Ange artefaktkällan och utgående typ baserat på dina krav på nätverksisolering.

Baserat på privat länk

Skapa ett privat länkbaserat isolerat nätverkskluster som kommer åt din ACR genom att köra kommandot az aks create med de parametrar som krävs.

az aks create --resource-group ${RESOURCE_GROUP} --name ${AKS_NAME} --vnet-subnet-id ${SUBNET_ID} --assign-identity ${CLUSTER_IDENTITY_RESOURCE_ID} --assign-kubelet-identity ${KUBELET_IDENTITY_RESOURCE_ID} --bootstrap-artifact-source Cache --bootstrap-container-registry-resource-id ${REGISTRY_ID} --outbound-type none --network-plugin azure --enable-private-cluster

Integrering av VNet för API-server

För ett isolerat nätverkskluster som konfigurerats med API Server VNet-integrering skapar du först ett undernät och tilldelar rätt roll med följande kommandon:

az network vnet subnet create --name ${APISERVER_SUBNET_NAME} --vnet-name ${VNET_NAME} --resource-group ${RESOURCE_GROUP} --address-prefixes 192.168.3.0/24 --delegations Microsoft.ContainerService/managedClusters

export APISERVER_SUBNET_ID=$(az network vnet subnet show --resource-group ${RESOURCE_GROUP} --vnet-name ${VNET_NAME} --name ${APISERVER_SUBNET_NAME} --query id -o tsv)

az role assignment create --scope ${APISERVER_SUBNET_ID} --role "Network Contributor" --assignee-object-id ${CLUSTER_IDENTITY_PRINCIPAL_ID} --assignee-principal-type ServicePrincipal

az role assignment create --scope ${SUBNET_ID} --role "Network Contributor" --assignee-object-id ${CLUSTER_IDENTITY_PRINCIPAL_ID} --assignee-principal-type ServicePrincipal

Skapa ett isolerat privat nätverkskluster som konfigurerats med API Server VNet-integrering och få åtkomst till din ACR genom att köra kommandot az aks create med de parametrar som krävs.

az aks create --resource-group ${RESOURCE_GROUP} --name ${AKS_NAME} --vnet-subnet-id ${SUBNET_ID} --assign-identity ${CLUSTER_IDENTITY_RESOURCE_ID} --assign-kubelet-identity ${KUBELET_IDENTITY_RESOURCE_ID} --bootstrap-artifact-source Cache --bootstrap-container-registry-resource-id ${REGISTRY_ID} --outbound-type none --network-plugin azure --enable-private-cluster --enable-apiserver-vnet-integration --apiserver-subnet-id ${APISERVER_SUBNET_ID}

Uppdatera ett befintligt AKS-kluster

Om du hellre vill aktivera nätverksisolering i ett befintligt AKS-kluster i stället för att skapa ett nytt kluster använder du kommandot az aks update .

När du skapar den privata slutpunkten och den privata DNS-zonen för BYO ACR använder du det befintliga virtuella nätverket och undernäten i det befintliga AKS-klustret. När du tilldelar lämplig ACR-pullroll till kubelet-identiteten använder du den befintliga kubelet-identiteten för det befintliga AKS-klustret.

Om du vill aktivera den isolerade nätverksfunktionen i ett befintligt AKS-kluster kör du först följande kommando för att uppdatera bootstrap-artifact-source:

az aks update --resource-group ${RESOURCE_GROUP} --name ${AKS_NAME} --bootstrap-artifact-source Cache --bootstrap-container-registry-resource-id ${REGISTRY_ID}

Sedan måste du manuellt återskapa alla befintliga nodpooler:

az aks upgrade --resource-group ${RESOURCE_GROUP} --name ${AKS_NAME} --node-image-only

NODEPOOLS=$(az aks nodepool list \
--resource-group "${RESOURCE_GROUP}" \
--cluster-name "${AKS_NAME}" \
--query "[].name" -o tsv)
for NODEPOOL in $NODEPOOLS; do
echo "Waiting for node pool $NODEPOOL to finish upgrading..."
az aks nodepool wait \
--resource-group "${RESOURCE_GROUP}" \
--cluster-name "${AKS_NAME}" \
--name "$NODEPOOL" \
--updated
echo "Node pool $NODEPOOL upgrade succeeded."
done

Vänta och se till att återimering har slutförts och kör sedan följande kommando för att uppdatera outbound-type:

az aks update --resource-group ${RESOURCE_GROUP} --name ${AKS_NAME} --outbound-type none

Uppdatera ditt ACR-ID

Du kan uppdatera den privata ACR som används med ett isolerat nätverkskluster. Använd kommandot för att identifiera resurs-ID: az aks show t för ACR.

az aks show --resource-group ${RESOURCE_GROUP} --name ${AKS_NAME}

Uppdatering av ACR-ID:t utförs genom att köra az aks update kommandot med parametrarna --bootstrap-artifact-source och --bootstrap-container-registry-resource-id .

az aks update --resource-group ${RESOURCE_GROUP} --name ${AKS_NAME} --bootstrap-artifact-source Cache --bootstrap-container-registry-resource-id <new-byo-acr-resource-id>

När du uppdaterar ACR-ID:t i ett befintligt kluster måste du manuellt återskapa alla befintliga noder.

az aks upgrade --resource-group ${RESOURCE_GROUP} --name ${AKS_NAME} --node-image-only

Distribuera ett nätverksisolerade kluster med Terraform

Det här Terraform-exemplet distribuerar ett nätverksisolerat kluster med hjälp av det AKS-hanterade ACR-alternativet som beskrivs tidigare i den här artikeln. AzureRM-providern exponerar ännu inte alla nätverksisolerade bootstrap-inställningar som det här exemplet använder, så exemplet använder AzAPI-providern för att distribuera den hanterade klusterresursen mot den api-version som krävs. Ett Terraform-exempel för alternativet BYO (Bring Your Own) ACR är inte tillgängligt för närvarande. Om du vill använda BYO ACR följer du Azure CLI vägledning tidigare i den här artikeln.

Exemplet distribuerar följande resurser:

• En resursgrupp (Microsoft.Resources/resourceGroups).
• Ett nätverksisolerade AKS-kluster (Microsoft.ContainerService/managedClusters) som använder:
  • En systemtilldelad hanterad identitet.
  • En enskild systemnodpool med en Standard_D2s_v3 nod och automatisk skalning inaktiverad.
  • Nätverkspluginet azure, med outboundType inställt på none, så att klustret inte har några utgående nätverksberoenden vid uppstart.
  • apiServerAccessProfile.enablePrivateCluster inställd på true, vilket skapar ett privat länkbaserat privat kluster.
  • bootstrapProfile.artifactSource inställd på Cache, så att AKS skapar, hanterar och synkroniserar sin egen ACR-cache för att bootstrapa klustret i stället för att hämta direkt från Microsoft Artifact Registry (MAR). Som du beskrev tidigare i den här artikeln behöver du inte skapa eller hantera den här ACR själv, och AKS hanterar cacheregler, privat länk och privat slutpunkt som det nätverksisolerade klustret använder.

Klustret skapas med standardversionen av Kubernetes som stöds i distributionsregionen. Om du vill låsa till en specifik version lägger du till kubernetesVersion i klustrets properties-block i main.tf och bekräftar att versionen är tillgänglig i regionen genom att använda kommandot az aks get-versions.

1. Skapa en katalog för att testa Terraform-exempelkoden och gör den till den aktuella katalogen.

2. Skapa en fil med namnet main.tf och kopiera följande testade exempelkonfiguration till den.

   terraform {
     required_version = ">= 1.6.0"
   
     required_providers {
       azapi = {
         source  = "Azure/azapi"
         version = "~> 2.0"
       }
       random = {
         source  = "hashicorp/random"
         version = "~> 3.6"
       }
     }
   }
   
   provider "azapi" {}
   
   resource "random_string" "suffix" {
     length  = 6
     upper   = false
     special = false
   }
   
   locals {
     location            = "westus2"
     resource_group_name = "rg-aks-network-isolated-${random_string.suffix.result}"
     aks_name            = "aks-netisolated-${random_string.suffix.result}"
     dns_prefix          = "aksnetiso${random_string.suffix.result}"
   }
   
   resource "azapi_resource" "resource_group" {
     type     = "Microsoft.Resources/resourceGroups@2024-03-01"
     name     = local.resource_group_name
     location = local.location
   }
   
   resource "azapi_resource" "aks_cluster" {
     type      = "Microsoft.ContainerService/managedClusters@2025-08-01"
     name      = local.aks_name
     parent_id = azapi_resource.resource_group.id
     location  = local.location
   
     identity {
       type = "SystemAssigned"
     }
   
     body = {
       properties = {
         dnsPrefix = local.dns_prefix
         agentPoolProfiles = [
           {
             name              = "systempool"
             count             = 1
             vmSize            = "Standard_D2s_v3"
             mode              = "System"
             osType            = "Linux"
             type              = "VirtualMachineScaleSets"
             enableAutoScaling = false
           }
         ]
         networkProfile = {
           networkPlugin = "azure"
           outboundType  = "none"
         }
         apiServerAccessProfile = {
           enablePrivateCluster = true
         }
         bootstrapProfile = {
           artifactSource = "Cache"
         }
       }
     }
   }
   

Initiera Terraform

Kör terraform init för att initiera Terraform-distributionen. Detta kommando laddar ned de leverantörer, azapi och random, som krävs för att hantera resurserna i det här exemplet.

terraform init -upgrade

Formatera och verifiera konfigurationen

Kör terraform fmt för att formatera konfigurationsfilen och terraform validate bekräfta att konfigurationen är syntaktiskt giltig.

terraform fmt
terraform validate

Skapa en Terraform-utförandeplan

Kör terraform plan för att skapa en exekveringsplan.

terraform plan -out main.tfplan

Tillämpa en Terraform-utförandeplan

Kör terraform apply för att tillämpa körningsplanen på din Azure-prenumeration.

terraform apply main.tfplan

Det tar flera minuter att skapa resursgruppen och det privata, nätverksisolerade AKS-klustret.

Verifiera driftsättningen

Det här exemplet definierar inte Terraform-utdata, så använd terraform show -json med jq för att hämta den genererade resursgruppen och klusternamnen från resurstillståndet när det är terraform apply klart. Du hanterar båda resurserna med providern azapi och deras name attribut innehåller det lösta resursnamnet.

RESOURCE_GROUP=$(terraform show -json | jq -r '.values.root_module.resources[] | select(.address=="azapi_resource.resource_group") | .values.name')
AKS_NAME=$(terraform show -json | jq -r '.values.root_module.resources[] | select(.address=="azapi_resource.aks_cluster") | .values.name')

Bekräfta att klustret skapades med de förväntade nätverksisolerade inställningarna med hjälp az aks show av kommandot .

az aks show --resource-group $RESOURCE_GROUP --name $AKS_NAME --query "{outboundType:networkProfile.outboundType, artifactSource:bootstrapProfile.artifactSource, privateCluster:apiServerAccessProfile.enablePrivateCluster}"

Utdata visar outboundType inställt på none, artifactSource inställt på Cache och privateCluster inställt på true, vilket bekräftar att klustret är nätverksisolerat och startas från den AKS-hanterade ACR-cachen.

Anslut till klustret

Eftersom det här är ett privat kluster ansluter du från en klient som har en tillgänglig nätverkslinje till klustrets privata slutpunkt, till exempel en virtuell dator i samma eller peerkopplade virtuella nätverk, eller Azure Cloud Shell om den är ansluten till klustrets virtuella nätverk. Hämta autentiseringsuppgifterna för klustret med kommandot az aks get-credentials och verifiera sedan anslutningen med kommandot kubectl get nodes.

az aks get-credentials --resource-group $RESOURCE_GROUP --name $AKS_NAME
kubectl get nodes

Rensa resurser

Om du inte längre behöver de resurser som skapats i den här artikeln tar du bort dem för att undvika ytterligare avgifter.

Kör terraform plan med -destroy flaggan för att granska vad Terraform tar bort.

terraform plan -destroy -out main.destroy.tfplan

Kör terraform apply för att tillämpa destruera-planen och ta bort alla resurser som skapats av det här exemplet.

terraform apply main.destroy.tfplan