Planifier des nœuds flexibles pour AKS (version préliminaire)

Important

Les fonctionnalités d’évaluation AKS sont disponibles en libre-service et font l’objet d’un abonnement. Les versions préliminaires sont fournies « en l’état » et « selon leur disponibilité » et ne sont pas couvertes par les accords de niveau de service ni par la garantie limitée. Les versions préliminaires d’AKS sont partiellement couvertes par le support client, dans la limite du raisonnable. Par conséquent, ces fonctionnalités ne sont pas destinées à une utilisation en production. Pour plus d’informations, consultez les articles de support suivants :

Les nœuds Flex étendent un cluster Azure Kubernetes Service (AKS) aux machines Linux que vous gérez en dehors des pools de nœuds gérés par le cluster Azure. Avant d’ajouter un nœud flex, choisissez la façon dont l’hôte s’authentifie pour Azure, comment il atteint le serveur d’API Kubernetes et comment le trafic réseau se déplace entre les environnements AKS et les environnements de nœuds flexibles.

Cet article vous aide à prendre ces décisions, à planifier des plages d’adresses qui ne se chevauchent pas et à créer un fichier d’environnement partagé pour les articles de déploiement restants.

Avant de commencer

  • Passez en revue les nœuds flexibles pour la vue d’ensemble d’AKS.
  • Passez en revue les concepts d’identité et d’accès pour les nœuds flexibles.
  • Passez en revue les concepts de mise en réseau pour les nœuds flexibles.
  • Utilisez un environnement Bash compatible Linux qui dispose des outils et de l’accès réseau requis. Dans cette série sur le déploiement, cet environnement est désigné sous le nom de votre environnement Bash. La machine distincte qui rejoint le cluster est l’hôte du nœud Flex.
  • Installez le Azure CLI. Exécutez az --version pour rechercher la version installée. Pour installer ou mettre à niveau, consultez Installer le Azure CLI.
  • Connectez-vous à Azure avec un compte capable de lire l’abonnement cible et la configuration du réseau virtuel.
  • Préparez un réseau virtuel et un sous-réseau Azure existants pour les nœuds AKS gérés par Azure. Le réseau virtuel peut se trouver dans un groupe de ressources différent du cluster AKS. Quand c’est le cas, vérifiez que l’identité de cluster AKS dispose des autorisations requises sur le sous-réseau.

Prendre les décisions de déploiement

Planifiez les décisions suivantes avant de créer ou de configurer des ressources.

Décision Options Ce que contrôle la décision
Identité de l’hôte Identité managée, identité managée d’Azure Arc ou principal de service Comment l’agent de nœud flex s’authentifie pour Azure
Accès à l’API AKS Cluster AKS public ou privé Comment votre environnement Bash et les hôtes de nœuds Flex résolvent et accèdent au serveur d’API de Kubernetes
Connectivité des nœuds Flex Connectivité de niveau 3 ou une passerelle WireGuard Unbounded-Net Comment les nœuds gérés par AKS, les nœuds flexibles, les pods et les services Kubernetes communiquent

Ces décisions traitent différentes parties du déploiement. Par exemple, la sélection d’un point de terminaison d’API AKS public ne crée pas de connectivité réseau entre les nœuds gérés par AKS et les hôtes de nœuds flexibles.

Choisir l’identité de l’hôte

Utilisez la table de décision dans les concepts d’identité et d’accès pour les nœuds flex pour choisir l’identité Azure utilisée par l’agent de nœud flex.

L’identité de l’hôte autorise les opérations Azure. Elle ne remplace ni la connectivité réseau ni la configuration d’amorçage Kubernetes dont l’hôte a besoin pour rejoindre le cluster. Ne stockez pas les informations d’identification dans le fichier d’environnement partagé.

Choisir l’accès à l’API AKS publique ou privée

Le serveur d’API Kubernetes est le point de terminaison de gestion du cluster. Votre environnement Bash et chaque hôte de nœud Flex doivent être en mesure de résoudre et de se connecter à ce point de terminaison.

  • L’accès à l’API AKS public utilise un point de terminaison public sécurisé. L’authentification et l’autorisation Kubernetes contrôlent toujours l’accès au cluster. Un point de terminaison d’API publique n’expose pas les applications s’exécutant dans le cluster.
  • L’accès à l’API AKS privé utilise un point de terminaison privé dans le réseau virtuel AKS. Exécutez Azure CLI, kubectlet les commandes d’installation de cluster dans votre environnement Bash, qui doivent s’exécuter sur un ordinateur connecté à ce réseau privé. Le réseau de nœuds flex doit également être en mesure de résoudre le nom DNS privé du cluster et de router le trafic vers le point de terminaison privé.

Les déploiements de nœuds Flex prennent en charge l’accès public et privé au serveur d’API. Le chemin privé nécessite des configurations supplémentaires de DNS, de routage et d’exécution des commandes, indiquées là où elles s’appliquent. Pour obtenir des conseils généraux sur AKS, consultez Planifier la mise en réseau du plan de contrôle pour AKS, Créer un cluster AKS privé et se connecter à un cluster AKS privé.

Choisir la connectivité de nœud flexible

Cette série de déploiements crée le cluster AKS sans plug-in réseau intégré et installe Unbounded-Net sur les nœuds gérés par AKS et les nœuds flexibles. Unbounded-Net attribue des plages d’adresses de pod et configure le routage entre les environnements AKS et de nœuds flexibles. Cet article décrit ce flux de travail. D’autres configurations réseau ou CNI peuvent nécessiter différents routage, pare-feu, DNS, passerelle, sécurité et configuration du cycle de vie. Pour obtenir une explication du modèle de mise en réseau en préversion publique, consultez les concepts de mise en réseau pour les nœuds flexibles.

Vous fournissez la connexion réseau sous-jacente entre les environnements AKS et les environnements de nœud flexible. La connectivité de couche 3 signifie que les deux réseaux de nœuds peuvent déjà acheminer les paquets IP vers les adresses de nœud des autres, dans les deux sens. Choisissez la méthode qui correspond à votre réseau existant :

Méthode de connexion Quand l′utiliser ?
Interconnexion de réseaux virtuels Le cluster AKS et les hôtes des nœuds flex sont dans des réseaux virtuels Azure, y compris des réseaux virtuels situés dans différentes régions.
passerelle VPN Les hôtes de nœud flex se trouvent dans un environnement local ou un autre réseau qui se connecte à Azure via un VPN de site à site chiffré.
ExpressRoute Votre organisation utilise une connexion privée dédiée entre son réseau et son Azure.
passerelle WireGuard Unbounded-Net Les réseaux AKS et flex node n’ont pas de connexion routée privée. Vous configurez et utilisez les tunnels WireGuard sur un pool de nœuds de passerelle AKS, et ces nœuds de passerelle doivent être accessibles publiquement. Planifiez la capacité et la disponibilité de la passerelle, car le trafic des pods entre environnements dépend de ce pool de ressources. Consultez le cluster AKS public avec l’atelier WireGuard Unbounded-Net.

La procédure pas à pas Microsoft Learn utilise la connectivité de couche 3 avec Unbounded-Net.

AKS API Connectivité des nœuds Flex Conseils
Publique Connectivité de couche 3 Configuration recommandée
Privé Connectivité de couche 3 Nécessite une configuration dns, de routage et d’exécution de commande supplémentaire
Publique Passerelle WireGuard publique Topologie alternative ; voir les laboratoires AKSFlexNode
Privé Passerelle WireGuard publique Non couvert par cette documentation

Note

Pour obtenir des exemples de topologie supplémentaires, consultez les laboratoires AKSFlexNode, notamment des exemples qui utilisent un serveur d’API AKS public avec une passerelle WireGuard et un serveur d’API AKS privé avec une mise en réseau gérée par le client. Ces laboratoires complètent la configuration documentée dans cet article. Ces laboratoires peuvent utiliser différents composants réseau et avoir des responsabilités opérationnelles ou de support différentes. Avant d’utiliser un laboratoire, passez en revue ses prérequis, ses limitations, ses versions de composants applicables et les responsabilités des clients. Un laboratoire GitHub n'étend pas l'étendue de prise en charge documentée dans Microsoft Learn.

Pour fournir des commentaires sur une topologie qui n’est pas représentée, ouvrez un problème dans le référentiel AKSFlexNode. Incluez l’emplacement de l’hôte du nœud flex, le modèle d’accès à l’API AKS, la méthode de connectivité proposée, le CNI proposé et les chemins réseau requis par le scénario.

Planifier la connectivité réseau requise

Collaborez avec votre administrateur réseau pour vous assurer que la conception du réseau fournit la connectivité suivante :

Requirement Pourquoi il est nécessaire
Votre environnement Bash peut résoudre et atteindre le serveur d’API AKS. Vous avez besoin de cette connexion pour configurer et gérer le cluster.
Chaque hôte de nœud flexible peut résoudre et atteindre le serveur d’API AKS. L’agent de nœud flex et kubelet utilisent cette connexion pour joindre le cluster et communiquer avec le plan de contrôle Kubernetes.
Les nœuds gérés par AKS et les hôtes de nœuds flexibles peuvent atteindre les adresses IP privées des autres. Pour la plupart des méthodes de connectivité, Unbounded-Net utilise les réseaux de nœuds comme chemin sous-jacent entre les deux environnements.
Le trafic des pods et des services Kubernetes peut être acheminé entre les nœuds gérés par AKS et les nœuds Flex. Les charges de travail nécessitent une communication entre nœuds, un DNS de cluster et un accès au service Kubernetes.
Le plan de contrôle AKS peut se connecter au kubelet sur un nœud flexible. AKS utilise ce chemin d’accès pour les opérations kubelet, notamment kubectl logs, kubectl execet kubectl port-forward.

Vous configurez et utilisez le réseau hôte externe, notamment le routage, le peering de réseaux virtuels, les connexions VPN ou ExpressRoute, les règles de groupe de sécurité réseau, DNS, les paramètres proxy et la configuration Unbounded-Net documentée dans cette série. Pour le modèle de responsabilité complète, consultez la stratégie de prise en charge des nœuds flexibles.

Restreindre l’accès à la gestion des hôtes aux adresses source approuvées. Pour une machine virtuelle Azure, associez un groupe de sécurité réseau au sous-réseau hôte ou à l’interface réseau. Pour un hôte extérieur Azure, appliquez des contrôles de pare-feu équivalents. Si vous utilisez az vm create pour créer un hôte de nœud flexible, passez en revue les règles de groupe de sécurité réseau et d’adresse IP publiques créées par la commande. Sauf si vous limitez la règle SSH, elle peut autoriser les connexions au port TCP 22 à partir de n’importe quelle source publique.

Collecter les valeurs de déploiement

Les articles restants réutilisent les valeurs suivantes.

Valeurs de ressources Azure courantes

Variable Description Quand elle est utilisée
SUBSCRIPTION_ID Abonnement qui contient le cluster AKS et les ressources Azure associées. À chaque déploiement
RESOURCE_GROUP Groupe de ressources qui contient le cluster AKS. À chaque déploiement
CLUSTER_NAME Nom du cluster AKS. À chaque déploiement
FLEX_POOL_NAME Nom du pool de nœuds flex. Utilisez uniquement des lettres et des chiffres. À chaque déploiement
AKS_API_ACCESS Modèle d’accès à l’API pour le cluster AKS. Définissez la valeur sur public ou private. Validation de la préparation du cluster et de la connectivité des API
AKS_RESOURCE_ID Azure ID de ressource du cluster AKS. Azure fournit cette valeur une fois le cluster existant. Articles ultérieurs

Valeurs de cluster et de réseau virtuel AKS

Variable Description Quand elle est utilisée
LOCATION Région Azure du cluster AKS. Vérifiez que cette région répond aux exigences de disponibilité régionale . Création du cluster AKS
AKS_VNET_NAME Nom du réseau virtuel qui contient le sous-réseau AKS. Recherche et validation du sous-réseau AKS
AKS_VNET_RESOURCE_GROUP Groupe de ressources qui contient le réseau virtuel AKS. Il peut différer de RESOURCE_GROUP. Recherche et validation du sous-réseau AKS
AKS_SUBNET_NAME Nom du sous-réseau utilisé par les nœuds AKS gérés par Azure. Recherche et validation du sous-réseau AKS
AKS_SUBNET_ID Azure ID de ressource du sous-réseau AKS. Création du cluster AKS
AKS_NODE_VM_SIZE Taille de machine virtuelle Azure pour le pool de nœuds système AKS géré par Azure. Cette valeur ne définit pas la taille du nœud hôte flex. Création du cluster AKS
SERVICE_CIDR Plage d’adresses pour les services Kubernetes. Configuration du profil réseau du cluster AKS
DNS_SERVICE_IP Adresse IP du service DNS Kubernetes. Configuration du profil réseau du cluster AKS

Récupérez l’ID de ressource de sous-réseau AKS et les plages d’adresses avant de créer le fichier d’environnement :

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

Valeurs d’adresse AKS et Unbounded-Net

Vous utilisez SERVICE_CIDR et DNS_SERVICE_IP pour configurer le profil réseau du cluster AKS. Configurez les CIDR de nœud et de pod pour configurer les sites Unbounded-Net utilisés par cette procédure pas à pas.

Les plages du nœud AKS, du pod AKS, du nœud Flex, du pod Flex et du service Kubernetes doivent respecter l’architecture réseau choisie et ne doivent se chevaucher ni entre elles ni avec un réseau accessible via l’appairage de réseaux virtuels, un VPN ou ExpressRoute. Coordonnez les valeurs finales avec votre administrateur réseau.

Ne copiez pas d’exemple de CIDR à partir d’un autre déploiement. Les blocs CIDR identifient l’espace d’adressage routable. Réutiliser un exemple qui recoupe vos réseaux Azure ou les réseaux connectés peut donc entraîner une ambiguïté dans le routage du trafic ou empêcher les nœuds et les pods de communiquer entre eux.

Variable Description Utilisé par
AKS_SUBNET_CIDR Plage d’adresses affectée au sous-réseau pour les nœuds AKS gérés par Azure. Validation du réseau virtuel Azure et du sous-réseau AKS
AKS_NODE_CIDR Plage de nœuds du site Unbounded-Net qui contient le sous-réseau des nœuds AKS. Site principal du cluster Unbounded-Net
AKS_POD_CIDR Pool d’adresses pour les pods sur des nœuds AKS gérés par Azure. Site principal du cluster Unbounded-Net
FLEX_HOST_SUBNET_CIDR Plage d’adresses contenant les hôtes du nœud Flex. Validation du réseau hôte du nœud Flex
FLEX_NODE_CIDR Plage de nœuds du site Unbounded-Net contenant le sous-réseau hôte du nœud flexible. site Unbounded-Net pour les nœuds flexibles
FLEX_POD_CIDR Pool d’adresses pour les pods sur les nœuds flexibles. site Unbounded-Net pour les nœuds flexibles
SERVICE_CIDR Plage d’adresses pour les services Kubernetes. Profil réseau du cluster AKS
DNS_SERVICE_IP Adresse IP du service DNS Kubernetes. Profil réseau du cluster AKS

Appliquez les règles suivantes au plan d’adresse :

  • AKS_SUBNET_CIDR doit être contenu dans AKS_NODE_CIDR.
  • FLEX_HOST_SUBNET_CIDR doit être contenu dans FLEX_NODE_CIDR.
  • DNS_SERVICE_IP doit être dans SERVICE_CIDR.

Ces huit valeurs ne sont pas huit plages distinctes. Cinq sont des plages indépendantes qui ne doivent pas se chevaucher, deux sont des plages de sous-réseaux contenues dans leur plage de nœuds de site correspondante, et une seule adresse IP à l’intérieur de la plage de services.

Les valeurs suivantes répondent à chaque règle de cette section. Traitez-les comme une illustration des relations, et non comme des valeurs par défaut. Confirmez vos propres valeurs par rapport à votre Azure et à l’espace d’adressage réseau connecté avant de les utiliser.

Variable Example Relationship
AKS_NODE_CIDR 10.10.0.0/16 Plage indépendante
AKS_SUBNET_CIDR 10.10.1.0/24 Contenu dans AKS_NODE_CIDR
AKS_POD_CIDR 10.244.0.0/16 Plage indépendante
FLEX_NODE_CIDR 10.20.0.0/16 Plage indépendante
FLEX_HOST_SUBNET_CIDR 10.20.1.0/24 Contenu dans FLEX_NODE_CIDR
FLEX_POD_CIDR 10.245.0.0/16 Plage indépendante
SERVICE_CIDR 10.96.0.0/16 Plage indépendante
DNS_SERVICE_IP 10.96.0.10 Intérieur SERVICE_CIDR

Passez en revue les espaces d’adressage de réseau virtuel Azure actuels :

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

Azure pouvez identifier les conflits au sein des ressources qu'il gère, mais il ne peut pas valider les plages d'adresses dans chaque réseau local ou externe connecté.

Valeurs de version du composant

Les nœuds Flex nécessitent des versions compatibles d’AKS, l’extension Azure CLI, Unbounded-Net et l’agent de nœud flex. Utilisez les versions répertoriées dans cet article et ne sélectionnez pas ou ne mettez pas à niveau ces composants indépendamment.

Variable Description
AKS_VERSION Version kubernetes prise en charge pour le cluster AKS.
AKS_PREVIEW_VERSION aks-preview version de l’extension Azure CLI 22.0.0b8 ou version ultérieure.
UNBOUNDED_VERSION Version Unbounded-Net prise en charge.
AKS_FLEX_NODE_VERSION Version de l’agent de nœud flexible prise en charge.

Disponibilité régionale

Les nœuds Flex nécessitent la version d’AKS v20260904 ou ultérieure dans la région où votre cluster est hébergé. AKS applique automatiquement ces versions basées sur des dates, et elles sont séparées de la version kubernetes que vous définissez dans AKS_VERSION.

Avant de créer ou de sélectionner un cluster, ouvrez l’onglet Publication AKS du suivi des versions AKS, recherchez votre région et vérifiez la version sous Actuellement en cours d’opération. Les versions de publication d’AKS utilisent le format vYYYYMMDD. Si votre région affiche une version antérieure, attendez que la version atteigne la région ou, si vos exigences de déploiement autorisent, sélectionnez une région où la version requise est disponible.

Valeur de l’espace de travail local

Variable Description
WORK_DIR Répertoire dans votre environnement Bash où les articles restants stockent les téléchargements, les fichiers générés et le fichier kubeconfig du cluster. La valeur par défaut est ~/.local/share/aksflexnode/<deployment-name>. Pour conserver ces fichiers ailleurs, par exemple un répertoire temporaire que vous supprimez après le déploiement, modifiez la WORK_DIR valeur dans le fichier d’environnement.

Créer le fichier d’environnement partagé

Créez un fichier d’environnement pour chaque déploiement. Le fichier conserve les valeurs non-secret cohérentes entre les articles restants et les sessions de terminal.

Ne stockez pas de jetons d’accès, de données de démarrage, de contenu kubeconfig, d’informations d’identification du principal de service, de certificats, de clés privées de certificat ou de clés privées SSH dans ce fichier.

  1. Choisissez une étiquette de déploiement courte et créez un répertoire protégé pour le fichier d’environnement.

    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. Créez le fichier d’environnement.

    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’assistance set_flexnode_env permet aux articles ultérieurs d’enregistrer des valeurs générées Azure sans ajouter de définitions dupliquées au fichier.

  3. Ouvrez ${FLEXNODE_ENV_FILE} dans un éditeur et remplacez chaque valeur entre crochets. Laissez les valeurs sous Valeurs enregistrées par les articles ultérieurs vides .

  4. Vérifiez qu’aucun espace réservé n’est conservé.

    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. Chargez le fichier d’environnement, créez le répertoire de travail et définissez l’abonnement actif 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

    Vérifiez que l’ID d’abonnement retourné correspond SUBSCRIPTION_ID.

    Vérifiez que AKS_API_ACCESS correspond à un chemin pris en charge :

    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

    Démarrez chaque nouvelle session de terminal en définissant l’étiquette de déploiement et en chargeant son fichier d’environnement :

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

Valider les valeurs de planification

Vérifiez le sous-réseau AKS sélectionné.

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

Vérifiez que l’ID de ressource et la plage d’adresses retournés correspondent AKS_SUBNET_ID et AKS_SUBNET_CIDR.

Étape suivante

Ensuite, préparez un cluster AKS pour les nœuds flexibles. L’article suivant crée le cluster AKS public ou privé et enregistre l’ID de ressource du cluster.

  • Dernière mise à jour :