Pianificare i nodi Flex per AKS (anteprima)

Importante

Le funzionalità in anteprima di AKS sono disponibili in modalità self-service, su base volontaria. Le anteprime vengono fornite "così come sono" e "come disponibili" e sono escluse dai contratti di servizio e dalla garanzia limitata. Le anteprime di AKS sono coperte solo parzialmente dall'assistenza clienti nei limiti del possibile. Di conseguenza, queste funzionalità non sono destinate all'uso in produzione. Per altre informazioni, vedere gli articoli di supporto seguenti:

• Criteri di supporto di AKS
• Domande frequenti sul supporto tecnico di Azure

I nodi Flex estendono un cluster Servizio Azure Kubernetes (AKS) ai computer Linux gestiti all'esterno dei pool di nodi gestiti dal cluster Azure. Prima di aggiungere un nodo flessibile, scegli come l'host si autentica con Azure, come raggiunge il server API di Kubernetes e come il traffico di rete passa tra gli ambienti AKS e del nodo flessibile.

Questo articolo illustra come prendere queste decisioni, pianificare intervalli di indirizzi non sovrapposti e creare un file di ambiente condiviso per gli articoli di distribuzione rimanenti.

Prima di iniziare

• Esamina la panoramica dei nodi flex per AKS.
• Esaminare i concetti relativi all'identità e all'accesso per i nodi flex.
• Esaminare i concetti di rete per i nodi flex.
• Usare un ambiente Bash compatibile con Linux con gli strumenti e l'accesso alla rete necessari. Questa serie di distribuzione si riferisce a quell'ambiente come al tuo ambiente Bash. La macchina separata che si unisce al cluster è l'host del flex node.
• Installare il interfaccia della riga di comando di Azure. Eseguire az --version per trovare la versione installata. Per installare o aggiornare, vedere Installare il interfaccia della riga di comando di Azure.
• Accedere a Azure con un account in grado di leggere la sottoscrizione di destinazione e la configurazione della rete virtuale.
• Preparare una rete virtuale di Azure e una subnet esistenti per i nodi AKS gestiti da Azure. La rete virtuale può trovarsi in un gruppo di risorse diverso da quello del cluster AKS. In tal caso, assicurarsi che l'identità del cluster AKS disponga delle autorizzazioni necessarie sulla subnet.

Prendere le decisioni di distribuzione

Pianificare le decisioni seguenti prima di creare o configurare le risorse.

Decisione	Opzioni	Cosa controlla la decisione
Identità dell'host	Identità gestita, identità gestita di Azure Arc o entità servizio	Come l'agente del nodo flex esegue l'autenticazione per Azure
Accesso all'API di AKS	Cluster AKS pubblico o privato	Come l'ambiente Bash e gli host dei nodi flex risolvono e raggiungono il server API Kubernetes
Connettività del nodo Flex	Connettività di livello 3 o un gateway Unbounded-Net WireGuard	Come comunicano i nodi gestiti da AKS, i nodi flessibili, i pod e i servizi Kubernetes

Queste decisioni riguardano parti diverse della distribuzione. Ad esempio, la selezione di un endpoint API del servizio Azure Kubernetes pubblico non crea la connettività di rete tra i nodi gestiti dal servizio Azure Kubernetes e gli host dei nodi flessibili.

Scegliere l'identità host

Usare la tabella decisionale in concetti relativi all'identità e all'accesso per i nodi flex per scegliere l'identità Azure usata dall'agente del nodo flex.

L'identità host autorizza le operazioni di Azure. Non sostituisce la connettività di rete o la configurazione bootstrap di Kubernetes che l'host deve aggiungere al cluster. Non archiviare le credenziali nel file dell'ambiente condiviso.

Scegli l'accesso pubblico o privato all'API di AKS

Il server API Kubernetes è l'endpoint di gestione per il cluster. L'ambiente Bash e ogni host del nodo flex devono essere in grado di risolvere e connettersi a questo endpoint.

• L'accesso all'API del servizio Azure Kubernetes pubblico usa un endpoint pubblico protetto. L'autenticazione e l'autorizzazione di Kubernetes controllano comunque l'accesso al cluster. Un endpoint API pubblico non espone le applicazioni in esecuzione nel cluster.
• L'accesso all'API del servizio Azure Kubernetes privato usa un endpoint privato nella rete virtuale del servizio Azure Kubernetes. Esegui l'interfaccia della riga di comando di Azure, kubectl, e i comandi di configurazione del cluster nel tuo ambiente Bash, che deve trovarsi su un computer connesso a tale rete privata. La rete flex node deve anche essere in grado di risolvere il nome DNS privato del cluster e instradare il traffico all'endpoint privato.

Le distribuzioni di nodi Flex supportano sia l'accesso pubblico che privato al server API. Il percorso privato richiede una configurazione AGGIUNTIVA di DNS, routing e esecuzione dei comandi, evidenziata dove si applica. Per indicazioni generali sul servizio Azure Kubernetes, vedere Pianificare la rete del piano di controllo per il servizio Azure Kubernetes, Creare un cluster del servizio Azure Kubernetes privato e Connettersi a un cluster del servizio Azure Kubernetes privato.

Scegliere la connettività del nodo flex

Questa serie di distribuzione crea il cluster del servizio Azure Kubernetes senza un plug-in di rete predefinito e installa Unbounded-Net nei nodi gestiti dal servizio Azure Kubernetes e nei nodi flex. Unbounded-Net assegna gli intervalli di indirizzi per i pod e configura il routing tra gli ambienti AKS e dei nodi flessibili. Questo articolo descrive il flusso di lavoro. Altre configurazioni CNI o di rete potrebbero richiedere routing, firewall, DNS, gateway, sicurezza e configurazione del ciclo di vita diversi. Per una spiegazione del modello di rete in anteprima pubblica, vedere Concetti di rete per i nodi flessibili.

Fornisci la connessione di rete sottostante tra gli ambienti AKS e dei nodi flessibili. La connettività di livello 3 significa che entrambe le reti del nodo possono già instradare i pacchetti IP agli indirizzi dei nodi, in entrambe le direzioni. Scegliere il metodo adatto alla rete esistente:

Metodo di connettività	Quando usarlo
Peering di reti virtuali	Il cluster AKS e gli host di nodi flessibili si trovano nelle reti virtuali di Azure, incluse le reti virtuali in aree geografiche diverse.
Gateway VPN	Gli host del nodo flex si trovano in un ambiente locale o in un'altra rete che si connette a Azure tramite una VPN da sito a sito crittografata.
ExpressRoute	L'organizzazione usa una connessione privata dedicata tra la rete e Azure.
Gateway WireGuard della rete non associata	Le reti di AKS e dei nodi flessibili non dispongono di una connessione privata instradata. Si configurano e gestiscono i tunnel WireGuard in un pool di nodi gateway di AKS e tali nodi gateway devono essere accessibili pubblicamente. Pianificare la capacità e la disponibilità del gateway, perché il traffico dei pod tra diversi ambienti dipende da questo pool. Vedi il cluster AKS pubblico con il lab Unbounded-Net WireGuard.

La procedura dettagliata di Microsoft Learn usa la connettività di livello 3 con Unbounded-Net.

API del servizio Azure Kubernetes	Connettività del nodo Flex	Guida
Public	Connettività di livello 3	Configurazione consigliata
Privato	Connettività di livello 3	Richiede un DNS, un routing e una configurazione di esecuzione dei comandi aggiuntivi
Public	Gateway pubblico WireGuard	Topologia alternativa; vedi i lab AKSFlexNode
Privato	Gateway pubblico WireGuard	Non coperto da questa documentazione

Note

Per altri esempi di topologia, vedere i lab AKSFlexNode, inclusi esempi che usano un server API del servizio Azure Kubernetes pubblico con un gateway WireGuard e un server API del servizio Azure Kubernetes privato con rete gestita dal cliente. Questi lab integrano la configurazione documentata in questo articolo. Questi lab possono usare componenti di rete diversi e avere responsabilità operative o di supporto diverse. Prima di usare un lab, esaminare i prerequisiti, le limitazioni, le versioni dei componenti applicabili e le responsabilità dei clienti. Un lab GitHub non espande l'ambito di supporto documentato in Microsoft Learn.

Per fornire commenti e suggerimenti su una topologia non rappresentata, aprire un problema nel repository AKSFlexNode. Includete la posizione host del nodo Flex, il modello di accesso all'API di AKS, il metodo di connettività proposto, la CNI proposta e i percorsi di rete richiesti dallo scenario.

Pianificare la connettività di rete necessaria

Collaborare con l'amministratore di rete per garantire che la progettazione della rete fornisca la connettività seguente:

Requisito	Perché è necessario
L'ambiente Bash può risolvere e raggiungere il server API del servizio Azure Kubernetes.	Questa connessione è necessaria per configurare e gestire il cluster.
Ogni host di nodo flex può risolvere e raggiungere il server API di AKS.	L'agente del nodo Flex e il kubelet usano questa connessione per unirsi al cluster e comunicare con il piano di controllo di Kubernetes.
I nodi gestiti da AKS e gli host dei nodi flessibili possono raggiungere i rispettivi indirizzi IP privati.	Per la maggior parte dei metodi di connettività, Unbounded-Net usa le reti nodo come percorso sottostante tra i due ambienti.
Il traffico dei pod e dei servizi Kubernetes può essere instradato tra i nodi gestiti da AKS e i nodi flessibili.	I carichi di lavoro necessitano di comunicazione tra nodi, DNS del cluster e accesso al servizio Kubernetes.
Il piano di controllo di AKS può connettersi al kubelet su un nodo flex.	AKS usa questo percorso per le operazioni kubelet, tra cui kubectl logs, kubectl exec e kubectl port-forward.

Configurare e gestire la rete host esterna, tra cui routing, peering di rete virtuale, connessioni VPN o ExpressRoute, regole del firewall e del gruppo di sicurezza di rete, DNS, impostazioni proxy e la configurazione Unbounded-Net documentata in questa serie. Per il modello di responsabilità completa, vedere Criteri di supporto per i nodi flex.

Limitare l'accesso alla gestione host agli indirizzi di origine approvati. Per una macchina virtuale Azure, associare un gruppo di sicurezza di rete alla subnet host o all'interfaccia di rete. Per un host esterno Azure, applicare controlli firewall equivalenti. Se si usa az vm create per creare un host del nodo flex, esaminare eventuali regole relative a indirizzi IP pubblici e gruppi di sicurezza di rete creati dal comando. A meno che non si limiti la regola SSH, può consentire le connessioni alla porta TCP 22 da qualsiasi origine pubblica.

Raccogliere i valori di distribuzione

Gli articoli rimanenti riutilizzano i valori seguenti.

Valori comuni delle risorse Azure

Variable	Description	Quando viene utilizzato
SUBSCRIPTION_ID	Sottoscrizione che contiene il cluster AKS e le risorse di Azure correlate.	Per ogni distribuzione
RESOURCE_GROUP	Gruppo di risorse che contiene il cluster AKS.	Per ogni distribuzione
CLUSTER_NAME	Nome del cluster AKS.	Per ogni distribuzione
FLEX_POOL_NAME	Nome del pool di nodi Flex. Usare solo lettere e cifre.	Per ogni distribuzione
AKS_API_ACCESS	Modello di accesso API per il cluster AKS. Impostare il valore su public o private.	Preparazione del cluster e convalida della connettività API
AKS_RESOURCE_ID	ID risorsa di Azure del cluster AKS. Azure fornisce questo valore dopo l'esistenza del cluster.	Articoli successivi

Valori del cluster AKS e della rete virtuale

Variable	Description	Quando viene utilizzato
LOCATION	Area di Azure per il cluster AKS. Verificare che questa area soddisfi il requisito di disponibilità a livello di area .	Creazione del cluster AKS
AKS_VNET_NAME	Nome della rete virtuale che contiene la subnet di AKS.	Individuazione e convalida della subnet di AKS
AKS_VNET_RESOURCE_GROUP	Gruppo di risorse che contiene la rete virtuale di AKS. Può differire da RESOURCE_GROUP.	Individuazione e convalida della subnet di AKS
AKS_SUBNET_NAME	Nome della subnet usata dai nodi del servizio Azure Kubernetes gestiti da Azure.	Individuazione e convalida della subnet di AKS
AKS_SUBNET_ID	ID della risorsa Azure della subnet di AKS.	Creazione del cluster AKS
AKS_NODE_VM_SIZE	Dimensione della macchina virtuale di Azure per il pool di nodi di sistema di AKS gestito da Azure. Questo valore non determina le dimensioni dell'host del nodo flex.	Creazione del cluster AKS
SERVICE_CIDR	Intervallo di indirizzi per i servizi Kubernetes.	Configurazione del profilo di rete del cluster AKS
DNS_SERVICE_IP	Indirizzo IP per il servizio DNS Kubernetes.	Configurazione del profilo di rete del cluster AKS

Recuperate l'ID della risorsa della subnet di AKS e gli intervalli di indirizzi prima di creare il file dell'ambiente:

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 e valori di indirizzo di Unbounded-Net

Si usano SERVICE_CIDR e DNS_SERVICE_IP per configurare il profilo di rete del cluster AKS. Configurare i CIDR del nodo e del pod per impostare i siti Unbounded-Net usati da questa guida.

Il nodo AKS, il pod AKS, il nodo flex, il pod flex e gli intervalli di servizio Kubernetes devono seguire la progettazione di rete scelta e non devono sovrapporsi tra loro né a qualsiasi rete raggiungibile tramite peering di rete virtuale, VPN o ExpressRoute. Coordinare i valori finali con l'amministratore di rete.

Non copiare i CIDR di esempio da un'altra implementazione. I CIDR identificano lo spazio di indirizzamento instradabile, quindi riutilizzare un esempio che si sovrappone alle reti di Azure o alle reti connesse può rendere ambiguo il traffico o impedire ai nodi e ai pod di comunicare tra loro.

Variable	Description	Usato da
AKS_SUBNET_CIDR	Intervallo di indirizzi assegnato alla subnet per i nodi del servizio Azure Kubernetes gestiti da Azure.	Convalida della rete virtuale di Azure e della subnet di AKS
AKS_NODE_CIDR	Intervallo di nodi del sito della rete non associata che contiene la subnet del nodo del servizio Azure Kubernetes.	sito del cluster primario di Unbounded-Net
AKS_POD_CIDR	Pool di indirizzi per i pod nei nodi AKS gestiti da Azure.	sito del cluster primario di Unbounded-Net
FLEX_HOST_SUBNET_CIDR	Intervallo di indirizzi che contiene gli host del nodo flex.	Convalida della rete host del nodo Flex
FLEX_NODE_CIDR	Intervallo di nodi del sito della rete non associata che contiene la subnet host del nodo flessibile.	sito Unbounded-Net per i nodi flex
FLEX_POD_CIDR	Pool di indirizzi IP per i pod sui nodi flex.	sito Unbounded-Net per i nodi flex
SERVICE_CIDR	Intervallo di indirizzi per i servizi Kubernetes.	Profilo di rete del cluster AKS
DNS_SERVICE_IP	Indirizzo IP per il servizio DNS Kubernetes.	Profilo di rete del cluster AKS

Applicare le regole seguenti al piano di indirizzi:

• AKS_SUBNET_CIDR deve essere contenuto all'interno di AKS_NODE_CIDR.
• FLEX_HOST_SUBNET_CIDR deve essere contenuto all'interno di FLEX_NODE_CIDR.
• DNS_SERVICE_IP deve essere all'interno di SERVICE_CIDR.

Questi otto valori non sono otto intervalli separati. Cinque sono intervalli indipendenti che non devono sovrapporsi, due sono intervalli di subnet contenuti all'interno dell'intervallo di nodi del sito corrispondente e uno è un singolo indirizzo IP all'interno dell'intervallo di servizi.

I valori seguenti soddisfano ogni regola in questa sezione. Considerarli come un'illustrazione delle relazioni, non come impostazioni predefinite. Confermare i valori in uso confrontandoli con quelli di Azure e dello spazio di indirizzamento della rete connessa prima di usarli.

Variable	Example	Relationship
AKS_NODE_CIDR	10.10.0.0/16	Intervallo indipendente
AKS_SUBNET_CIDR	10.10.1.0/24	Contenuto in AKS_NODE_CIDR
AKS_POD_CIDR	10.244.0.0/16	Intervallo indipendente
FLEX_NODE_CIDR	10.20.0.0/16	Intervallo indipendente
FLEX_HOST_SUBNET_CIDR	10.20.1.0/24	Contenuto in FLEX_NODE_CIDR
FLEX_POD_CIDR	10.245.0.0/16	Intervallo indipendente
SERVICE_CIDR	10.96.0.0/16	Intervallo indipendente
DNS_SERVICE_IP	10.96.0.10	All'interno SERVICE_CIDR

Esamina gli spazi di indirizzamento attuali della rete virtuale di Azure:

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

Azure può identificare i conflitti all'interno delle risorse gestite, ma non può convalidare gli intervalli di indirizzi in ogni rete locale o esterna connessa.

Valori della versione del componente

I nodi flex richiedono versioni compatibili del servizio Azure Kubernetes, l'estensione interfaccia della riga di comando di Azure, Unbounded-Net e l'agente del nodo flex. Usare le versioni elencate in questo articolo e non selezionare o aggiornare questi componenti in modo indipendente.

Variable	Description
AKS_VERSION	Versione di Kubernetes supportata per il cluster AKS.
AKS_PREVIEW_VERSION	aks-preview versione dell'estensione di interfaccia della riga di comando di Azure 22.0.0b8 o successiva.
UNBOUNDED_VERSION	Versione Unbounded-Net supportata.
AKS_FLEX_NODE_VERSION	Versione dell'agente flex node supportata.

Disponibilità a livello regionale

I nodi flessibili richiedono il servizio Azure Kubernetes versione v20260904 o successiva nell'area che ospita il cluster. AKS applica automaticamente questi rilasci basati sulla data, che sono separati dalla versione di Kubernetes che imposti in AKS_VERSION.

Prima di creare o selezionare un cluster, aprire la scheda Versione del servizio Azure Kubernetes del tracker delle versioni del servizio Azure Kubernetes, trovare l'area e controllare la versione in Attualmente in Operazione. Le versioni di rilascio di AKS usano il formato vYYYYMMDD. Se l'area mostra una versione precedente, attendere che il rilascio raggiunga l'area o, se i requisiti di distribuzione consentono, selezionare un'area in cui è disponibile la versione richiesta.

Valore dell'area di lavoro locale

Variable	Description
WORK_DIR	Directory nell'ambiente Bash in cui gli articoli rimanenti archiviano i download, i file generati e il file kubeconfig del cluster. Il valore predefinito è ~/.local/share/aksflexnode/<deployment-name>. Per mantenere questi file in un'altra posizione, ad esempio una directory temporanea che viene rimossa dopo la distribuzione, modificare il WORK_DIR valore nel file di ambiente.

Creare il file di ambiente condiviso

Creare un file di ambiente per ogni distribuzione. Il file mantiene coerenti i valori non segreti tra i restanti articoli e le sessioni di terminale.

Non archiviare token di accesso, dati di bootstrap, contenuto di kubeconfig, credenziali del service principal, certificati, chiavi private dei certificati o chiavi private SSH in questo file.

1. Scegliere un'etichetta di distribuzione breve e creare una directory protetta per il file di ambiente.

   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. Creare il file di ambiente.

   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
   

   L'helper set_flexnode_env consente agli articoli successivi di registrare i valori generati Azure senza aggiungere definizioni duplicate al file.

3. Aprire ${FLEXNODE_ENV_FILE} in un editor e sostituire ogni valore racchiuso tra parentesi angolari. Lasciare vuoti i valori sotto Valori registrati da articoli successivi.

4. Verificare che nessun segnaposto rimanga.

   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. Caricare il file di ambiente, creare la directory di lavoro e impostare la sottoscrizione attiva Azure.

   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
   

   Verificare che l'ID sottoscrizione restituito corrisponda a SUBSCRIPTION_ID.

   Verificare che AKS_API_ACCESS identifichi un percorso supportato:

   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
   

   Avviare ogni nuova sessione del terminale impostando l'etichetta di distribuzione e caricandone il file di ambiente:

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

Convalidare i valori di pianificazione

Verificare la subnet AKS selezionata.

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

Verificare che l'ID della risorsa restituita e l'intervallo di indirizzi corrispondano a AKS_SUBNET_ID e AKS_SUBNET_CIDR.

Passo successivo

Successivamente, preparare un cluster AKS per i nodi flessibili. Nell'articolo seguente viene creato il cluster AKS pubblico o privato e viene registrato l'ID della risorsa del cluster.