Planeamiento de nodos flexibles para AKS (versión preliminar)

Importante

Las características en versión preliminar de AKS están disponibles en régimen de autoservicio y mediante adhesión voluntaria. Las versiones preliminares se proporcionan "tal cual" y "como están disponibles", y están excluidas de los Acuerdos de nivel de servicio y la garantía limitada. Las versiones preliminares de AKS cuentan con soporte parcial por parte del servicio al cliente en la medida de lo posible. Por lo tanto, estas características no están diseñadas para su uso en producción. Para más información, consulte los siguientes artículos de soporte:

Los nodos Flex amplían un clúster de Azure Kubernetes Service (AKS) para incluir máquinas Linux que administra fuera de los grupos de nodos del clúster administrados por Azure. Antes de agregar un nodo flexible, elija cómo se autentica el host en Azure, cómo llega al servidor de API de Kubernetes y cómo se mueve el tráfico de red entre los entornos de nodo flexible y AKS.

Este artículo le ayuda a tomar estas decisiones, planificar rangos de direcciones que no se superpongan y crear un archivo de entorno compartido para los artículos restantes sobre la implementación.

Antes de empezar

  • Consulte la información general sobre los nodos flex para AKS.
  • Revise los conceptos de identidad y acceso para los nodos flexibles.
  • Revise los conceptos de red para los nodos flexibles.
  • Use un entorno de Bash compatible con Linux que tenga las herramientas necesarias y el acceso a la red. Esta serie sobre implementación se refiere a ese entorno como tu entorno de Bash. La máquina independiente que se une al clúster es el host de nodo flexible.
  • Instale el CLI de Azure. Ejecute az --version para buscar la versión instalada. Para la instalación o la actualización, consulte Instalación de la CLI de Azure.
  • Inicie sesión en Azure con una cuenta que pueda leer la suscripción de destino y la configuración de red virtual.
  • Prepare una red virtual y una subred de Azure existentes para los nodos de AKS administrados por Azure. La red virtual puede estar en un grupo de recursos diferente del clúster de AKS. Cuando sea así, asegúrese de que la identidad del clúster de AKS tenga los permisos necesarios en la subred.

Tomar las decisiones de implementación

Planee las siguientes decisiones antes de crear o configurar recursos.

Decisión Opciones Qué controla la decisión
Identidad de host Identidad administrada, identidad administrada de Azure Arc o entidad de servicio Cómo se autentica el agente de nodo flexible en Azure
Acceso a la API de AKS Clúster de AKS público o privado Cómo resuelven y acceden su entorno Bash y los hosts de los nodos flexibles al servidor de la API de Kubernetes
Conectividad del nodo Flex Conectividad de nivel 3 o puerta de enlace de Unbounded-Net WireGuard Cómo se comunican los nodos administrados por AKS, los nodos flexibles, los pods y los servicios de Kubernetes

Estas decisiones abordan diferentes partes de la implementación. Por ejemplo, al seleccionar un punto de conexión de API de AKS público no se crea conectividad de red entre nodos administrados por AKS y hosts de nodo flexible.

Elección de la identidad del host

Use la tabla de decisiones en los conceptos de identidad y acceso para los nodos flexibles para elegir la identidad de Azure que usa el agente de nodo flexible.

La identidad del host autoriza las operaciones de Azure. No reemplaza la conectividad de red ni la configuración de arranque de Kubernetes que el host necesita para unirse al clúster. No almacene las credenciales en el archivo de entorno compartido.

Elección del acceso a la API de AKS pública o privada

El servidor de API de Kubernetes es el punto de conexión de administración del clúster. Su entorno Bash y cada host de nodo flexible deben poder resolver y conectarse a este punto de conexión.

  • El acceso a la API de AKS pública usa un punto de conexión público protegido. La autenticación y la autorización de Kubernetes siguen controlando el acceso al clúster. Un punto de conexión de API público no expone las aplicaciones que se ejecutan en el clúster.
  • El acceso a la API de AKS privada usa un punto de conexión privado en la red virtual de AKS. Ejecute CLI de Azure, kubectl, y comandos de configuración del clúster en el entorno de Bash, que deben ejecutarse en una máquina conectada a esa red privada. La red del nodo flexible también debe poder resolver el nombre DNS privado del clúster y enrutar el tráfico al punto de conexión privado.

Las implementaciones de nodos flexibles admiten el acceso público y privado al servidor de API. La ruta privada requiere una configuración adicional de DNS, del enrutamiento y de la ejecución de comandos, que se indica donde corresponda. Para obtener instrucciones generales de AKS, consulte Planeamiento de redes de plano de control para AKS, Creación de un clúster de AKS privado y Conexión a un clúster de AKS privado.

Elección de la conectividad de nodo flexible

Esta serie de implementación crea el clúster de AKS sin un complemento de red integrado e instala Unbounded-Net tanto en los nodos administrados por AKS como en los nodos flex. Unbounded-Net asigna intervalos de direcciones de pod y configura el enrutamiento entre los entornos de nodo flexible y AKS. En este artículo se describe ese flujo de trabajo. Otras configuraciones de red o CNI pueden requerir un enrutamiento diferente, firewall, DNS, puerta de enlace, seguridad y configuración del ciclo de vida. Para obtener una explicación del modelo de red de versión preliminar pública, consulte Conceptos de redes para nodos flexibles.

Proporciona la conexión de red subyacente entre AKS y los entornos de nodos flexibles. La conectividad de nivel 3 significa que ambas redes de nodos ya pueden enrutar paquetes IP a las direcciones de nodo entre sí, en ambas direcciones. Elija el método que se ajuste a la red existente:

Método de conectividad Cuándo usarlo
Interconexión de redes virtuales El clúster de AKS y los hosts de nodos flexibles se encuentran en redes virtuales de Azure, incluidas redes virtuales en distintas regiones.
Pasarela VPN Los hosts de nodo flexible se encuentran en un entorno local u otra red que se conecta a Azure a través de una VPN de sitio a sitio cifrada.
ExpressRoute Su organización usa una conexión privada dedicada entre su red y Azure.
puerta de enlace de Unbounded-Net WireGuard Las redes de nodos flexible y AKS no tienen una conexión enrutada privada. Configure y opere los túneles de WireGuard en un grupo de nodos de puerta de enlace de AKS y esos nodos de puerta de enlace deben ser accesibles públicamente. Planee la capacidad y la disponibilidad de la puerta de enlace, ya que el tráfico entre pods del entorno depende de este grupo. Consulte el clúster público de AKS con el laboratorio de WireGuard de Unbounded-Net.

En el tutorial de Microsoft Learn se usa la conectividad de nivel 3 con Unbounded-Net.

AKS API Conectividad del nodo Flex Orientación
Public Conectividad de nivel 3 Configuración recomendada
Privada Conectividad de nivel 3 Requiere una configuración adicional de DNS, enrutamiento y ejecución de comandos.
Public Puerta de enlace pública de WireGuard Topología alternativa; consulte los laboratorios de AKSFlexNode.
Privada Puerta de enlace pública de WireGuard No se incluye en esta documentación

Note

Para obtener ejemplos adicionales de topología, consulte los laboratorios de AKSFlexNode, incluidos ejemplos que usan un servidor de API de AKS público con una puerta de enlace de WireGuard y un servidor de API de AKS privado con redes administradas por el cliente. Estos laboratorios complementan la configuración documentada en este artículo. Estos laboratorios pueden usar diferentes componentes de red y tener diferentes responsabilidades operativas o de soporte técnico. Antes de usar un laboratorio, revise sus requisitos previos, limitaciones, versiones de componentes aplicables y responsabilidades del cliente. Un laboratorio de GitHub no expande el ámbito de soporte técnico documentado en Microsoft Learn.

Para proporcionar comentarios sobre una topología que no está representada, abra un problema en el repositorio AKSFlexNode. Incluya la ubicación del host del nodo flexible, el modelo de acceso a la API de AKS, el método de conectividad propuesto, el CNI propuesto y las rutas de acceso de red necesarias para el escenario.

Planeamiento de la conectividad de red necesaria

Trabaje con el administrador de red para asegurarse de que el diseño de red proporciona la conectividad siguiente:

Requisito Por qué es necesario
El entorno de Bash puede resolver y acceder al servidor de API de AKS. Necesita esta conexión para configurar y administrar el clúster.
Cada host de nodo flexible puede resolver y llegar al servidor de API de AKS. El agente de nodo flexible y kubelet usan esta conexión para unir el clúster y comunicarse con el plano de control de Kubernetes.
Los nodos administrados por AKS y los hosts de nodos flexibles pueden alcanzar las direcciones IP privadas entre sí. Para la mayoría de los métodos de conectividad, Unbounded-Net usa las redes de nodo como ruta de acceso subyacente entre los dos entornos.
El tráfico del servicio Pod y Kubernetes puede enrutar entre nodos administrados por AKS y nodos flexibles. Las cargas de trabajo necesitan comunicación entre nodos, DNS de clúster y acceso al servicio Kubernetes.
El plano de control de AKS puede conectarse al kubelet en un nodo flexible. AKS usa esta ruta de acceso para las operaciones de kubelet, como kubectl logs, kubectl execy kubectl port-forward.

Configure y administre la red externa del host, incluidos el enrutamiento, el emparejamiento entre redes virtuales, las conexiones VPN o ExpressRoute, las reglas del firewall y del grupo de seguridad de red, DNS, la configuración de proxy y la configuración de Unbounded-Net documentada en esta serie. Para consultar el modelo de responsabilidad completa, consulte la política de soporte para nodos Flex.

Restrinja el acceso de administración de hosts a direcciones de origen aprobadas. Para una máquina virtual de Azure, asocie un grupo de seguridad de red a la subred host o a la interfaz de red. Para un host fuera de Azure, aplique controles de firewall equivalentes. Si usa az vm create para crear un host de nodo flexible, revise cualquier dirección IP pública y reglas de grupo de seguridad de red que cree el comando. A menos que restrinja la regla SSH, puede permitir conexiones al puerto TCP 22 desde cualquier origen público.

Recopilación de los valores de implementación

Los artículos restantes reutilizan los siguientes valores.

Valores comunes de recursos de Azure

Variable Description Cuando se usa
SUBSCRIPTION_ID Suscripción que contiene el clúster de AKS y los recursos de Azure relacionados. Cada despliegue
RESOURCE_GROUP Grupo de recursos que contiene el clúster de AKS. Cada despliegue
CLUSTER_NAME Nombre del clúster de AKS. Cada despliegue
FLEX_POOL_NAME Nombre del grupo de nodos flexible. Use solo letras y dígitos. Cada despliegue
AKS_API_ACCESS Modelo de acceso de API para el clúster de AKS. Establezca el valor en public o private. Preparación del clúster y validación de conectividad de API
AKS_RESOURCE_ID Identificador de recurso de Azure del clúster de AKS. Azure proporciona este valor después de que exista el clúster. Artículos posteriores

Valores de clúster y red virtual de AKS

Variable Description Cuando se usa
LOCATION Región de Azure para el clúster de AKS. Confirme que esta región cumple el requisito de disponibilidad regional . Creación del clúster de AKS
AKS_VNET_NAME Nombre de la red virtual que contiene la subred de AKS. Búsqueda y validación de la subred de AKS
AKS_VNET_RESOURCE_GROUP Grupo de recursos que contiene la red virtual de AKS. Puede diferir de RESOURCE_GROUP. Búsqueda y validación de la subred de AKS
AKS_SUBNET_NAME Nombre de la subred usada por los nodos de AKS administrados por Azure. Búsqueda y validación de la subred de AKS
AKS_SUBNET_ID Identificador de recurso de Azure de la subred de AKS. Creación del clúster de AKS
AKS_NODE_VM_SIZE Tamaño de la máquina virtual de Azure para el grupo de nodos del sistema de AKS administrado por Azure. Este valor no cambia el tamaño del host de nodo flexible. Creación del clúster de AKS
SERVICE_CIDR Intervalo de direcciones para los servicios de Kubernetes. Configuración del perfil de red del clúster de AKS
DNS_SERVICE_IP Dirección IP del servicio DNS de Kubernetes. Configuración del perfil de red del clúster de AKS

Recupere el identificador del recurso de la subred de AKS y los intervalos de direcciones antes de crear el archivo de entorno:

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 dirección de AKS y Unbounded-Net

Usa SERVICE_CIDR y DNS_SERVICE_IP para configurar el perfil de red del clúster de AKS. Configure los CIDR de los nodos y de los pods para configurar los sitios de Unbounded-Net usados en esta guía.

El nodo de AKS, el pod de AKS, el nodo flexible, el pod flexible y los rangos de servicio de Kubernetes deben ajustarse al diseño de red seleccionado y no deben superponerse entre sí ni con ninguna red accesible a través del emparejamiento de red virtual, VPN o ExpressRoute. Coordinar los valores finales con el administrador de red.

No copie los CIDR de ejemplo de otro despliegue. Los bloques CIDR identifican el espacio de direcciones enrutable, por lo que reutilizar un ejemplo que se superpone con sus redes de Azure o con las redes conectadas puede provocar ambigüedad en el tráfico o impedir que los nodos y los pods se comuniquen entre sí.

Variable Description Usado por
AKS_SUBNET_CIDR Intervalo de direcciones asignado a la subred para los nodos de AKS administrados por Azure. Red virtual de Azure y validación de la subred de AKS
AKS_NODE_CIDR Rango de nodos de Unbounded-Net Site que contiene la subred de nodos de AKS. Sitio del clúster primario de Unbounded-Net
AKS_POD_CIDR Grupo de direcciones para pods en nodos de AKS administrados por Azure. Sitio del clúster primario de Unbounded-Net
FLEX_HOST_SUBNET_CIDR Intervalo de direcciones que contiene los hosts del nodo flex. Validación de la red del host del nodo Flex
FLEX_NODE_CIDR Rango de nodos del sitio de Unbounded-Net que contiene la subred del host del nodo Flex. sitio de Unbounded-Net para nodos flexibles
FLEX_POD_CIDR Rango de direcciones para los pods en nodos Flex. sitio de Unbounded-Net para nodos flexibles
SERVICE_CIDR Intervalo de direcciones para los servicios de Kubernetes. Perfil de red del clúster de AKS
DNS_SERVICE_IP Dirección IP del servicio DNS de Kubernetes. Perfil de red del clúster de AKS

Aplique las reglas siguientes al plan de direcciones:

  • AKS_SUBNET_CIDR debe estar incluido en AKS_NODE_CIDR.
  • FLEX_HOST_SUBNET_CIDR debe estar incluido en FLEX_NODE_CIDR.
  • DNS_SERVICE_IP debe estar dentro de SERVICE_CIDR.

Estos ocho valores no son ocho intervalos independientes. Cinco son intervalos independientes que no se deben superponer, dos son intervalos de subredes contenidos en su intervalo de nodos de sitio correspondiente y uno es una única dirección IP dentro del intervalo de servicios.

Los valores siguientes satisfacen todas las reglas de esta sección. Trátelas como una ilustración de las relaciones, no como valores predeterminados. Compruebe sus propios valores con su espacio de direcciones de Azure y de la red conectada antes de utilizarlos.

Variable Example Relationship
AKS_NODE_CIDR 10.10.0.0/16 Intervalo independiente
AKS_SUBNET_CIDR 10.10.1.0/24 Contenido en AKS_NODE_CIDR
AKS_POD_CIDR 10.244.0.0/16 Intervalo independiente
FLEX_NODE_CIDR 10.20.0.0/16 Intervalo independiente
FLEX_HOST_SUBNET_CIDR 10.20.1.0/24 Contenido en FLEX_NODE_CIDR
FLEX_POD_CIDR 10.245.0.0/16 Intervalo independiente
SERVICE_CIDR 10.96.0.0/16 Intervalo independiente
DNS_SERVICE_IP 10.96.0.10 Dentro SERVICE_CIDR

Revise los espacios de direcciones actuales de la red virtual de Azure:

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

Azure puede identificar conflictos dentro de los recursos que administra, pero no puede validar los intervalos de direcciones en todas las redes locales o externas conectadas.

Valores de versión del componente

Los nodos flex requieren versiones compatibles de AKS, la extensión CLI de Azure, Unbounded-Net y el agente de nodo flexible. Use las versiones enumeradas en este artículo y no seleccione ni actualice estos componentes de forma independiente.

Variable Description
AKS_VERSION Versión de Kubernetes compatible para el clúster de AKS.
AKS_PREVIEW_VERSION aks-preview versión de la extensión de CLI de Azure 22.0.0b8 o posterior.
UNBOUNDED_VERSION Versión compatible de Unbounded-Net.
AKS_FLEX_NODE_VERSION Versión compatible del agente Flex Node.

Disponibilidad regional

Los nodos flex requieren la versión v20260904 de AKS o posterior en la región que hospeda el clúster. AKS aplica automáticamente estas versiones basadas en fechas y son independientes de la versión de Kubernetes que estableció en AKS_VERSION.

Antes de crear o seleccionar un clúster, abra la pestaña Versión de AKS del rastreador de versiones de AKS, busque la región y compruebe la versión en Actualmente en funcionamiento. Las versiones de lanzamiento de AKS usan el formato vYYYYMMDD. Si la región muestra una versión anterior, espere a que la versión llegue a la región o, si los requisitos de implementación permiten, seleccione una región en la que esté disponible la versión necesaria.

Valor del área de trabajo local

Variable Description
WORK_DIR Directorio en el entorno de Bash donde los artículos restantes almacenan descargas, archivos generados y el archivo kubeconfig del clúster. El valor por defecto es ~/.local/share/aksflexnode/<deployment-name>. Para mantener estos archivos en otro lugar, como un directorio temporal que quite después de la implementación, cambie el WORK_DIR valor en el archivo de entorno.

Creación del archivo de entorno compartido

Cree un archivo de entorno para cada implementación. El archivo mantiene uniformes los valores no secretos en los artículos restantes y las sesiones de terminal.

No almacene tokens de acceso, datos de arranque, contenido kubeconfig, credenciales de entidad de servicio, certificados, claves privadas de certificado o claves privadas SSH en este archivo.

  1. Elija una etiqueta de implementación corta y cree un directorio protegido para el archivo de entorno.

    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. Cree el archivo de entorno.

    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

    El set_flexnode_env asistente permite que los artículos posteriores registren valores generados Azure sin agregar definiciones duplicadas al archivo.

  3. Abra ${FLEXNODE_ENV_FILE} en un editor y reemplace cada valor entre corchetes angulares. Deje vacíos los valores debajo de Valores registrados por artículos posteriores.

  4. Compruebe que no quedan marcadores de posición.

    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. Cargue el archivo de entorno, cree el directorio de trabajo y establezca la suscripción de Azure activa.

    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 que el identificador de suscripción devuelto coincide con SUBSCRIPTION_ID.

    Confirme que AKS_API_ACCESS identifica una ruta de acceso admitida:

    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 nueva sesión de terminal estableciendo la etiqueta de implementación y cargando su archivo de entorno:

    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 los valores de planeación

Compruebe la subred de AKS seleccionada.

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 que el identificador de recurso devuelto y el rango de direcciones coincidan con AKS_SUBNET_ID y AKS_SUBNET_CIDR.

Paso siguiente

A continuación, prepare un clúster de AKS para nodos flexibles. En el siguiente artículo se crea el clúster de AKS público o privado y se registra el identificador de recurso del clúster.

  • Se actualizó por última vez el