Planeia nós flexíveis para AKS (pré-visualização)

Importante

As funcionalidades de pré-visualização do AKS estão disponíveis num regime de autosserviço e de adesão voluntária. As visualizações prévias são fornecidas "como estão" e "conforme disponíveis" e são excluídas dos contratos de nível de serviço e da garantia limitada. As versões de pré-visualização do AKS são apenas parcialmente abrangidas pelo suporte ao cliente, na medida do possível. Assim sendo, estas funcionalidades não se destinam ao uso em produção. Para obter mais informações, consulte os seguintes artigos de suporte:

• Políticas de suporte do AKS
• Perguntas frequentes sobre o suporte do Azure

Os nós Flex expandem um cluster do Azure Kubernetes Service (AKS) para máquinas Linux geridas por si fora dos conjuntos de nós do cluster geridos pelo Azure. Antes de adicionar um nó flex, escolha como o host se autentica no Azure, como chega ao servidor API Kubernetes e como o tráfego de rede se move entre os ambientes AKS e flex node.

Este artigo ajuda-o a tomar estas decisões, planear intervalos de endereços não sobrepostos e criar um ficheiro de ambiente partilhado para os restantes artigos de implementação.

Antes de começares

• Consulte a visão geral dos nós flex para AKS.
• Revise os conceitos de identidade e acesso para nós flexíveis.
• Revise conceitos de rede para nós flexíveis.
• Use um ambiente Bash compatível com Linux que tenha as ferramentas necessárias e acesso à rede. Esta série de implementação refere-se a esse ambiente como o seu ambiente Bash. A máquina separada que se junta ao cluster é o anfitrião do nó flex.
• Instala a CLI do Azure. Execute az --version para localizar a versão instalada. Para instalar ou atualizar, consulte Instale o CLI do Azure.
• Inicie sessão no Azure com uma conta que possa ler a subscrição alvo e a configuração da rede virtual.
• Prepare uma rede virtual e sub-rede Azure existentes para os nós AKS geridos pelo Azure. A rede virtual pode estar num grupo de recursos diferente do cluster AKS. Quando estiver, certifique-se de que a identidade do cluster AKS tem as permissões necessárias na sub-rede.

Tome as decisões de implantação

Planeie as seguintes decisões antes de criar ou configurar recursos.

Decisão	Opções	O que a decisão controla
Identidade do hospedeiro	Identidade gerida, identidade gerida do Azure Arc ou principal de serviço	Como o agente flex node autentica no Azure
Acesso à API AKS	Cluster AKS público ou privado	Como o seu ambiente Bash e os anfitriões flex node resolvem e chegam ao servidor API Kubernetes
Conectividade de nós Flex	Conectividade de Camada 3 ou um gateway WireGuard da Unbounded-Net	Como os nós geridos pelo AKS, os nós Flex, os pods e os serviços Kubernetes comunicam entre si

Estas decisões abordam diferentes partes do destacamento. Por exemplo, a seleção de um endpoint público da API do AKS não cria conectividade de rede entre os nós geridos pelo AKS e os anfitriões de nós flexíveis.

Escolha a identidade do anfitrião

Utilize a tabela de decisão em conceitos de identidade e acesso para nós flex para escolher a identidade do Azure utilizada pelo agente do nó flex.

A identidade do host autoriza as operações do Azure. Não substitui a conectividade de rede nem a configuração de bootstrap do Kubernetes que o host precisa para se juntar ao cluster. Não guarde credenciais no ficheiro do ambiente partilhado.

Escolha acesso à API AKS pública ou privada

O servidor API Kubernetes é o endpoint de gestão do cluster. O seu ambiente Bash e cada host de nó flex devem ser capazes de resolver e estabelecer ligação a este endpoint.

• O acesso público à API AKS utiliza um endpoint público seguro. A autenticação e autorização Kubernetes continuam a controlar o acesso ao cluster. Um endpoint de API pública não expõe as aplicações a correr no cluster.
• O acesso privado à API AKS utiliza um endpoint privado na rede virtual AKS. Execute os comandos da CLI do Azure, kubectl e os comandos de configuração do cluster no seu ambiente Bash, que tem de ser executado numa máquina ligada a essa rede privada. A rede de nós flexíveis deve também ser capaz de resolver o nome DNS privado do cluster e encaminhar o tráfego para o endpoint privado.

As implementações de nós flexíveis suportam tanto o acesso público como privado ao servidor API. O caminho privado requer DNS adicional, roteamento e configuração de execução de comandos, assinalados onde aplicável. Para orientações gerais sobre AKS, consulte Planear a rede do plano de controlo para AKS, Criar um cluster AKS privado e Conectar-se a um cluster AKS privado.

Escolha a conectividade do nó flexível

Esta série de implementação cria o cluster AKS sem um plugin de rede incorporado e instala Unbounded-Net tanto nos nós geridos pelo AKS como nos nós flex. Unbounded-Net atribui intervalos de endereços pod e configura o encaminhamento entre os ambientes AKS e flex node. Este artigo descreve esse fluxo de trabalho. Outras configurações de CNI ou rede podem exigir roteamento, firewall, DNS, gateway, segurança e configuração do ciclo de vida diferentes. Para uma explicação do modelo de rede de pré-visualização pública, veja conceitos de rede para nós flexíveis.

Forneces a ligação de rede subjacente entre os ambientes AKS e flex node. A conectividade de Camada 3 significa que ambas as redes dos nós já podem encaminhar pacotes IP para os endereços dos nós uma da outra, em ambas as direções. Escolha o método que se adequa à sua rede atual:

Método de conectividade	Quando utilizá-lo
Emparelhamento de rede virtual	O cluster do AKS e os hosts de nós flexíveis estão em redes virtuais do Azure, incluindo redes virtuais em diferentes regiões.
Gateway de VPN	Os anfitriões flex node estão num ambiente on-premises ou noutra rede que se liga ao Azure através de uma VPN site-to-site encriptada.
ExpressRoute	A sua organização utiliza uma ligação privada dedicada entre a sua rede e o Azure.
Unbounded-Net gateway WireGuard	As redes do AKS e de nós flex não têm uma ligação privada com encaminhamento. Configuras e operas os túneis WireGuard num pool de nós de gateway AKS, e esses nós de gateway têm de ser acessíveis publicamente. Planeie a capacidade e a disponibilidade do gateway, porque o tráfego de pods entre ambientes depende deste conjunto. Veja o cluster AKS público com o laboratório Unbounded-Net WireGuard.

O guia passo a passo do Microsoft Learn utiliza conectividade de Camada 3 com Unbounded-Net.

AKS API	Conectividade de nós Flex	Documentação de orientação
Public	Conectividade de Camada 3	Configuração recomendada
Privado	Conectividade de Camada 3	Requer configuração adicional de DNS, de encaminhamento e de execução de comandos
Public	Gateway público do WireGuard	Topologia alternativa; ver os laboratórios AKSFlexNode
Privado	Gateway público do WireGuard	Não abrangido por esta documentação

Observação

Para exemplos adicionais de topologia, veja os laboratórios AKSFlexNode, incluindo exemplos que utilizam um servidor API AKS público com gateway WireGuard e um servidor API AKS privado com rede gerida pelo cliente. Estes laboratórios complementam a configuração documentada neste artigo. Estes laboratórios podem usar componentes de rede diferentes e ter responsabilidades operacionais ou de apoio distintas. Antes de usar um laboratório, reveja os seus pré-requisitos, limitações, versões de componentes aplicáveis e responsabilidades do cliente. Um laboratório no GitHub não expande o âmbito de suporte documentado no Microsoft Learn.

Para fornecer feedback sobre uma topologia que não está representada, abra um problema no repositório AKSFlexNode. Inclua a localização do anfitrião do nó flexível, o modelo de acesso à API do AKS, o método de conectividade proposto, o CNI proposto e os caminhos de rede exigidos pelo cenário.

Planeie a conectividade de rede necessária

Trabalhe com o seu administrador de rede para garantir que o design da rede fornece a seguinte conectividade:

Requisito	Por que é necessário
O seu ambiente Bash pode resolver e aceder ao servidor API do AKS.	Precisas desta ligação para configurar e gerir o cluster.
Cada anfitrião do nó flexível pode resolver e aceder ao servidor API do AKS.	O agente do nó flex e o kubelet usam esta ligação para se juntar ao cluster e comunicar com o plano de controlo do Kubernetes.
Os nós geridos pelo AKS e os anfitriões de nós flexíveis podem aceder aos respetivos endereços IP privados.	Para a maioria dos métodos de conectividade, Unbounded-Net utiliza as redes de nós como o caminho subjacente entre os dois ambientes.
O tráfego de serviço Pod e Kubernetes pode ser encaminhado entre nós geridos por AKS e nós flex.	As cargas de trabalho necessitam de comunicação entre nós, DNS de cluster e acesso ao serviço Kubernetes.
O plano de controlo do AKS pode estabelecer ligação ao kubelet num nó flex.	O AKS utiliza este caminho para operações de kubelet, incluindo kubectl logs, kubectl exec, e kubectl port-forward.

Configure e opere a rede de anfitrião externa, incluindo o roteamento, o peering de rede virtual, ligações VPN ou do ExpressRoute, regras de firewall e de grupos de segurança de rede, DNS, definições de proxy e a configuração Unbounded-Net documentada nesta série. Para o modelo completo de responsabilidade, veja política de suporte para nós flexíveis.

Restringa o acesso da gestão de hosts a endereços de origem aprovados. Para uma VM Azure, associe um grupo de segurança de rede à sub-rede do anfitrião ou interface de rede. Para um host fora do Azure, aplique controlos de firewall equivalentes. Se usares az vm create para criar um host de nó flexível, revê quaisquer endereços IP públicos e regras de grupo de segurança de rede que o comando crie. A menos que restreina a regra do SSH, pode permitir ligações à porta TCP 22 a partir de qualquer fonte pública.

Recolher os valores de implementação

Os artigos restantes reutilizam os seguintes valores.

Valores comuns de recursos do Azure

Variable	Description	Quando é usado
SUBSCRIPTION_ID	Subscrição que contém o cluster AKS e os recursos relacionados do Azure.	Cada implantação
RESOURCE_GROUP	Grupo de recursos que contém o cluster AKS.	Cada implantação
CLUSTER_NAME	Nome do cluster AKS.	Cada implantação
FLEX_POOL_NAME	Nome do pool de nós flexíveis. Use apenas letras e dígitos.	Cada implantação
AKS_API_ACCESS	Modelo de acesso à API para o cluster AKS. Defina o valor para public ou private.	Preparação de clusters e validação da conectividade da API
AKS_RESOURCE_ID	ID de recurso Azure do cluster AKS. O Azure fornece este valor depois de o cluster existir.	Artigos posteriores

Valores do cluster AKS e da rede virtual

Variable	Description	Quando é usado
LOCATION	Região Azure para o cluster AKS. Confirme que esta região cumpre o requisito regional de disponibilidade .	Criação do cluster AKS
AKS_VNET_NAME	Nome da rede virtual que contém a sub-rede AKS.	Encontrar e validar a sub-rede AKS
AKS_VNET_RESOURCE_GROUP	Grupo de recursos que contém a rede virtual AKS. Pode diferir de RESOURCE_GROUP.	Encontrar e validar a sub-rede AKS
AKS_SUBNET_NAME	Nome da sub-rede usada pelos nós AKS geridos pelo Azure.	Encontrar e validar a sub-rede AKS
AKS_SUBNET_ID	ID de recurso Azure da sub-rede AKS.	Criação do cluster AKS
AKS_NODE_VM_SIZE	Tamanho da VM do Azure para o pool de nós do sistema AKS gerido pelo Azure. Este valor não determina o tamanho do host do nó flex.	Criação do cluster AKS
SERVICE_CIDR	Intervalo de endereços dos serviços Kubernetes.	Configuração do perfil de rede do cluster AKS
DNS_SERVICE_IP	Endereço IP para o serviço DNS Kubernetes.	Configuração do perfil de rede do cluster AKS

Recupere o ID do recurso da sub-rede AKS e os intervalos de endereços antes de criar o ficheiro de 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 valores de endereços do Unbounded-Net

Utilizas SERVICE_CIDR e DNS_SERVICE_IP configuras o perfil de rede do cluster AKS. Configure os CIDR do nó e do pod para configurar os sites Unbounded-Net utilizados neste tutorial.

Os intervalos de endereços do nó AKS, do pod AKS, do nó flex, do pod flex e do serviço Kubernetes têm de seguir a arquitetura de rede selecionada e não se devem sobrepor entre si nem a qualquer rede acessível através de peering de rede virtual, VPN ou ExpressRoute. Coordena os valores finais com o administrador da rede.

Não copies exemplos de CIDRs de outra implementação. Os CIDRs identificam o espaço de endereçamento encaminhável, pelo que reutilizar um exemplo que se sobreponha ao Azure ou às redes conectadas pode causar ambiguidade no tráfego ou impedir que os nós e os pods comuniquem entre si.

Variable	Description	Usado por
AKS_SUBNET_CIDR	Intervalo de endereços atribuído à sub-rede para nós AKS geridos pelo Azure.	Rede virtual Azure e validação de subredes AKS
AKS_NODE_CIDR	Unbounded-Net Intervalo de nós do site que contém a sub-rede de nós do AKS.	site do cluster primário Unbounded-Net
AKS_POD_CIDR	Pool de endereços para pods em nós AKS geridos pelo Azure.	site do cluster primário Unbounded-Net
FLEX_HOST_SUBNET_CIDR	Gama de endereços que inclui os hosts do nó flex.	Validação da rede anfitriã do nó Flex
FLEX_NODE_CIDR	Unbounded-Net Intervalo de nós do site que contém a sub-rede do anfitrião do nó flex.	Unbounded-Net Site para nós flexíveis
FLEX_POD_CIDR	Pool de endereços para pods em nós flexíveis.	Unbounded-Net Site para nós flexíveis
SERVICE_CIDR	Intervalo de endereços dos serviços Kubernetes.	Perfil de rede de cluster AKS
DNS_SERVICE_IP	Endereço IP para o serviço DNS Kubernetes.	Perfil de rede de cluster AKS

Aplique as seguintes regras ao plano de endereços:

• AKS_SUBNET_CIDR deve estar contido em AKS_NODE_CIDR.
• FLEX_HOST_SUBNET_CIDR deve estar contido em FLEX_NODE_CIDR.
• DNS_SERVICE_IP deve estar dentro de SERVICE_CIDR.

Estes oito valores não são oito intervalos separados. Cinco são intervalos independentes que não devem sobrepor-se, dois são intervalos de sub-redes contidos dentro do respetivo intervalo de nós do Site, e um é um único endereço IP dentro do intervalo de serviço.

Os valores seguintes satisfazem todas as regras desta secção. Trata-os como uma ilustração das relações, não como incumprimentos. Confirme os seus próprios valores em relação ao espaço de endereços do Azure e da rede conectada antes de os utilizar.

Variable	Example	Relationship
AKS_NODE_CIDR	10.10.0.0/16	Intervalo independente
AKS_SUBNET_CIDR	10.10.1.0/24	Contido em AKS_NODE_CIDR
AKS_POD_CIDR	10.244.0.0/16	Intervalo independente
FLEX_NODE_CIDR	10.20.0.0/16	Intervalo independente
FLEX_HOST_SUBNET_CIDR	10.20.1.0/24	Contido em FLEX_NODE_CIDR
FLEX_POD_CIDR	10.245.0.0/16	Intervalo independente
SERVICE_CIDR	10.96.0.0/16	Intervalo independente
DNS_SERVICE_IP	10.96.0.10	Interior SERVICE_CIDR

Consulte os espaços de endereçamento de rede virtual do Azure atuais:

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

O Azure pode identificar conflitos dentro dos recursos que gere, mas não pode validar intervalos de endereços em todas as redes on-premises ou externas ligadas.

Valores de versão dos componentes

Os nós flex requerem versões compatíveis do AKS, da extensão CLI do Azure, do Unbounded-Net e do agente de nó flex. Use as versões listadas neste artigo e não selecione ou atualize estes componentes de forma independente.

Variable	Description
AKS_VERSION	Versão Kubernetes suportada para o cluster AKS.
AKS_PREVIEW_VERSION	aks-previewVersão 22.0.0b8 da extensão do CLI do Azure ou posterior.
UNBOUNDED_VERSION	Versão suportada do Unbounded-Net.
AKS_FLEX_NODE_VERSION	Versão do agente de nó flexível suportada.

Disponibilidade regional

Os nós flexíveis requerem a versão v20260904 do AKS ou posterior na região onde o seu cluster está alojado. O AKS aplica automaticamente estes lançamentos baseados em datas, e são separados da versão Kubernetes que defines em AKS_VERSION.

Antes de criar ou selecionar um cluster, abra o separador de Lançamentos AKS do rastreador de lançamentos AKS, encontre a sua região e verifique a versão em Atualmente em Operação. As versões lançadas do AKS utilizam este vYYYYMMDD formato. Se a sua região mostrar uma versão anterior, espere que a versão chegue à região ou, se os seus requisitos de implementação permitirem, selecione uma região onde a versão exigida esteja disponível.

Valor do espaço de trabalho local

Variable	Description
WORK_DIR	Diretório no teu ambiente Bash onde os artigos restantes armazenam downloads, ficheiros gerados e o ficheiro kubeconfig do cluster. O valor predefinido é ~/.local/share/aksflexnode/<deployment-name>. Para guardar estes ficheiros noutro local, como num diretório temporário que removes após a implementação, altera o WORK_DIR valor no ficheiro de ambiente.

Criar o ficheiro de ambiente partilhado

Crie um ficheiro de ambiente para cada implementação. O ficheiro mantém os valores não secretos coerentes nos restantes artigos e sessões de terminal.

Não armazene tokens de acesso, dados de bootstrap, conteúdo do kubeconfig, credenciais de principal de serviço, certificados, chaves privadas de certificados ou chaves privadas de SSH neste ficheiro.

1. Escolha um pequeno rótulo de implementação e crie um diretório protegido para o ficheiro de 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. Cria o ficheiro de 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
   

   O set_flexnode_env assistente permite que artigos posteriores gravem valores gerados pelo Azure sem adicionar definições duplicadas ao ficheiro.

3. Abre ${FLEXNODE_ENV_FILE} num editor e coloca cada valor entre colchetes angulares. Deixe os valores em Valores registados pelos artigos posteriores vazios.

4. Verifique se não restam marcadores de lugar.

   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. Carrega o ficheiro de ambiente, cria o diretório de trabalho e define a subscrição ativa do 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
   

   Confirme se o ID de subscrição devolvido corresponde a SUBSCRIPTION_ID.

   Confirme que AKS_API_ACCESS identifica um caminho suportado:

   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
   

   Inicie cada nova sessão de terminal definindo o rótulo de implementação e carregando o seu ficheiro de 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.}"
   

Validar os valores de planeamento

Verifique a sub-rede AKS selecionada.

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

Confirme se o ID de recurso devolvido e o intervalo de endereços correspondem AKS_SUBNET_ID e AKS_SUBNET_CIDR.

Passo seguinte

De seguida, prepare um cluster AKS para nós flexíveis. O artigo seguinte cria o cluster AKS público ou privado e regista o ID do recurso do cluster.