Planejar nós flexíveis para AKS (prévia)

Importante

As funcionalidades em versão preliminar do AKS estão disponíveis de forma optativa e por autoatendimento. As versões prévias são fornecidas “no estado em que se encontram” e “conforme disponíveis” e são excluídas dos contratos de nível de serviço e da garantia limitada. As versões prévias do AKS são parcialmente cobertas pelo suporte ao cliente em uma base de melhor esforço. Dessa forma, esses recursos não são destinados ao uso em produção. Para obter mais informações, consulte os seguintes artigos:

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

Os Nós Flex expandem um cluster do AKS (Serviço de Kubernetes do Azure) para incluir máquinas Linux que você gerencia fora dos pools de nós do cluster gerenciados pelo Azure. Antes de adicionar um nó flex, escolha como o host se autentica para Azure, como ele atinge o servidor de API do Kubernetes e como o tráfego de rede se move entre os ambientes do AKS e do nó flex.

Este artigo ajuda você a tomar essas decisões, planejar intervalos de endereços não sobrepostos e criar um arquivo de ambiente compartilhado para os artigos de implantação restantes.

Antes de começar

• Consulte a visão geral de nós flexíveis para AKS.
• Revise os conceitos de identidade e acesso para nós Flex.
• Examine os conceitos de rede para nós flex.
• Use um ambiente Bash compatível com Linux que tenha as ferramentas necessárias e o acesso à rede. Esta série sobre implantação se refere a esse ambiente como seu ambiente Bash. A máquina separada que ingressa no cluster é o host do nó flex.
• Instale o CLI do Azure. Execute az --version para localizar a versão instalada. Para instalar ou atualizar, consulte Instale o CLI do Azure.
• Entre no Azure com uma conta que possa ler a assinatura de destino e a configuração de rede virtual.
• Prepare uma rede virtual Azure existente e uma sub-rede para os nós do AKS gerenciados por Azure. A rede virtual pode estar em um grupo de recursos diferente do cluster do AKS. Quando isso acontecer, verifique se a identidade do cluster do AKS tem as permissões necessárias na sub-rede.

Tomar as decisões de implantação

Planeje as decisões a seguir antes de criar ou configurar recursos.

Decisão	Opções	O que a decisão controla
Identidade do host	Identidade gerenciada, identidade gerenciada do Azure Arc ou entidade de serviço	Como o agente de nó flex se autentica para Azure
Acesso à API do AKS	Cluster AKS público ou privado	Como o ambiente Bash e os hosts de nós flex resolvem e alcançam o servidor de API do Kubernetes
Conectividade do nó Flex	Conectividade de camada 3 ou um gateway WireGuard da Unbounded-Net	Como os nós gerenciados por AKS, os nós Flex, os pods e os serviços do Kubernetes se comunicam

Essas decisões abordam diferentes partes da implantação. Por exemplo, selecionar um ponto de extremidade público da API do AKS não cria conectividade de rede entre nós gerenciados pelo AKS e hosts de nós flex.

Escolher a identidade do host

Use a tabela de decisão em conceitos de identidade e acesso para nós flexíveis para escolher a identidade do Azure que o agente do nó flexível usa.

A identidade do host autoriza operações de Azure. Ele não substitui a conectividade de rede ou a configuração de inicialização do Kubernetes que o host precisa para ingressar no cluster. Não armazene credenciais no arquivo de ambiente compartilhado.

Escolher acesso à API do AKS público ou privado

O servidor de API do Kubernetes é o endpoint de gerenciamento do cluster. Seu ambiente Bash e o host de cada nó flex devem ser capazes de resolver e se conectar a esse endpoint.

• O acesso à API pública do AKS usa um ponto de extremidade público seguro. A autenticação e a autorização do Kubernetes ainda controlam o acesso ao cluster. Um endpoint público da API não expõe as aplicações em execução no cluster.
• O acesso à API privada do AKS usa um ponto de extremidade privado na rede virtual do AKS. Execute o CLI do Azure, kubectl, e os comandos de configuração do cluster no seu ambiente Bash, que deve ser executado em um computador conectado a essa rede privada. A rede de nós flex também deve ser capaz de resolver o nome DNS privado do cluster e rotear o tráfego para o endpoint privado.

As implantações de nós Flex oferecem suporte ao acesso público e privado ao servidor da API. O caminho privado requer configuração adicional de DNS, roteamento e execução de comandos, conforme indicado quando aplicável. Para orientações gerais sobre o AKS, consulte Planejar a rede do plano de controle para o AKS, Criar um cluster privado do AKS e Conectar-se a um cluster privado do AKS.

Selecione a conectividade do nó Flex

Essa série de implantação cria o cluster do AKS sem um plug-in de rede interno e instala Unbounded-Net nos nós gerenciados pelo AKS e nos nós flex. Unbounded-Net atribui intervalos de endereços para pods e configura o roteamento entre os ambientes do AKS e de nós flex. 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 de ciclo de vida diferentes. Para obter uma explicação do modelo de rede de visualização pública, consulte os conceitos de rede para nós flex.

Você fornece a conexão de rede subjacente entre os ambientes do AKS e de nós flexíveis. A conectividade da camada 3 significa que as duas redes de nós já podem rotear pacotes IP para endereços dos nós entre si, nas duas direções. Escolha o método que se ajusta à sua rede existente:

Método de conectividade	Quando utilizá-lo
Emparelhamento de rede virtual	O cluster do AKS e os hosts de nós flex estão em redes virtuais do Azure, incluindo redes virtuais em diferentes regiões.
Gateway de VPN	Os hosts de nós flex estão em um ambiente on-premises ou em outra rede que se conecta ao Azure por uma VPN site a site criptografada.
ExpressRoute	Sua organização usa uma conexão privada dedicada entre sua rede e Azure.
Gateway Unbounded-Net WireGuard	As redes de nós do AKS e flex não têm uma conexão roteada privada. Você configura e opera os túneis do WireGuard em um pool de nós de gateway do AKS e esses nós de gateway devem estar acessíveis publicamente. Planeje a capacidade e a disponibilidade do gateway, pois o tráfego de pod entre ambientes depende desse pool. Veja o cluster AKS público com o laboratório WireGuard da Unbounded-Net.

O guia passo a passo do Microsoft Learn usa conectividade de camada 3 com o Unbounded-Net.

AKS API	Conectividade do nó Flex	Orientação
Público	Conectividade de Camada 3	Configuração recomendada
Privada	Conectividade de Camada 3	Requer configuração de DNS, roteamento e execução de comando adicionais
Público	Gateway público do WireGuard	Topologia alternativa; ver os laboratórios do AKSFlexNode
Privada	Gateway público do WireGuard	Não coberto por esta documentação

Note

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

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

Planejar a conectividade de rede necessária

Trabalhe com o administrador de rede para garantir que o design de rede forneça a seguinte conectividade:

Requirement	Por que motivo é necessário
Seu ambiente bash pode resolver e acessar o servidor de API do AKS.	Você precisa dessa conexão para configurar e gerenciar o cluster.
Cada host de nó flex pode resolver e alcançar o servidor de API do AKS.	O agente Flex Node e o kubelet usam essa conexão para entrar no cluster e se comunicar com o plano de controle do Kubernetes.
Os nós gerenciados pelo AKS e os hosts de nós flex podem acessar os endereços IP privados entre si.	Para a maioria dos métodos de conectividade, a Unbounded-Net usa as redes dos nós como caminho subjacente entre os dois ambientes.
O tráfego de serviço de Pod e Kubernetes pode rotear entre nós gerenciados pelo AKS e nós flex.	As cargas de trabalho precisam de comunicação entre nós, DNS do cluster e acesso aos serviços do Kubernetes.
O painel de controle do AKS pode se conectar ao kubelet em um nó flex.	O AKS usa esse caminho para operações de kubelet, incluindo kubectl logs, kubectl exece kubectl port-forward.

Você configura e opera a rede de host externa, incluindo roteamento, emparelhamento de rede virtual, conexões VPN ou ExpressRoute, regras de grupo de segurança de rede e firewall, DNS, configurações de proxy e a configuração de Unbounded-Net documentada nesta série. Para o modelo de responsabilidade integral, consulte a política de suporte para nós flex.

Restrinja o acesso de gerenciamento de host a endereços de origem aprovados. Para uma VM Azure, associe um grupo de segurança de rede à sub-rede do host ou à interface de rede. Para um host fora Azure, aplique controles de firewall equivalentes. Se você usar az vm create para criar um host de nó flexível, examine endereços IP públicos e regras de grupo de segurança de rede criadas pelo comando. A menos que você restrinja a regra SSH, ela pode permitir conexões com a porta TCP 22 de qualquer fonte pública.

Coletar os valores de implantação

Os artigos restantes reutilizam os valores a seguir.

Valores comuns de recursos de Azure

Variable	Description	Quando ele é usado
SUBSCRIPTION_ID	Assinatura que contém o cluster do AKS e recursos de Azure relacionados.	Todas as implantações
RESOURCE_GROUP	Grupo de recursos que contém o cluster do AKS.	Todas as implantações
CLUSTER_NAME	Nome do cluster do AKS.	Todas as implantações
FLEX_POOL_NAME	Nome do pool de nós flex. Use somente letras e dígitos.	Todas as implantações
AKS_API_ACCESS	Modelo de acesso à API para o cluster do AKS. Defina o valor como public ou private.	Preparação do cluster e validação de conectividade de API
AKS_RESOURCE_ID	ID do recurso do Azure do cluster do AKS. Azure fornece esse valor depois que o cluster existe.	Artigos posteriores

Valores de cluster e de rede virtual do AKS

Variable	Description	Quando ele é usado
LOCATION	Região do Azure para o cluster do AKS. Confirme se essa região atende ao requisito de disponibilidade regional .	Criando o cluster do AKS
AKS_VNET_NAME	Nome da rede virtual que contém a sub-rede do AKS.	Localizando e validando a sub-rede do AKS
AKS_VNET_RESOURCE_GROUP	Grupo de recursos que contém a rede virtual do AKS. Pode ser diferente de RESOURCE_GROUP.	Localizando e validando a sub-rede do AKS
AKS_SUBNET_NAME	Nome da sub-rede usada pelos nós do AKS gerenciados por Azure.	Localizando e validando a sub-rede do AKS
AKS_SUBNET_ID	ID do recurso do Azure da sub-rede do AKS.	Criando o cluster do AKS
AKS_NODE_VM_SIZE	Tamanho da VM para o pool de nós do sistema do AKS gerenciado pelo Azure. Esse valor não dimensiona o host do nó flexível.	Criando o cluster do AKS
SERVICE_CIDR	Intervalo de endereços para serviços do Kubernetes.	Configurando o perfil de rede de cluster do AKS
DNS_SERVICE_IP	Endereço IP para o serviço DNS do Kubernetes.	Configurando o perfil de rede de cluster do AKS

Obtenha o ID do recurso da sub-rede do AKS e os intervalos de endereços antes de criar o arquivo 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

Valores de endereço do AKS e Unbounded-Net

Você usa SERVICE_CIDR e DNS_SERVICE_IP para configurar o perfil de rede do cluster do AKS. Configure os CIDRs de nós e pods necessários para configurar os Sites do Unbounded-Net usados neste passo a passo.

Os intervalos do nó do AKS, do pod do AKS, do nó flex, do pod flex e do serviço do Kubernetes devem seguir a arquitetura de rede selecionada e não devem se sobrepor entre si nem a qualquer rede acessível via emparelhamento de rede virtual, VPN ou ExpressRoute. Coordene os valores finais com o administrador de rede.

Não copie CIDRs de exemplo de outra implantação. Os CIDRs identificam o espaço de endereços roteável, portanto, reutilizar um exemplo que se sobreponha às suas redes do Azure ou às redes conectadas pode tornar o tráfego ambíguo ou impedir que nós e pods se comuniquem entre si.

Variable	Description	Usado por
AKS_SUBNET_CIDR	Faixa de endereços atribuída à sub-rede para nós do AKS gerenciados pelo Azure.	Azure rede virtual e validação de sub-rede do AKS
AKS_NODE_CIDR	Intervalo de nós de Sites do Unbounded-Net 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 do AKS gerenciados por Azure.	Site do cluster primário Unbounded-Net
FLEX_HOST_SUBNET_CIDR	Faixa de endereços que contém os hosts do nó flex.	Validação da rede de host do nó flex
FLEX_NODE_CIDR	Unbounded-Net intervalo de nós do site que contém a sub-rede de host do nó Flex.	Site do Unbounded-Net para nós flexíveis
FLEX_POD_CIDR	Conjunto de endereços para pods em nós flexíveis.	Site do Unbounded-Net para nós flexíveis
SERVICE_CIDR	Intervalo de endereços para serviços do Kubernetes.	Perfil de rede de cluster do AKS
DNS_SERVICE_IP	Endereço IP para o serviço DNS do Kubernetes.	Perfil de rede de cluster do AKS

Aplique as seguintes regras ao plano de endereço:

• 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 SERVICE_CIDR.

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

Os valores a seguir atendem a todas as regras desta seção. Trate-os como uma ilustração das relações, não como valores padrão. Confirme seus próprios valores em relação ao Azure e ao espaço de endereço de rede conectado antes de usá-los.

Variable	Exemplo	Relationship
AKS_NODE_CIDR	10.10.0.0/16	Intervalo independente
AKS_SUBNET_CIDR	10.10.1.0/24	Contido dentro de 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 dentro de 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	Dentro SERVICE_CIDR

Examine os espaços de endereço de rede virtual Azure atuais:

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

Azure pode identificar conflitos dentro dos recursos que gerencia, mas não pode validar intervalos de endereços em todas as redes locais ou externas conectadas.

Valores de versão do componente

Os nós flex exigem 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 esses componentes de forma independente.

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

Disponibilidade regional

Os nós flexíveis exigem a versão v20260904 do AKS ou posterior na região que hospeda seu cluster. O AKS aplica automaticamente essas versões baseadas em datas, e elas são separadas da versão do Kubernetes que você definiu em AKS_VERSION.

Antes de criar ou selecionar um cluster, abra a guia Versão do AKS do rastreador de lançamento do AKS, localize sua região e verifique a versão em Operação atualmente. As versões de lançamento do AKS usam o formato vYYYYMMDD. Se sua região mostrar uma versão anterior, aguarde até que a versão chegue à região ou, se os requisitos de implantação permitirem, selecione uma região em que a versão necessária esteja disponível.

Valor do espaço de trabalho local

Variable	Description
WORK_DIR	Diretório em seu ambiente Bash em que os artigos restantes armazenam downloads, arquivos gerados e o arquivo kubeconfig do cluster. O valor padrão é ~/.local/share/aksflexnode/<deployment-name>. Para manter esses arquivos em outro lugar, como um diretório temporário que você remove após a implantação, altere o WORK_DIR valor no arquivo de ambiente.

Criar o arquivo de ambiente compartilhado

Crie um arquivo de ambiente para cada implantação. O arquivo mantém os valores não secretos consistentes nos demais artigos e sessões de terminal.

Não armazene tokens de acesso, dados de inicialização, conteúdo kubeconfig, credenciais de entidade de serviço, certificados, chaves privadas de certificado ou chaves privadas SSH neste arquivo.

1. Escolha um rótulo de implantação curto e crie um diretório protegido para o arquivo 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. Crie o arquivo 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 auxiliar permite que artigos posteriores registrem valores gerados por Azure sem adicionar definições duplicadas ao arquivo.

3. Abra ${FLEXNODE_ENV_FILE} em um editor e substitua cada valor entre colchetes angulares. Deixe em branco os valores em Valores registrados por artigos posteriores.

4. Verifique se não restou nenhum marcador.

   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. Carregue o arquivo de ambiente, crie o diretório de trabalho e defina a assinatura Azure ativa.

   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 a ID da assinatura retornada corresponde SUBSCRIPTION_ID.

   Confirme se AKS_API_ACCESS identifica um caminho com suporte:

   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 implantação e carregando seu arquivo 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 planejamento

Verifique a sub-rede do 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 a ID do recurso retornado e o intervalo de endereços correspondem AKS_SUBNET_ID e AKS_SUBNET_CIDR.

Próximas etapas

Em seguida, prepare um cluster do AKS para nós flex. No próximo artigo, cria-se um cluster AKS público ou privado e registra-se a ID de recurso do cluster.