Planera flexnoder för AKS (förhandsversion)

Important

AKS-förhandsversionsfunktioner är tillgängliga via självbetjäning och frivillig registrering. Förhandsversioner tillhandahålls "i befintligt skick" och "i mån av tillgång," och de är undantagna från servicenivåavtal och begränsad garanti. AKS-förhandsversioner stöds delvis av kundsupport efter bästa förmåga. Därför är dessa funktioner inte avsedda för produktionsanvändning. Mer information finns i följande supportartiklar:

Flex-noder utökar ett Azure Kubernetes Service (AKS) kluster till Linux-datorer som du hanterar utanför klustrets Azure-hanterade nodpooler. Innan du lägger till en flexnod behöver du välja hur värden autentiserar sig mot Azure, hur den når Kubernetes API-servern och hur nätverkstrafik flödar mellan AKS- och flexnodsmiljöerna.

Den här artikeln hjälper dig att fatta dessa beslut, planera icke-överlappande adressintervall och skapa en delad miljöfil för de återstående distributionsartiklarna.

Innan du börjar

  • Granska översikten över flexnoder för AKS.
  • Granska identitets- och åtkomstbegrepp för flexnoder.
  • Granska nätverksbegrepp för flexnoder.
  • Använd en Linux-kompatibel Bash-miljö som har nödvändiga verktyg och nätverksåtkomst. I den här distributionsserien kallas den miljön för din Bash-miljö. Den separata dator som ansluter till klustret är flexnodvärden.
  • Installera Azure CLI. Kör az --version för att hitta den installerade versionen. Information om hur du installerar eller uppgraderar finns i Installera Azure CLI.
  • Logga in på Azure med ett konto som kan läsa målprenumerationen och konfigurationen av virtuella nätverk.
  • Förbered ett befintligt Azure virtuellt nätverk och undernät för de Azure hanterade AKS-noderna. Det virtuella nätverket kan finnas i en annan resursgrupp än AKS-klustret. När det är det kontrollerar du att AKS-klusteridentiteten har de behörigheter som krävs för undernätet.

Fatta driftsättningsbesluten

Planera följande beslut innan du skapar eller konfigurerar resurser.

Beslut Options Vad beslutet styr
Värdidentitet Hanterad identitet, Azure Arc hanterad identitet eller tjänstens huvudnamn Så här autentiserar flexnodagenten till Azure
AKS API-åtkomst Offentligt eller privat AKS-kluster Så här löser och når dina Bash-miljöer och flexnodvärdar Kubernetes API-servern
Flex-nodanslutning Layer 3-anslutning eller en Unbounded-Net WireGuard-gateway Så här kommunicerar AKS-hanterade noder, flexnoder, poddar och Kubernetes-tjänster

Dessa beslut gäller olika delar av distributionen. Om du till exempel väljer en offentlig AKS API-slutpunkt skapas inte nätverksanslutning mellan AKS-hanterade noder och flexnodvärdar.

Välj värdidentitet

Använd beslutstabellen i identitets- och åtkomstbegrepp för flexnoder för att välja den Azure identitet som flexnodagenten använder.

Värdidentiteten auktoriserar Azure-åtgärder. Den ersätter inte nätverksanslutningen eller Kubernetes bootstrap-konfigurationen som värddatorn behöver för att gå med i klustret. Lagra inte autentiseringsuppgifter i den delade miljöfilen.

Välj offentlig eller privat AKS API-åtkomst

Kubernetes API-servern är hanteringsslutpunkten för klustret. Din Bash-miljö och varje värd för flexnoder måste kunna namnupplösa och ansluta till denna slutpunkt.

  • Offentlig AKS API-åtkomst använder en skyddad offentlig slutpunkt. Kubernetes-autentisering och -auktorisering styr fortfarande åtkomsten till klustret. En offentlig API-slutpunkt exponerar inte de program som körs i klustret.
  • Privat AKS API-åtkomst använder en privat slutpunkt i det virtuella AKS-nätverket. Kör kommandona Azure CLI, kubectloch klusterkonfiguration i Bash-miljön, som måste köras på en dator som är ansluten till det privata nätverket. Flex-nodnätverket måste också kunna matcha klustrets privata DNS-namn och dirigera trafik till den privata slutpunkten.

Flex-noddistributioner stöder både offentlig och privat åtkomst till API-servern. Den privata sökvägen kräver ytterligare dns-, routnings- och kommandokörningskonfiguration, som anges var den gäller. Allmän AKS-vägledning finns i Planera kontrollplansnätverk för AKS, Skapa ett privat AKS-kluster och Anslut till ett privat AKS-kluster.

Välj flexnodanslutningen

Den här distributionsserien skapar AKS-klustret utan ett inbyggt nätverksinsticksprogram och installerar Unbounded-Net på både AKS-hanterade noder och flexnoder. Unbounded-Net tilldelar poddadressintervall och konfigurerar routning mellan AKS- och flexnodmiljöerna. I den här artikeln beskrivs arbetsflödet. Andra CNI- eller nätverkskonfigurationer kan kräva olika konfigurationer för routning, brandvägg, DNS, gateway, säkerhet och livscykel. En förklaring av nätverksmodellen för offentlig förhandsversion finns i nätverksbegrepp för flexnoder.

Du anger den underliggande nätverksanslutningen mellan AKS- och flexnodmiljöerna. Layer 3-anslutning innebär att båda nodnätverken redan kan dirigera IP-paket till varandras nodadresser i båda riktningarna. Välj den metod som passar ditt befintliga nätverk:

Anslutningsmetod När du ska använda detta
Peering för virtuella nätverk AKS-klustret och värdar för flexnoder ligger i virtuella Azure-nätverk, inklusive virtuella nätverk i olika regioner.
VPN-gateway Flex-nodvärdarna finns i en lokal miljö eller ett annat nätverk som ansluter till Azure via ett krypterat plats-till-plats-VPN.
ExpressRoute Din organisation använder en dedikerad privat anslutning mellan nätverket och Azure.
Unbounded-Net WireGuard gateway AKS- och flexnodnätverken har ingen privat dirigerad anslutning. Du konfigurerar och driver WireGuard-tunnlarna i en gatewaynodpool i AKS, och dessa gatewaynoder måste vara publikt tillgängliga. Planera för gateway-kapacitet och tillgänglighet, eftersom podtrafik mellan miljöer är beroende av den här poolen. Se det offentliga AKS-klustret med Unbounded-Net WireGuard-labb.

Genomgången i Microsoft Learn använder lager 3-anslutning med Unbounded-Net.

AKS-API Flex-nodanslutning Riktlinjer
Public Layer 3-anslutning Rekommenderad konfiguration
Privat Layer 3-anslutning Kräver ytterligare konfiguration av DNS, routning och kommandokörning
Public Offentlig WireGuard-gateway Alternativ topologi; se AKSFlexNode-labb
Privat Offentlig WireGuard-gateway Omfattas inte av den här dokumentationen

Note

Ytterligare topologiexempel finns i AKSFlexNode-labb, inklusive exempel som använder en offentlig AKS API-server med en WireGuard-gateway och en privat AKS API-server med kundhanterat nätverk. De här labbarna kompletterar konfigurationen som beskrivs i den här artikeln. Dessa labb kan använda olika nätverkskomponenter och ha olika drifts- eller supportansvar. Innan du använder ett labb granskar du dess krav, begränsningar, tillämpliga komponentversioner och kundansvar. Ett GitHub labb expanderar inte det stödomfång som beskrivs i Microsoft Learn.

Om du vill ge feedback om en topologi som inte representeras öppnar du ett problem på AKSFlexNode-lagringsplatsen. Inkludera flexnodens värdplats, AKS API-åtkomstmodell, föreslagen anslutningsmetod, föreslagen CNI och de nätverkssökvägar som krävs i scenariot.

Planera den nödvändiga nätverksanslutningen

Arbeta med nätverksadministratören för att säkerställa att nätverksdesignen ger följande anslutning:

Krav Varför det krävs
Bash-miljön kan matcha och nå AKS API-servern. Du behöver den här anslutningen för att konfigurera och hantera klustret.
Varje flexnodvärd kan matcha och nå AKS API-servern. Flexnodagenten och kubelet använder den här anslutningen för att ansluta till klustret och kommunicera med Kubernetes kontrollplan.
AKS-hanterade noder och flexnodvärdar kan nå varandras privata IP-adresser. För de flesta anslutningsmetoder använder Unbounded-Net nätverken för noderna som den underliggande kommunikationsvägen mellan de två miljöerna.
Podd- och Kubernetes-tjänsttrafik kan dirigeras mellan AKS-hanterade noder och flexnoder. Arbetsbelastningar behöver kommunikation mellan noder, kluster-DNS och Kubernetes-tjänståtkomst.
AKS-kontrollplanet kan ansluta till kubelet på en flexnod. AKS använder den här sökvägen för kubelet-åtgärder, inklusive kubectl logs, kubectl execoch kubectl port-forward.

Du konfigurerar och använder det externa värdnätverket, inklusive routning, peering för virtuella nätverk, VPN- eller ExpressRoute-anslutningar, brandväggs- och nätverkssäkerhetsgruppsregler, DNS, proxyinställningar och den Unbounded-Net konfiguration som dokumenteras i den här serien. Den fullständiga ansvarsmodellen finns i supportprincip för flexnoder.

Begränsa åtkomsten för värdhantering till godkända källadresser. För en Azure virtuell dator associerar du en nätverkssäkerhetsgrupp med värdundernätet eller nätverksgränssnittet. Använd motsvarande brandväggskontroller för en värd utanför Azure. Om du använder az vm create för att skapa en flexnodvärd, granskar du eventuella offentliga IP-adresser och regler för nätverkssäkerhetsgrupper som kommandot skapar. Om du inte begränsar SSH-regeln kan den tillåta anslutningar till TCP-port 22 från alla offentliga källor.

Samla in driftsättningsvärdena

De återstående artiklarna återanvänder följande värden.

Vanliga Azure resursvärden

Variabel Description När den används
SUBSCRIPTION_ID Prenumeration som innehåller AKS-klustret och relaterade Azure resurser. Varje driftsättning
RESOURCE_GROUP Resursgrupp som innehåller AKS-klustret. Varje driftsättning
CLUSTER_NAME Namnet på AKS-klustret. Varje driftsättning
FLEX_POOL_NAME Namnet på flexnodpoolen. Använd endast bokstäver och siffror. Varje driftsättning
AKS_API_ACCESS API-åtkomstmodell för AKS-klustret. Ange värdet till public eller private. Klusterförberedelse och API-anslutningsverifiering
AKS_RESOURCE_ID Azure resurs-ID för AKS-klustret. Azure ger det här värdet när klustret finns. Senare artiklar

VÄRDEN för AKS-kluster och virtuella nätverk

Variabel Description När den används
LOCATION Azure region för AKS-klustret. Bekräfta att den här regionen uppfyller kravet på regional tillgänglighet . Skapa AKS-klustret
AKS_VNET_NAME Namnet på det virtuella nätverk som innehåller AKS-undernätet. Hitta och verifiera AKS-undernätet
AKS_VNET_RESOURCE_GROUP Resursgrupp som innehåller det virtuella AKS-nätverket. Det kan skilja sig från RESOURCE_GROUP. Hitta och verifiera AKS-undernätet
AKS_SUBNET_NAME Namnet på det undernät som används av de Azure-hanterade AKS-noderna. Hitta och verifiera AKS-undernätet
AKS_SUBNET_ID Azure resurs-ID för AKS-undernätet. Skapa AKS-klustret
AKS_NODE_VM_SIZE Azure VM-storlek för Azure-hanterad AKS-systemnodpool. Det här värdet bestämmer inte storleken på flexnodens värd. Skapa AKS-klustret
SERVICE_CIDR Adressintervall för Kubernetes-tjänster. Konfigurera AKS-klusternätverksprofilen
DNS_SERVICE_IP IP-adress för Kubernetes DNS-tjänsten. Konfigurera AKS-klusternätverksprofilen

Hämta RESURS-ID och adressintervall för AKS-undernätet innan du skapar miljöfilen:

az network vnet subnet show \
    --resource-group '<virtual-network-resource-group>' \
    --vnet-name '<virtual-network-name>' \
    --name '<aks-subnet-name>' \
    --query "{ResourceId:id,AddressPrefix:addressPrefix,AddressPrefixes:addressPrefixes}" \
    --output json

AKS- och Unbounded-Net-adressvärden

Du använder SERVICE_CIDR och DNS_SERVICE_IP för att konfigurera AKS-klusternätverksprofilen. Konfigurera noden och podd-CIDR:erna för att konfigurera de Unbounded-Net webbplatser som används i den här genomgången.

AKS-noden, AKS-podden, flexnoden, flexpodden och Kubernetes-tjänstintervallen måste följa den valda nätverksdesignen och får inte överlappa varandra eller något nätverk som kan nås via peering för virtuella nätverk, VPN eller ExpressRoute. Samordna de slutliga värdena med nätverksadministratören.

Kopiera inte exempel-CIDR från en annan distribution. CIDR identifierar routbart adressutrymme, så att återanvända ett exempel som överlappar dina Azure eller anslutna nätverk kan göra trafiken tvetydig eller förhindra att noder och poddar når varandra.

Variabel Description Används av
AKS_SUBNET_CIDR Adressintervall som tilldelats undernätet för Azure-hanterade AKS-noder. Azure virtuellt nätverk och AKS-undernätsverifiering
AKS_NODE_CIDR Unbounded-Net platsnodintervall som innehåller AKS-nodens undernät. Unbounded-Net primära klusterwebbplatsen
AKS_POD_CIDR Adresspool för poddar på Azure-hanterade AKS-noder. Unbounded-Net primära klusterwebbplatsen
FLEX_HOST_SUBNET_CIDR Adressområde som innehåller värdarna för flexnoderna. Validering av nätverk för värddator för Flex-nod
FLEX_NODE_CIDR Unbounded-Net platsnodintervall som innehåller flexnodens värdundernät. Unbounded-Net-site för flexnoder
FLEX_POD_CIDR Adresspool för poddar på flexnoder. Unbounded-Net-site för flexnoder
SERVICE_CIDR Adressintervall för Kubernetes-tjänster. Nätverksprofil för AKS-kluster
DNS_SERVICE_IP IP-adress för Kubernetes DNS-tjänsten. Nätverksprofil för AKS-kluster

Tillämpa följande regler på adressplanen:

  • AKS_SUBNET_CIDR måste finnas i AKS_NODE_CIDR.
  • FLEX_HOST_SUBNET_CIDR måste finnas i FLEX_NODE_CIDR.
  • DNS_SERVICE_IP måste finnas inuti SERVICE_CIDR.

Dessa åtta värden är inte åtta separata intervall. Fem är oberoende intervall som inte får överlappa varandra, två är undernätsintervall inom motsvarande platsnodintervall och ett är en enda IP-adress inom tjänstintervallet.

Följande värden uppfyller alla regler i det här avsnittet. Behandla dem som en illustration av relationerna, inte som standardvärden. Kontrollera dina egna värden mot adressutrymmet i Azure och det anslutna nätverket innan du använder dem.

Variabel Example Relationship
AKS_NODE_CIDR 10.10.0.0/16 Fristående intervall
AKS_SUBNET_CIDR 10.10.1.0/24 Finns i AKS_NODE_CIDR
AKS_POD_CIDR 10.244.0.0/16 Fristående intervall
FLEX_NODE_CIDR 10.20.0.0/16 Fristående intervall
FLEX_HOST_SUBNET_CIDR 10.20.1.0/24 Finns i FLEX_NODE_CIDR
FLEX_POD_CIDR 10.245.0.0/16 Fristående intervall
SERVICE_CIDR 10.96.0.0/16 Fristående intervall
DNS_SERVICE_IP 10.96.0.10 Inuti SERVICE_CIDR

Granska aktuella Azure virtuella nätverksadressutrymmen:

az network vnet list \
    --query "[].{ResourceGroup:resourceGroup,Name:name,AddressPrefixes:addressSpace.addressPrefixes}" \
    --output table

Azure kan identifiera konflikter inom de resurser som hanteras, men det kan inte verifiera adressintervall i alla anslutna lokala eller externa nätverk.

Komponentversionsvärden

Flex-noder kräver kompatibla versioner av AKS, Azure CLI-tillägget, Unbounded-Net och flexnodagenten. Använd versionerna som anges i den här artikeln och välj eller uppgradera inte dessa komponenter oberoende av varandra.

Variabel Description
AKS_VERSION Kubernetes-version som stöds för AKS-klustret.
AKS_PREVIEW_VERSION aks-previewAzure CLI tilläggsversion 22.0.0b8 eller senare.
UNBOUNDED_VERSION Stöds Unbounded-Net version.
AKS_FLEX_NODE_VERSION Flex Node-agentversion som stöds.

Regional tillgänglighet

Flex-noder kräver AKS-version v20260904 eller senare i den region som är värd för klustret. AKS tillämpar dessa datumbaserade versioner automatiskt och de är separata från Kubernetes-versionen som du angav i AKS_VERSION.

Innan du skapar eller väljer ett kluster öppnar du fliken AKS-version i AKS-versionsspåraren, letar upp din region och kontrollerar versionen under För närvarande i drift. AKS-versionsversioner använder vYYYYMMDD formatet. Om din region visar en tidigare version väntar du på att versionen ska nå regionen eller, om dina distributionskrav tillåter det, välja en region där den nödvändiga versionen är tillgänglig.

Värde för lokal arbetsyta

Variabel Description
WORK_DIR Katalog i bash-miljön där de återstående artiklarna lagrar nedladdningar, genererade filer och kubeconfig-klustrets fil. Standardvärdet är ~/.local/share/aksflexnode/<deployment-name>. Om du vill behålla filerna någon annanstans, till exempel en tillfällig katalog som du tar bort efter distributionen, ändrar WORK_DIR du värdet i miljöfilen.

Skapa den delade miljöfilen

Skapa en miljöfil för varje distribution. Filen ser till att de icke-hemliga värdena förblir konsekventa mellan de återstående artiklarna och terminalsessionerna.

Lagra inte åtkomsttoken, bootstrap-data, kubeconfig-innehåll, autentiseringsuppgifter för tjänstens huvudnamn, certifikat, privata certifikatnycklar eller privata SSH-nycklar i den här filen.

  1. Välj en kort distributionsetikett och skapa en skyddad katalog för miljöfilen.

    export FLEXNODE_DEPLOYMENT="flexnode-demo"
export FLEXNODE_ENV_DIR="${HOME}/.config/aks-flexnode"
export FLEXNODE_ENV_FILE="${FLEXNODE_ENV_DIR}/${FLEXNODE_DEPLOYMENT}.env"

install -d -m 0700 "${FLEXNODE_ENV_DIR}"

  2. Skapa miljöfilen.

    if [[ -e "${FLEXNODE_ENV_FILE}" ]]; then
    printf 'Environment file already exists: %s\n' "${FLEXNODE_ENV_FILE}" >&2
    false
else
    install -m 0600 /dev/null "${FLEXNODE_ENV_FILE}"

    cat > "${FLEXNODE_ENV_FILE}" <<'EOF'
set_flexnode_env() {
    if [[ "$#" -ne 2 || ! "$1" =~ ^[A-Za-z_][A-Za-z0-9_]*$ ]]; then
        printf 'Usage: set_flexnode_env NAME VALUE\n' >&2
        return 2
    fi

    local name="$1"
    local value="$2"
    local temporary_file

    temporary_file="$(mktemp "$(dirname "${FLEXNODE_ENV_FILE}")/flexnode.env.XXXXXX")" || return 1
    awk -v prefix="export ${name}=" 'index($0, prefix) != 1 { print }' \
        "${FLEXNODE_ENV_FILE}" > "${temporary_file}" || {
        rm -f "${temporary_file}"
        return 1
    }

    printf 'export %s=%q\n' "${name}" "${value}" >> "${temporary_file}" || {
        rm -f "${temporary_file}"
        return 1
    }

    install -m 0600 "${temporary_file}" "${FLEXNODE_ENV_FILE}" || {
        rm -f "${temporary_file}"
        return 1
    }

    rm -f "${temporary_file}"
    export "${name}=${value}"
}

# Customer inputs
export SUBSCRIPTION_ID='<subscription-id>'
export LOCATION='<supported-aks-region>'
export RESOURCE_GROUP='<aks-resource-group>'
export CLUSTER_NAME='<aks-cluster-name>'
export FLEX_POOL_NAME='<flex-node-pool-name>'
export AKS_API_ACCESS='<public-or-private>'

# AKS virtual network
export AKS_VNET_NAME='<virtual-network-name>'
export AKS_VNET_RESOURCE_GROUP='<virtual-network-resource-group>'
export AKS_SUBNET_NAME='<aks-subnet-name>'
export AKS_SUBNET_ID='<aks-subnet-resource-id>'

# Network address ranges
export AKS_SUBNET_CIDR='<aks-node-subnet-cidr>'
export AKS_POD_CIDR='<aks-pod-cidr>'
export AKS_NODE_CIDR='<aks-site-node-cidr>'
export FLEX_HOST_SUBNET_CIDR='<flex-host-subnet-cidr>'
export FLEX_NODE_CIDR='<flex-site-node-cidr>'
export FLEX_POD_CIDR='<flex-node-pod-cidr>'
export SERVICE_CIDR='<kubernetes-service-cidr>'
export DNS_SERVICE_IP='<kubernetes-dns-service-ip>'

# Azure-managed AKS system node pool
export AKS_NODE_VM_SIZE='<supported-and-available-aks-node-vm-size>'

# Compatible component versions for flex nodes (preview)
export AKS_VERSION='1.36.2'
export AKS_PREVIEW_VERSION='22.0.0b8'
export UNBOUNDED_VERSION='v0.8.0'
export AKS_FLEX_NODE_VERSION='v0.2.0'

# Local paths
export WORK_DIR="${HOME}/.local/share/aksflexnode/${FLEXNODE_DEPLOYMENT}"

# Values recorded by later articles
export AKS_RESOURCE_ID=''
export FLEXNODE_KUBECONFIG=''
export FLEX_POOL_RESOURCE_ID=''
export FLEX_MACHINE_NAME=''
export FLEX_HOST_NAME=''
export FLEX_HOST_SSH_TARGET=''
export FLEX_HOST_PRIVATE_IP=''
export HOST_PRINCIPAL_OBJECT_ID=''
export HOST_IDENTITY_CLIENT_ID=''
export SSH_PUBLIC_KEY_PATH=''
export SSH_PRIVATE_KEY_PATH=''
export VM_RESOURCE_GROUP=''
export VM_NAME=''
export VM_RESOURCE_ID=''
export ARC_RESOURCE_GROUP=''
export ARC_MACHINE_NAME=''
export ARC_RESOURCE_ID=''
export SP_TENANT_ID=''
export SP_CLIENT_ID=''
export SP_OBJECT_ID=''
EOF
fi

    Hjälpverktyget set_flexnode_env gör att efterföljande artiklar kan registrera Azure-genererade värden utan att lägga till duplicerade definitioner i filen.

  3. Öppna ${FLEXNODE_ENV_FILE} i en redigerare och ersätt varje värde som omges av vinkelparenteser. Lämna värdena under Värden som registrerats av senare artiklar tomma.

  4. Kontrollera att inga platshållare finns kvar.

    if grep -n '<[^>]*>' "${FLEXNODE_ENV_FILE}"; then
    printf 'Replace the unresolved placeholders before you continue.\n' >&2
    false
else
    printf 'No unresolved placeholders found.\n'
fi

  5. Läs in miljöfilen, skapa arbetskatalogen och ange den aktiva Azure prenumerationen.

    source "${FLEXNODE_ENV_FILE}"
install -d -m 0700 "${WORK_DIR:?Load the deployment environment first.}"
az account set --subscription "${SUBSCRIPTION_ID}"
az account show \
    --query "{Name:name,SubscriptionId:id}" \
    --output table

    Bekräfta att det returnerade prenumerations-ID:t matchar SUBSCRIPTION_ID.

    Bekräfta att AKS_API_ACCESS identifierar en sökväg som stöds:

    case "${AKS_API_ACCESS}" in
    public|private)
        printf 'AKS API access: %s\n' "${AKS_API_ACCESS}"
        ;;
    *)
        printf 'Set AKS_API_ACCESS to public or private.\n' >&2
        false
        ;;
esac

    Starta varje ny terminalsession genom att ange distributionsetiketten och läsa in dess miljöfil:

    export FLEXNODE_DEPLOYMENT="flexnode-demo"
export FLEXNODE_ENV_FILE="${HOME}/.config/aks-flexnode/${FLEXNODE_DEPLOYMENT}.env"
test -s "${FLEXNODE_ENV_FILE}"
source "${FLEXNODE_ENV_FILE}"
install -d -m 0700 "${WORK_DIR:?Load the deployment environment first.}"

Verifiera planeringsvärdena

Verifiera det valda AKS-undernätet.

az network vnet subnet show \
    --resource-group "${AKS_VNET_RESOURCE_GROUP}" \
    --vnet-name "${AKS_VNET_NAME}" \
    --name "${AKS_SUBNET_NAME}" \
    --query "{AddressPrefix:addressPrefix,AddressPrefixes:addressPrefixes,ResourceId:id}" \
    --output json

Bekräfta att det returnerade resurs-ID:t och adressintervallet matchar AKS_SUBNET_ID och AKS_SUBNET_CIDR.

Nästa steg

Förbered sedan ett AKS-kluster för flexnoder. I nästa artikel skapas det offentliga eller privata AKS-klustret och klustrets resurs-ID registreras.

  • Uppdaterades senast