Créer un cluster Azure Kubernetes Service (AKS) isolé en réseau

• Utilisez l’environnement Bash dans Azure Cloud Shell. Pour obtenir plus d’informations, consultez Démarrage d’Azure Cloud Shell.

  

• Si vous préférez exécuter les commandes de référence de l’interface de ligne de commande localement, installez l’interface Azure CLI. Si vous exécutez sur Windows ou macOS, envisagez d’exécuter Azure CLI dans un conteneur Docker. Pour plus d’informations, consultez Guide pratique pour exécuter Azure CLI dans un conteneur Docker.

  • Si vous utilisez une installation locale, connectez-vous à Azure CLI à l’aide de la commande az login. Pour finir le processus d’authentification, suivez les étapes affichées dans votre terminal. Pour obtenir d’autres options de connexion, consultez S’authentifier auprès d’Azure à l’aide d’Azure CLI.

  • Lorsque vous y êtes invité, installez l’extension Azure CLI lors de la première utilisation. Pour plus d’informations sur les extensions, consultez Utiliser et gérer des extensions avec Azure CLI.

  • Exécutez az version pour rechercher la version et les bibliothèques dépendantes installées. Pour effectuer une mise à niveau vers la dernière version, exécutez az upgrade.

• Cet article nécessite la version 2.73.0 ou ultérieure d’Azure CLI. Si vous utilisez Azure Cloud Shell, sachez que la dernière version y est déjà installée.
• Vous devez installer l’extension aks-preview Azure CLI version 9.0.0b2 ou ultérieure si vous utilisez le type de sortie block (préversion).
  • Si vous n’avez pas encore l’extension aks-preview, installez-la en utilisant la commande az extension add.

    az extension add --name aks-preview
    

  • Si vous disposez déjà de l’extension aks-preview, mettez-la à jour pour vous assurer que vous disposez de la dernière version en utilisant la commande az extension update.

    az extension update --name aks-preview
    

Définir des variables d’environnement

Définissez les variables d’environnement utilisées dans cet article. Le nom ACR doit être globalement unique et contenir uniquement des caractères alphanumériques minuscules.

RESOURCE_GROUP="myResourceGroup"
LOCATION="eastus"
AKS_NAME="myAKSCluster"
VNET_NAME="myVNet"
AKS_SUBNET_NAME="aksSubnet"
ACR_SUBNET_NAME="acrSubnet"
APISERVER_SUBNET_NAME="apiServerSubnet"
REGISTRY_NAME="myregistry${RANDOM}"
CLUSTER_IDENTITY_NAME="clusterIdentity"
KUBELET_IDENTITY_NAME="kubeletIdentity"

az group create --name ${RESOURCE_GROUP} --location ${LOCATION}

• Un compte Azure avec un abonnement actif. Si vous n’en avez pas, créez un compte gratuit avant de commencer.
• Installez et configurez Terraform.
• Azure CLI installé et connecté à l’aide de az login, utilisé pour vérifier le déploiement et se connecter au cluster. Installez Azure CLI si vous ne l'avez pas déjà.
• kubectl installé pour se connecter au cluster. Si vous utilisez Azure Cloud Shell, kubectl est déjà installé. Pour l’installer localement, utilisez la az aks install-cli commande.
• jq installé, utilisé pour analyser l’état Terraform lors de la vérification du déploiement. Azure Cloud Shell a déjà jq installé.

Déployer un cluster isolé du réseau avec ACR géré par AKS

AKS crée, gère et rapproche une ressource ACR dans cette option. Vous n’avez pas besoin d’attribuer d’autorisations ni de gérer l’ACR. AKS gère les règles de cache, la liaison privée et le point de terminaison privé utilisés dans le cluster isolé du réseau.

Créer un cluster isolé du réseau

Lors de la création d’un cluster AKS isolé de réseau, choisissez l’un des modes de cluster privé suivants : intégration de réseaux virtuels basés sur des liaisons privées ou du serveur d’API.

Définissez la source d’artefact et le type sortant en fonction de vos exigences d’isolation réseau.

Basé sur un lien privé

Créez un cluster isolé basé sur des liaisons privées en exécutant la commande az aks create avec --bootstrap-artifact-source, --enable-private-clusteret --outbound-type les paramètres.

az aks create --resource-group ${RESOURCE_GROUP} --name ${AKS_NAME} --bootstrap-artifact-source Cache --outbound-type none --network-plugin azure --enable-private-cluster

Intégration au réseau virtuel du serveur d’API

Créez un cluster isolé du réseau configuré avec l’intégration au réseau virtuel de serveur d’API en exécutant la commande az aks create à l’aide des paramètres --bootstrap-artifact-source, --enable-private-cluster, --enable-apiserver-vnet-integration et --outbound-type.

az aks create --resource-group ${RESOURCE_GROUP} --name ${AKS_NAME} --bootstrap-artifact-source Cache --outbound-type none --network-plugin azure --enable-private-cluster --enable-apiserver-vnet-integration

Mettre à jour un cluster AKS existant vers un type isolé du réseau

Si vous préférez activer l’isolation réseau sur un cluster AKS existant au lieu de créer un cluster, utilisez la commande az aks update.

Pour activer la fonctionnalité isolée réseau sur un cluster AKS existant, exécutez d’abord la commande suivante pour mettre à jour bootstrap-artifact-source:

az aks update --resource-group ${RESOURCE_GROUP} --name ${AKS_NAME} --bootstrap-artifact-source Cache

Vous devez ensuite réimager manuellement tous les pools de nœuds existants :

az aks upgrade --resource-group ${RESOURCE_GROUP} --name ${AKS_NAME} --node-image-only

NODEPOOLS=$(az aks nodepool list \
--resource-group "${RESOURCE_GROUP}" \
--cluster-name "${AKS_NAME}" \
--query "[].name" -o tsv)
for NODEPOOL in $NODEPOOLS; do
echo "Waiting for node pool $NODEPOOL to finish upgrading..."
az aks nodepool wait \
--resource-group "${RESOURCE_GROUP}" \
--cluster-name "${AKS_NAME}" \
--name "$NODEPOOL" \
--updated
echo "Node pool $NODEPOOL upgrade succeeded."
done

Attendez et vérifiez que la réimage est terminée, puis exécutez la commande suivante pour mettre à jour outbound-type:

az aks update --resource-group ${RESOURCE_GROUP} --name ${AKS_NAME} --outbound-type none

Déployer un cluster isolé du réseau avec ACR apporté par vous

AKS prend en charge l’apport de votre propre ACR (BYO). Pour prendre en charge le scénario ACR BYO, vous devez configurer un point de terminaison privé ACR et une zone DNS privée avant de créer le cluster AKS.

Les étapes suivantes montrent comment préparer ces ressources :

• Réseau virtuel personnalisé et sous-réseaux pour AKS et ACR.
• ACR, règle de cache ACR, point de terminaison privé et zone DNS privée.
• Identité du plan de contrôle personnalisé et identité kubelet.

Étape 1 : Créer le réseau virtuel et les sous-réseau

az network vnet create  --resource-group ${RESOURCE_GROUP} --name ${VNET_NAME} --address-prefixes 192.168.0.0/16

az network vnet subnet create --name ${AKS_SUBNET_NAME} --vnet-name ${VNET_NAME} --resource-group ${RESOURCE_GROUP} --address-prefixes 192.168.1.0/24

SUBNET_ID=$(az network vnet subnet show --name ${AKS_SUBNET_NAME} --vnet-name ${VNET_NAME} --resource-group ${RESOURCE_GROUP} --query 'id' --output tsv)

az network vnet subnet create --name ${ACR_SUBNET_NAME} --vnet-name ${VNET_NAME} --resource-group ${RESOURCE_GROUP} --address-prefixes 192.168.2.0/24 --private-endpoint-network-policies Disabled

Étape 2 : Désactiver la connectivité sortante du réseau virtuel (facultatif)

Par exemple, rendez le sous-réseau AKS privé en définissant son accès sortant par défaut sur false.

az network vnet subnet update --resource-group ${RESOURCE_GROUP} --vnet-name ${VNET_NAME} --name ${AKS_SUBNET_NAME} --default-outbound false

Pour obtenir d’autres méthodes et considérations de transition prises en charge, consultez Désactiver la connectivité sortante du réseau virtuel.

Étape 3 : Créer l’ACR et activer le cache d’artefacts

1. Créez l’ACR avec un accès réseau public désactivé.

   az acr create --resource-group ${RESOURCE_GROUP} --name ${REGISTRY_NAME} --sku Premium --public-network-enabled false
   
   REGISTRY_ID=$(az acr show --name ${REGISTRY_NAME} -g ${RESOURCE_GROUP}  --query 'id' --output tsv)
   

2. Créez une règle de cache ACR à l’aide de la commande suivante pour permettre aux utilisateurs de mettre en cache des images conteneur MAR et des fichiers binaires dans le nouvel ACR. Le nom de la règle de cache et les noms de dépôt doivent suivre les instructions de la section suivante.

   az acr cache create -n aks-managed-mcr -r ${REGISTRY_NAME} -g ${RESOURCE_GROUP} --source-repo "mcr.microsoft.com/*" --target-repo "aks-managed-repository/*"
   

Étape 4 : Créer un point de terminaison privé pour l’ACR

az network private-endpoint create --name myPrivateEndpoint --resource-group ${RESOURCE_GROUP} --vnet-name ${VNET_NAME} --subnet ${ACR_SUBNET_NAME} --private-connection-resource-id ${REGISTRY_ID} --group-id registry --connection-name myConnection

NETWORK_INTERFACE_ID=$(az network private-endpoint show --name myPrivateEndpoint --resource-group ${RESOURCE_GROUP} --query 'networkInterfaces[0].id' --output tsv)

REGISTRY_PRIVATE_IP=$(az network nic show --ids ${NETWORK_INTERFACE_ID} --query "ipConfigurations[?privateLinkConnectionProperties.requiredMemberName=='registry'].privateIPAddress" --output tsv)

DATA_ENDPOINT_PRIVATE_IP=$(az network nic show --ids ${NETWORK_INTERFACE_ID} --query "ipConfigurations[?privateLinkConnectionProperties.requiredMemberName=='registry_data_$LOCATION'].privateIPAddress" --output tsv)

Étape 5 : Créer une zone DNS privée et ajouter des enregistrements

Créer une zone DNS privée nommée privatelink.azurecr.io. Ajoutez les enregistrements du point de terminaison REST du registre {REGISTRY_NAME}.azurecr.io et le point de terminaison de données du registre {REGISTRY_NAME}.{LOCATION}.data.azurecr.io.

az network private-dns zone create --resource-group ${RESOURCE_GROUP} --name "privatelink.azurecr.io"

az network private-dns link vnet create --resource-group ${RESOURCE_GROUP} --zone-name "privatelink.azurecr.io" --name MyDNSLink --virtual-network ${VNET_NAME} --registration-enabled false

az network private-dns record-set a create --name ${REGISTRY_NAME} --zone-name "privatelink.azurecr.io" --resource-group ${RESOURCE_GROUP}

az network private-dns record-set a add-record --record-set-name ${REGISTRY_NAME} --zone-name "privatelink.azurecr.io" --resource-group ${RESOURCE_GROUP} --ipv4-address ${REGISTRY_PRIVATE_IP}

az network private-dns record-set a create --name ${REGISTRY_NAME}.${LOCATION}.data --zone-name "privatelink.azurecr.io" --resource-group ${RESOURCE_GROUP}

az network private-dns record-set a add-record --record-set-name ${REGISTRY_NAME}.${LOCATION}.data --zone-name "privatelink.azurecr.io" --resource-group ${RESOURCE_GROUP} --ipv4-address ${DATA_ENDPOINT_PRIVATE_IP}

Étape 6 : Créer un plan de contrôle et des identités kubelet

Identité de plan de contrôle

az identity create --name ${CLUSTER_IDENTITY_NAME} --resource-group ${RESOURCE_GROUP}

CLUSTER_IDENTITY_RESOURCE_ID=$(az identity show --name ${CLUSTER_IDENTITY_NAME} --resource-group ${RESOURCE_GROUP} --query 'id' -o tsv)

CLUSTER_IDENTITY_PRINCIPAL_ID=$(az identity show --name ${CLUSTER_IDENTITY_NAME} --resource-group ${RESOURCE_GROUP} --query 'principalId' -o tsv)

Identité Kubelet

az identity create --name ${KUBELET_IDENTITY_NAME} --resource-group ${RESOURCE_GROUP}

KUBELET_IDENTITY_RESOURCE_ID=$(az identity show --name ${KUBELET_IDENTITY_NAME} --resource-group ${RESOURCE_GROUP} --query 'id' -o tsv)

KUBELET_IDENTITY_PRINCIPAL_ID=$(az identity show --name ${KUBELET_IDENTITY_NAME} --resource-group ${RESOURCE_GROUP} --query 'principalId' -o tsv)

Si vous mettez à jour un cluster AKS existant, ignorez les commandes de création d’identité précédentes et récupérez l’ID d’objet d’identité kubelet existant :

KUBELET_IDENTITY_PRINCIPAL_ID=$(az aks show --resource-group ${RESOURCE_GROUP} --name ${AKS_NAME} --query identityProfile.kubeletidentity.objectId -o tsv)

Accorder des autorisations d’extraction ACR à l’identité kubelet

Vérifiez le mode d’autorisations d’attribution de rôle du Registre et sélectionnez le rôle d’extraction correspondant. Les registres compatibles avec ABAC utilisent le rôle Container Registry Repository Reader. Les registres non compatibles avec ABAC utilisent le rôle AcrPull.

ROLE_ASSIGNMENT_MODE=$(az acr show --name ${REGISTRY_NAME} --resource-group ${RESOURCE_GROUP} --query roleAssignmentMode -o tsv)

if [[ "${ROLE_ASSIGNMENT_MODE}" == "rbac-abac" ]]; then
  ACR_PULL_ROLE="Container Registry Repository Reader"
else
  ACR_PULL_ROLE="AcrPull"
fi

az role assignment create --role "${ACR_PULL_ROLE}" --scope ${REGISTRY_ID} --assignee-object-id ${KUBELET_IDENTITY_PRINCIPAL_ID} --assignee-principal-type ServicePrincipal

Après avoir configuré ces ressources, vous pouvez continuer à créer le cluster AKS isolé du réseau avec ACR BYO.

Étape 7 : Créer un cluster isolé réseau à l’aide de BYO ACR

Lorsque vous créez un cluster isolé de réseau, choisissez l’un des modes de cluster privé suivants : intégration de réseau virtuel basé sur des liaisons privées ou du serveur d’API.

Définissez la source d’artefact et le type sortant en fonction de vos exigences d’isolation réseau.

Basé sur un lien privé

Créez un cluster isolé basé sur des liaisons privées qui accède à votre ACR en exécutant la commande az aks create avec les paramètres requis.

az aks create --resource-group ${RESOURCE_GROUP} --name ${AKS_NAME} --vnet-subnet-id ${SUBNET_ID} --assign-identity ${CLUSTER_IDENTITY_RESOURCE_ID} --assign-kubelet-identity ${KUBELET_IDENTITY_RESOURCE_ID} --bootstrap-artifact-source Cache --bootstrap-container-registry-resource-id ${REGISTRY_ID} --outbound-type none --network-plugin azure --enable-private-cluster

Intégration au réseau virtuel du serveur d’API

Pour un cluster isolé réseau configuré avec l’intégration au réseau virtuel du serveur d’API, commencez par créer un sous-réseau et attribuez le rôle approprié avec les commandes suivantes :

az network vnet subnet create --name ${APISERVER_SUBNET_NAME} --vnet-name ${VNET_NAME} --resource-group ${RESOURCE_GROUP} --address-prefixes 192.168.3.0/24 --delegations Microsoft.ContainerService/managedClusters

export APISERVER_SUBNET_ID=$(az network vnet subnet show --resource-group ${RESOURCE_GROUP} --vnet-name ${VNET_NAME} --name ${APISERVER_SUBNET_NAME} --query id -o tsv)

az role assignment create --scope ${APISERVER_SUBNET_ID} --role "Network Contributor" --assignee-object-id ${CLUSTER_IDENTITY_PRINCIPAL_ID} --assignee-principal-type ServicePrincipal

az role assignment create --scope ${SUBNET_ID} --role "Network Contributor" --assignee-object-id ${CLUSTER_IDENTITY_PRINCIPAL_ID} --assignee-principal-type ServicePrincipal

Créez un cluster isolé de réseau privé configuré avec l’intégration au réseau virtuel du serveur d’API et accédez à votre ACR en exécutant la commande az aks create avec les paramètres requis.

az aks create --resource-group ${RESOURCE_GROUP} --name ${AKS_NAME} --vnet-subnet-id ${SUBNET_ID} --assign-identity ${CLUSTER_IDENTITY_RESOURCE_ID} --assign-kubelet-identity ${KUBELET_IDENTITY_RESOURCE_ID} --bootstrap-artifact-source Cache --bootstrap-container-registry-resource-id ${REGISTRY_ID} --outbound-type none --network-plugin azure --enable-private-cluster --enable-apiserver-vnet-integration --apiserver-subnet-id ${APISERVER_SUBNET_ID}

Mettre à jour un cluster AKS existant

Si vous préférez activer l’isolation réseau sur un cluster AKS existant au lieu de créer un cluster, utilisez la commande az aks update.

Lors de la création du point de terminaison privé et de la zone DNS privée pour l’ACR BYO, utilisez le réseau virtuel et les sous-réseaux existants du cluster AKS existant. Lorsque vous attribuez le rôle d’extraction ACR approprié à l’identité kubelet, utilisez l’identité kubelet existante du cluster AKS existant.

Pour activer la fonctionnalité isolée réseau sur un cluster AKS existant, exécutez d’abord la commande suivante pour mettre à jour bootstrap-artifact-source:

az aks update --resource-group ${RESOURCE_GROUP} --name ${AKS_NAME} --bootstrap-artifact-source Cache --bootstrap-container-registry-resource-id ${REGISTRY_ID}

Vous devez ensuite réimager manuellement tous les pools de nœuds existants :

az aks upgrade --resource-group ${RESOURCE_GROUP} --name ${AKS_NAME} --node-image-only

NODEPOOLS=$(az aks nodepool list \
--resource-group "${RESOURCE_GROUP}" \
--cluster-name "${AKS_NAME}" \
--query "[].name" -o tsv)
for NODEPOOL in $NODEPOOLS; do
echo "Waiting for node pool $NODEPOOL to finish upgrading..."
az aks nodepool wait \
--resource-group "${RESOURCE_GROUP}" \
--cluster-name "${AKS_NAME}" \
--name "$NODEPOOL" \
--updated
echo "Node pool $NODEPOOL upgrade succeeded."
done

Attendez et vérifiez que la réimage est terminée, puis exécutez la commande suivante pour mettre à jour outbound-type:

az aks update --resource-group ${RESOURCE_GROUP} --name ${AKS_NAME} --outbound-type none

Mettre à jour votre ID ACR

Vous pouvez mettre à jour l’ACR privé utilisé avec un cluster isolé de réseau. Pour identifier l’ID de ressource ACR, utilisez la commande az aks show.

az aks show --resource-group ${RESOURCE_GROUP} --name ${AKS_NAME}

La mise à jour de l’ID ACR est effectuée en exécutant la commande az aks update avec les paramètres --bootstrap-artifact-source et --bootstrap-container-registry-resource-id.

az aks update --resource-group ${RESOURCE_GROUP} --name ${AKS_NAME} --bootstrap-artifact-source Cache --bootstrap-container-registry-resource-id <new-byo-acr-resource-id>

Lorsque vous mettez à jour l’ID ACR sur un cluster existant, vous devez réimager manuellement tous les nœuds existants.

az aks upgrade --resource-group ${RESOURCE_GROUP} --name ${AKS_NAME} --node-image-only

Déployer un cluster isolé réseau avec Terraform

Cet exemple Terraform déploie un cluster isolé réseau à l’aide de l’option ACR gérée par AKS décrite précédemment dans cet article. Le fournisseur AzureRM n’expose pas encore tous les paramètres de démarrage isolés du réseau que cet exemple utilise. L’exemple utilise donc le fournisseur AzAPI pour déployer la ressource de cluster managé sur la version d’API requise. Un exemple Terraform pour l’option ACR BYO (bring your own) n’est actuellement pas disponible. Pour utiliser BYO ACR, suivez les instructions Azure CLI plus haut dans cet article.

L’exemple déploie les ressources suivantes :

• Un groupe de ressources (Microsoft.Resources/resourceGroups).
• Un cluster AKS isolé sur le réseau (Microsoft.ContainerService/managedClusters) qui utilise :
  • Identité gérée attribuée par le système.
  • Un pool de nœuds système unique avec un Standard_D2s_v3 nœud et une mise à l’échelle automatique désactivées.
  • Le azure plugin réseau, avec outboundType défini sur none afin que le cluster n’ait aucune dépendance au réseau sortant pour l’amorçage.
  • apiServerAccessProfile.enablePrivateCluster défini sur true, ce qui crée un cluster privé basé sur des liaisons privées.
  • bootstrapProfile.artifactSource défini sur Cache, de sorte qu’AKS crée, gère et synchronise son propre cache ACR pour amorcer le cluster au lieu de l’extraire directement depuis Microsoft Artifact Registry (MAR). Comme décrit précédemment dans cet article, vous n’avez pas besoin de créer ou de gérer cet ACR vous-même, et AKS gère les règles de cache, la liaison privée et le point de terminaison privé que le cluster isolé du réseau utilise.

Le cluster est créé avec la version Kubernetes par défaut prise en charge dans la région de déploiement. Pour épingler une version spécifique, ajoutez kubernetesVersion au bloc main.tf du cluster dans properties, et vérifiez que la version est disponible dans la région à l’aide de la commande az aks get-versions.

1. Créez un répertoire pour tester l’exemple de code Terraform et le rendre le répertoire actif.

2. Créez un fichier nommé main.tf et copiez l’exemple de configuration testé suivant.

   terraform {
     required_version = ">= 1.6.0"
   
     required_providers {
       azapi = {
         source  = "Azure/azapi"
         version = "~> 2.0"
       }
       random = {
         source  = "hashicorp/random"
         version = "~> 3.6"
       }
     }
   }
   
   provider "azapi" {}
   
   resource "random_string" "suffix" {
     length  = 6
     upper   = false
     special = false
   }
   
   locals {
     location            = "westus2"
     resource_group_name = "rg-aks-network-isolated-${random_string.suffix.result}"
     aks_name            = "aks-netisolated-${random_string.suffix.result}"
     dns_prefix          = "aksnetiso${random_string.suffix.result}"
   }
   
   resource "azapi_resource" "resource_group" {
     type     = "Microsoft.Resources/resourceGroups@2024-03-01"
     name     = local.resource_group_name
     location = local.location
   }
   
   resource "azapi_resource" "aks_cluster" {
     type      = "Microsoft.ContainerService/managedClusters@2025-08-01"
     name      = local.aks_name
     parent_id = azapi_resource.resource_group.id
     location  = local.location
   
     identity {
       type = "SystemAssigned"
     }
   
     body = {
       properties = {
         dnsPrefix = local.dns_prefix
         agentPoolProfiles = [
           {
             name              = "systempool"
             count             = 1
             vmSize            = "Standard_D2s_v3"
             mode              = "System"
             osType            = "Linux"
             type              = "VirtualMachineScaleSets"
             enableAutoScaling = false
           }
         ]
         networkProfile = {
           networkPlugin = "azure"
           outboundType  = "none"
         }
         apiServerAccessProfile = {
           enablePrivateCluster = true
         }
         bootstrapProfile = {
           artifactSource = "Cache"
         }
       }
     }
   }
   

Initialisez Terraform

Exécutez terraform init pour initialiser le déploiement Terraform. Cette commande télécharge les fournisseurs random et azapi nécessaires pour gérer les ressources dans cet exemple.

terraform init -upgrade

Mettre en forme et valider la configuration

Exécutez terraform fmt pour mettre en forme le fichier de configuration et terraform validate confirmer que la configuration est valide de manière syntactique.

terraform fmt
terraform validate

Créer un plan d’exécution Terraform

Exécutez terraform plan pour créer un plan d’exécution.

terraform plan -out main.tfplan

Appliquer un plan d’exécution Terraform

Exécutez terraform apply pour appliquer le plan d’exécution à votre abonnement Azure.

terraform apply main.tfplan

La création du groupe de ressources et du cluster AKS privé isolé par réseau prend plusieurs minutes.

Vérifier le déploiement

Cet exemple ne définit pas les sorties Terraform. Par conséquent, utilisez-le terraform show -jsonjq pour récupérer le groupe de ressources généré et les noms de cluster à partir de l’état de la ressource une fois terraform apply l’opération terminée. Vous gérez les deux ressources avec le azapi fournisseur et leur name attribut contient le nom de la ressource résolue.

RESOURCE_GROUP=$(terraform show -json | jq -r '.values.root_module.resources[] | select(.address=="azapi_resource.resource_group") | .values.name')
AKS_NAME=$(terraform show -json | jq -r '.values.root_module.resources[] | select(.address=="azapi_resource.aks_cluster") | .values.name')

Vérifiez que le cluster a été créé avec les paramètres isolés du réseau attendus à l’aide de la az aks show commande.

az aks show --resource-group $RESOURCE_GROUP --name $AKS_NAME --query "{outboundType:networkProfile.outboundType, artifactSource:bootstrapProfile.artifactSource, privateCluster:apiServerAccessProfile.enablePrivateCluster}"

La sortie indique outboundType définie sur none, artifactSource définie sur Cache et privateCluster définie sur true, confirmant que le cluster est isolé du réseau et s’amorce depuis le cache ACR géré par AKS.

Se connecter au cluster

Comme il s’agit d’un cluster privé, connectez-vous depuis un client qui dispose d’une visibilité réseau sur le point de terminaison privé du cluster, par exemple une machine virtuelle située dans le même réseau virtuel ou dans un réseau virtuel appairé, ou Azure Cloud Shell s’il est connecté au réseau virtuel du cluster. Obtenez les informations d’identification du cluster à l’aide de la az aks get-credentials commande, puis vérifiez la connexion à l’aide de la kubectl get nodes commande.

az aks get-credentials --resource-group $RESOURCE_GROUP --name $AKS_NAME
kubectl get nodes

Nettoyer les ressources

Si vous n’avez plus besoin des ressources créées dans cet article, supprimez-les pour éviter les frais supplémentaires.

Exécutez terraform plan avec l’indicateur -destroy pour vérifier ce que Terraform supprime.

terraform plan -destroy -out main.destroy.tfplan

Exécutez terraform apply pour appliquer le plan de destruction et supprimer toutes les ressources créées par cet exemple.

terraform apply main.destroy.tfplan