Flexknooppunten plannen voor AKS (preview)

Important

AKS preview-functies zijn beschikbaar op selfservice, opt-in basis. Previews worden geleverd 'zoals het is' en 'voor zover beschikbaar' en zijn uitgesloten van de serviceovereenkomsten en beperkte garantie. AKS-previews worden gedeeltelijk gedekt door klantondersteuning naar best vermogen. Zodoende zijn deze functies niet bedoeld voor productiegebruik. Zie de volgende ondersteuningsartikelen voor meer informatie:

Flexknooppunten breiden een Azure Kubernetes Service (AKS)-cluster uit naar Linux-machines die u buiten de Azure beheerde knooppuntgroepen van het cluster beheert. Voordat u een flexknooppunt toevoegt, kiest u hoe de host wordt geverifieerd bij Azure, hoe deze de Kubernetes API-server bereikt en hoe netwerkverkeer tussen de AKS- en flexknooppuntomgevingen wordt verplaatst.

Dit artikel helpt u bij het nemen van deze beslissingen, het plannen van niet-overlapping van adresbereiken en het maken van een gedeeld omgevingsbestand voor de resterende implementatieartikelen.

Voordat u begint

  • Bekijk het overzicht van flexknooppunten voor AKS.
  • Bekijk identiteits- en toegangsconcepten voor flexknooppunten.
  • Bekijk de netwerkconcepten voor flexknooppunten.
  • Gebruik een linux-compatibele Bash-omgeving met de vereiste hulpprogramma's en netwerktoegang. Deze implementatieserie noemt die omgeving uw Bash-omgeving. De afzonderlijke computer waarmee het cluster wordt samengevoegd, is de flexknooppunthost.
  • Installeer de Azure CLI. Voer az --version uit om te kijken welke versie is geïnstalleerd. Ga naar Azure CLI installeren om te installeren of upgraden.
  • Meld u aan bij Azure met een account dat het doelabonnement en de configuratie van het virtuele netwerk kan lezen.
  • Bereid een bestaand virtueel Azure-netwerk en subnet voor de door Azure beheerde AKS-knooppunten voor. Het virtuele netwerk kan zich in een andere resourcegroep bevinden dan het AKS-cluster. Als dat het is, moet u ervoor zorgen dat de AKS-clusteridentiteit over de vereiste machtigingen voor het subnet beschikt.

De implementatiebeslissingen nemen

Plan de volgende beslissingen voordat u resources maakt of configureert.

Besluit Opties Wat de beslissing bepaalt
Hostidentiteit Beheerde identiteit, Azure Arc beheerde identiteit of service-principal Hoe de flexknooppuntagent wordt geverifieerd bij Azure
Toegang tot AKS-API Openbaar of privé AKS-cluster Hoe uw Bash-omgeving en flexknooppunthosts de Kubernetes-API-server oplossen en bereiken
Flexknooppuntconnectiviteit Layer 3-connectiviteit of een Unbounded-Net WireGuard-gateway Hoe AKS-beheerde knooppunten, flexknooppunten, pods en Kubernetes-services communiceren

Deze beslissingen hebben betrekking op verschillende onderdelen van de implementatie. Als u bijvoorbeeld een openbaar AKS-API-eindpunt selecteert, wordt er geen netwerkverbinding gemaakt tussen door AKS beheerde knooppunten en flexknooppunthosts.

De hostidentiteit kiezen

Gebruik de beslissingstabel in identiteits- en toegangsconcepten voor flexknooppunten om de Azure identiteit te kiezen die de flexknooppuntagent gebruikt.

De host-id autoriseert Azure bewerkingen. De netwerkverbinding of kubernetes bootstrapconfiguratie die de host nodig heeft om lid te worden van het cluster, wordt niet vervangen. Sla geen inloggegevens op in het gedeelde omgevingsbestand.

Openbare of persoonlijke AKS-API-toegang kiezen

De Kubernetes-API-server is het beheereindpunt voor het cluster. Uw Bash-omgeving en elke flexknooppunthost moeten dit eindpunt kunnen oplossen en er verbinding mee kunnen maken.

  • Openbare AKS-API-toegang maakt gebruik van een beveiligd openbaar eindpunt. Kubernetes-verificatie en -autorisatie beheren nog steeds de toegang tot het cluster. Een openbaar API-eindpunt maakt de toepassingen die worden uitgevoerd in het cluster niet beschikbaar.
  • Privé-AKS-API-toegang maakt gebruik van een privé-eindpunt in het virtuele AKS-netwerk. Voer Azure CLI- kubectlen clusterinstallatieopdrachten uit in uw Bash-omgeving, die moet worden uitgevoerd op een computer die is verbonden met dat privénetwerk. Het flexknooppuntnetwerk moet ook de privé-DNS-naam van het cluster kunnen oplossen en verkeer naar het privé-eindpunt kunnen routeren.

Flexknooppuntimplementaties ondersteunen zowel openbare als persoonlijke toegang tot de API-server. Voor het privépad zijn aanvullende DNS-, routerings- en opdrachtuitvoeringsconfiguratie vereist, die wordt uitgelicht waar het van toepassing is. Voor algemene AKS-richtlijnen raadpleegt u Netwerkbeheervlak plannen voor AKS, een privé-AKS-cluster maken en verbinding maken met een privé-AKS-cluster.

De connectiviteit van flexknooppunten kiezen

Deze implementatiereeks maakt het AKS-cluster zonder een ingebouwde netwerkinvoegtoepassing en installeert Unbounded-Net op zowel de door AKS beheerde knooppunten als flexknooppunten. Unbounded-Net podadresbereiken toewijst en routering configureert tussen de AKS- en flexknooppuntomgevingen. In dit artikel wordt die werkstroom beschreven. Voor andere CNI- of netwerkconfiguraties is mogelijk andere routering, firewall, DNS, gateway, beveiliging en levenscyclusconfiguratie vereist. Zie netwerkconcepten voor Flex-knooppunten voor een uitleg van het netwerkmodel in openbare preview.

U geeft de onderliggende netwerkverbinding tussen de AKS- en flexknooppuntomgevingen op. Connectiviteit op laag 3 betekent dat beide knooppuntnetwerken IP-pakketten al in beide richtingen naar elkaars knooppuntadressen kunnen routeren. Kies de methode die past bij uw bestaande netwerk:

Verbindingsmethode Wanneer gebruikt u het?
Peering op virtueel netwerk De AKS-cluster- en flexknooppunthosts bevinden zich in Azure virtuele netwerken, waaronder virtuele netwerken in verschillende regio's.
VPN-toegangspoort De flexknooppunthosts bevinden zich in een on-premises omgeving of een ander netwerk dat verbinding maakt met Azure via een versleuteld site-naar-site-VPN.
ExpressRoute Uw organisatie maakt gebruik van een toegewezen privéverbinding tussen het netwerk en Azure.
Unbounded-Net WireGuard-gateway De AKS- en flexknooppuntnetwerken hebben geen privéverbinding. U configureert en gebruikt de WireGuard-tunnels op een AKS-gatewayknooppuntgroep en deze gatewayknooppunten moeten openbaar toegankelijk zijn. Houd rekening met gatewaycapaciteit en beschikbaarheid, omdat podverkeer tussen omgevingen afhankelijk is van deze pool. Bekijk het openbare AKS-cluster met Unbounded-Net WireGuard-lab.

In de stapsgewijze handleiding van Microsoft Learn wordt gebruikgemaakt van connectiviteit op laag 3 met Unbounded-Net.

AKS-API Flexknooppuntconnectiviteit Richtlijnen
Public Verbinding op netwerkniveau (laag 3) Aanbevolen configuratie
Privé Verbinding op netwerkniveau (laag 3) Vereist aanvullende DNS-, routerings- en opdrachtuitvoeringsconfiguratie
Public Openbare WireGuard-gateway Alternatieve topologie; de AKSFlexNode-labs bekijken
Privé Openbare WireGuard-gateway Niet gedekt door deze documentatie

Opmerking

Zie de AKSFlexNode-labs voor aanvullende topologievoorbeelden, waaronder voorbeelden die gebruikmaken van een openbare AKS-API-server met een WireGuard-gateway en een persoonlijke AKS API-server met door de klant beheerde netwerken. Deze labs vormen een aanvulling op de configuratie die in dit artikel wordt beschreven. Deze labs kunnen verschillende netwerkonderdelen gebruiken en verschillende operationele of ondersteuningsverantwoordelijkheden hebben. Voordat u een lab gebruikt, bekijkt u de vereisten, beperkingen, toepasselijke onderdeelversies en verantwoordelijkheden van de klant. Een GitHub lab breidt het ondersteuningsbereik dat wordt beschreven in Microsoft Learn niet uit.

Als u feedback wilt geven over een topologie die niet wordt weergegeven, opent u een probleem in de AKSFlexNode-opslagplaats. Neem de locatie van de flexknooppunthost, het AKS API-toegangsmodel, de voorgestelde connectiviteitsmethode, voorgestelde CNI en de netwerkpaden op die vereist zijn voor het scenario.

De vereiste netwerkverbinding plannen

Neem contact op met de netwerkbeheerder om ervoor te zorgen dat het netwerkontwerp de volgende connectiviteit biedt:

Requirement Waarom dit vereist is
Uw Bash-omgeving kan de AKS-API-server oplossen en bereiken. U hebt deze verbinding nodig om het cluster te configureren en te beheren.
Elke flexknooppunthost kan de AKS-API-server oplossen en bereiken. De flexknooppuntagent en kubelet gebruiken deze verbinding om het cluster te koppelen en te communiceren met het Kubernetes-besturingsvlak.
Door AKS beheerde knooppunten en flexknooppunthosts kunnen elkaars privé-IP-adressen bereiken. Voor de meeste connectiviteitsmethoden gebruikt Unbounded-Net de knooppuntnetwerken als het onderliggende pad tussen de twee omgevingen.
Verkeer van pods en Kubernetes-services kan worden gerouteerd tussen door AKS beheerde knooppunten en flexknooppunten. Workloads hebben communicatie tussen knooppunten, cluster-DNS en Kubernetes-servicetoegang nodig.
Het AKS-besturingsvlak kan verbinding maken met de kubelet op een flexknooppunt. AKS gebruikt dit pad voor kubelet-bewerkingen, waaronder kubectl logs, kubectl execen kubectl port-forward.

U configureert en beheert het externe hostnetwerk, waaronder routering, peering van virtuele netwerken, VPN- of ExpressRoute-verbindingen, regels voor firewall- en netwerkbeveiligingsgroepen, DNS, proxy-instellingen en de Unbounded-Net configuratie die in deze reeks wordt beschreven. Zie ondersteuningsbeleid voor flexknooppunten voor het volledige verantwoordelijkheidsmodel.

Toegang tot hostbeheer beperken tot goedgekeurde bronadressen. Voor een Azure-VM koppelt u een netwerkbeveiligingsgroep aan het hostsubnet of de netwerkinterface. Voor een host buiten Azure past u gelijkwaardige firewallbesturingselementen toe. Als u az vm create gebruikt om een Flex-nodehost te maken, controleer dan eventuele regels voor openbare IP-adressen en netwerkbeveiligingsgroepen die door de opdracht worden gemaakt. Tenzij u de SSH-regel beperkt, kunnen verbindingen met TCP-poort 22 vanuit elke openbare bron worden toegestaan.

De implementatiewaarden verzamelen

In de resterende artikelen worden de volgende waarden opnieuw gebruikt.

Algemene Azure-resourcewaarden

Variable Description Wanneer deze wordt gebruikt
SUBSCRIPTION_ID Abonnement met het AKS-cluster en gerelateerde Azure resources. Elke implementatie
RESOURCE_GROUP Resourcegroep die het AKS-cluster bevat. Elke implementatie
CLUSTER_NAME Naam van het AKS-cluster. Elke implementatie
FLEX_POOL_NAME Naam van de flexknooppuntgroep. Gebruik alleen letters en cijfers. Elke implementatie
AKS_API_ACCESS API-toegangsmodel voor het AKS-cluster. Stel de waarde in op public of private. Validatie van clustervoorbereiding en API-connectiviteit
AKS_RESOURCE_ID Azure resource-id van het AKS-cluster. Azure geeft deze waarde op nadat het cluster bestaat. Latere artikelen

Waarden voor AKS-cluster en virtueel netwerk

Variable Description Wanneer deze wordt gebruikt
LOCATION Azure regio voor het AKS-cluster. Controleer of deze regio voldoet aan de regionale beschikbaarheidsvereiste . Het AKS-cluster maken
AKS_VNET_NAME Naam van het virtuele netwerk dat het AKS-subnet bevat. Het AKS-subnet zoeken en valideren
AKS_VNET_RESOURCE_GROUP Resourcegroep die het virtuele AKS-netwerk bevat. Het kan verschillen van RESOURCE_GROUP. Het AKS-subnet zoeken en valideren
AKS_SUBNET_NAME Naam van het subnet dat door de Azure beheerde AKS-knooppunten wordt gebruikt. Het AKS-subnet zoeken en valideren
AKS_SUBNET_ID Azure resource-id van het AKS-subnet. Het AKS-cluster maken
AKS_NODE_VM_SIZE Azure VM-grootte voor de door Azure beheerde AKS-systeemknooppuntgroep. Deze waarde bepaalt niet de grootte van de host van het flexknooppunt. Het AKS-cluster maken
SERVICE_CIDR Adresbereik voor Kubernetes-services. Het AKS-clusternetwerkprofiel configureren
DNS_SERVICE_IP IP-adres voor de Kubernetes DNS-service. Het AKS-clusternetwerkprofiel configureren

Haal de resource-id en adresbereiken van het AKS-subnet op voordat u het omgevingsbestand maakt:

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- en Unbounded-Net-adreswaarden

U gebruikt SERVICE_CIDR en DNS_SERVICE_IP om het netwerkprofiel van het AKS-cluster te configureren. Configureer de CIDR's voor nodes en pods om de Unbounded-Net Sites in te stellen die in deze handleiding worden gebruikt.

Het AKS-knooppunt, de AKS-pod, het flexknooppunt, de flexpod en de Kubernetes-servicebereiken moeten voldoen aan het geselecteerde netwerkontwerp en mogen elkaar niet overlappen of een netwerk dat bereikbaar is via peering van virtuele netwerken, VPN of ExpressRoute. De uiteindelijke waarden coördineren met uw netwerkbeheerder.

Kopieer geen voorbeeld-CIDR's uit een andere implementatie. CIDR's identificeren routeerbare adresruimte, dus als u een voorbeeld gebruikt dat uw Azure of verbonden netwerken overlapt, kan verkeer ambigu zijn of voorkomen dat knooppunten en pods elkaar bereiken.

Variable Description Wordt gebruikt door
AKS_SUBNET_CIDR Adresbereik dat is toegewezen aan het subnet voor door Azure beheerde AKS-knooppunten. validatie van Azure virtueel netwerk en AKS-subnet
AKS_NODE_CIDR Het bereik van het Unbounded-Net Site-knooppunt dat het subnet van het AKS-knooppunt bevat. Unbounded-Net primaire clustersite
AKS_POD_CIDR Adresgroep voor pods op Azure beheerde AKS-knooppunten. Unbounded-Net primaire clustersite
FLEX_HOST_SUBNET_CIDR Adresbereik dat de flexknooppunthosts bevat. Validatie van flexknooppunthostnetwerk
FLEX_NODE_CIDR Unbounded-Net siteknooppuntbereik dat het subnet van de flexknooppunthost bevat. Unbounded-Net site voor flexknooppunten
FLEX_POD_CIDR Adresgroep voor pods op flexknooppunten. Unbounded-Net site voor flexknooppunten
SERVICE_CIDR Adresbereik voor Kubernetes-services. AKS-clusternetwerkprofiel
DNS_SERVICE_IP IP-adres voor de Kubernetes DNS-service. AKS-clusternetwerkprofiel

Pas de volgende regels toe op het adresplan:

  • AKS_SUBNET_CIDR moet zijn opgenomen in AKS_NODE_CIDR.
  • FLEX_HOST_SUBNET_CIDR moet zijn opgenomen in FLEX_NODE_CIDR.
  • DNS_SERVICE_IP moet binnen SERVICE_CIDRzijn.

Deze acht waarden zijn geen acht afzonderlijke intervallen. Vijf zijn onafhankelijke bereiken die niet mogen overlappen, twee zijn subnetbereiken binnen het bereik van de bijbehorende Site-knoop en één is een afzonderlijk IP-adres binnen het servicebereik.

De volgende waarden voldoen aan elke regel in deze sectie. Behandel ze als illustratie van de relaties, niet als standaardwaarden. Bevestig uw eigen waarden voor uw Azure en verbonden netwerkadresruimte voordat u deze gebruikt.

Variable Example Relationship
AKS_NODE_CIDR 10.10.0.0/16 Onafhankelijk bereik
AKS_SUBNET_CIDR 10.10.1.0/24 Ingesloten in AKS_NODE_CIDR
AKS_POD_CIDR 10.244.0.0/16 Onafhankelijk bereik
FLEX_NODE_CIDR 10.20.0.0/16 Onafhankelijk bereik
FLEX_HOST_SUBNET_CIDR 10.20.1.0/24 Ingesloten in FLEX_NODE_CIDR
FLEX_POD_CIDR 10.245.0.0/16 Onafhankelijk bereik
SERVICE_CIDR 10.96.0.0/16 Onafhankelijk bereik
DNS_SERVICE_IP 10.96.0.10 Binnen SERVICE_CIDR

Bekijk de huidige adresruimten van het virtuele netwerk Azure:

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

Azure kan conflicten identificeren binnen de resources die het beheert, maar het kan geen adresbereiken valideren in elk verbonden on-premises-netwerk of extern netwerk.

Versiewaarden van onderdelen

Flexknooppunten vereisen compatibele versies van AKS, de Azure CLI-extensie, Unbounded-Net en de flexknooppuntagent. Gebruik de versies die in dit artikel worden vermeld en selecteer of upgrade deze onderdelen niet zelfstandig.

Variable Description
AKS_VERSION Ondersteunde Kubernetes-versie voor het AKS-cluster.
AKS_PREVIEW_VERSION aks-previewAzure CLI extensieversie 22.0.0b8 of hoger.
UNBOUNDED_VERSION Ondersteunde Unbounded-Net versie.
AKS_FLEX_NODE_VERSION Ondersteunde versie van flexknooppuntagent.

Regionale beschikbaarheid

Flexknooppunten vereisen AKS-release v20260904 of hoger in de regio die als host fungeert voor uw cluster. AKS past deze op datum gebaseerde releases automatisch toe en ze staan los van de Kubernetes-versie die u hebt AKS_VERSIONingesteld.

Voordat u een cluster maakt of selecteert, opent u het tabblad AKS Release van de AKS-releasetracker, zoekt u uw regio en controleert u de versie onder Momenteel in werking. AKS-releaseversies maken gebruik van de vYYYYMMDD indeling. Als in uw regio een eerdere versie wordt weergegeven, wacht u totdat de release de regio bereikt of selecteert u, als uw implementatievereisten zijn toegestaan, een regio waar de vereiste versie beschikbaar is.

Lokale werkruimtewaarde

Variable Description
WORK_DIR Map in uw Bash-omgeving waarin de overige artikelen downloads, gegenereerde bestanden en het kubeconfig-bestand van het cluster opslaan. De standaardwaarde is ~/.local/share/aksflexnode/<deployment-name>. Als u deze bestanden ergens anders wilt bewaren, zoals een tijdelijke map die u na de implementatie verwijdert, wijzigt u de WORK_DIR waarde in het omgevingsbestand.

Het gedeelde omgevingsbestand maken

Maak één omgevingsbestand voor elke implementatie. Het bestand houdt de niet-geheime waarden consistent in de overige artikelen en terminalsessies.

Sla geen toegangstokens op, bootstrapgegevens, kubeconfig-inhoud, referenties van de service-principal, certificaten, persoonlijke sleutels van certificaten of persoonlijke SSH-sleutels in dit bestand.

  1. Kies een kort implementatielabel en maak een beveiligde map voor het omgevingsbestand.

    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. Maak het omgevingsbestand.

    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

    Met de set_flexnode_env helper kunnen latere artikelen Azure gegenereerde waarden vastleggen zonder dubbele definities aan het bestand toe te voegen.

  3. Open ${FLEXNODE_ENV_FILE} in een editor en vervang elke waarde tussen punthaken. Laat de waarden onder Waarden die door latere artikelen zijn vastgelegd , leeg.

  4. Controleer of er geen tijdelijke aanduidingen blijven.

    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. Laad het omgevingsbestand, maak de werkmap en stel het actieve Azure-abonnement in.

    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

    Bevestig dat de geretourneerde abonnements-id overeenkomt met SUBSCRIPTION_ID.

    Bevestig dat AKS_API_ACCESS een ondersteund pad identificeert:

    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

    Start elke nieuwe terminalsessie door het implementatielabel in te stellen en het omgevingsbestand ervan te laden:

    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.}"

De planningswaarden valideren

Controleer het geselecteerde AKS-subnet.

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

Bevestig dat de geretourneerde resource-id en het adresbereik overeenkomen AKS_SUBNET_ID en AKS_SUBNET_CIDR.

Volgende stap

Maak vervolgens een AKS-cluster gereed voor flex-knooppunten. In het volgende artikel wordt het openbare of persoonlijke AKS-cluster gemaakt en wordt de clusterresource-id vastgelegd.

  • Laatst bijgewerkt om