Partager via

Créer un cluster de Azure Kubernetes Service (AKS) privé

Cet article vous aide à déployer un cluster AKS basé sur des liaisons privées à l’aide de Azure CLI ou Terraform. Si vous souhaitez créer un cluster AKS sans liaison privée ou tunnel requis, consultez Créer un cluster Azure Kubernetes Service (AKS) avec l'intégration au réseau virtuel du serveur d'API.

Vue d’ensemble des clusters privés dans AKS

Dans un cluster privé, le plan de contrôle ou le serveur d’API a des adresses IP internes définies dans le document RFC1918 - Allocation d’adresses pour le document Internet privé . En utilisant un cluster privé, vous pouvez vous assurer que le trafic réseau entre votre serveur d’API et vos pools de nœuds reste uniquement sur le réseau privé.

Le plan de contrôle ou le serveur d’API se trouve dans un groupe de ressources Azure géré par AKS, et votre cluster ou pool de nœuds se trouve dans votre groupe de ressources. Le serveur et le pool de nœuds peuvent communiquer entre eux via le service Azure Private Link dans le réseau virtuel du serveur d’API et un point de terminaison privé exposé sur le sous-réseau de votre cluster AKS.

Lorsque vous créez un cluster AKS privé, AKS crée des noms de domaine complets privés et publics (FQDN) avec des zones DNS correspondantes par défaut. Pour obtenir des options de configuration DNS détaillées, consultez Configurer une zone DNS privée, une sous-zone DNS privée ou un sous-domaine personnalisé.

Disponibilité des régions

Les clusters privés sont disponibles dans les régions publiques, les régions Azure Government et les régions de Microsoft Azure exploitées par 21Vianet où AKS est pris en charge.

Important

Toutes les fonctionnalités de Microsoft Defender for Cloud seront officiellement retirées dans la Azure dans la région de Chine le 18 août 2026. En raison de cette mise hors service à venir, Azure clients chinois ne peuvent plus intégrer de nouveaux abonnements au service. Un nouvel abonnement est tout abonnement qui n’a pas déjà été intégré au service Microsoft Defender for Cloud avant le 18 août 2025, date de l’annonce de mise hors service. Pour plus d’informations sur ce retrait, consultez l’annonce Retrait de Microsoft Defender for Cloud dans Microsoft Azure opéré par 21Vianet.

Les clients doivent collaborer avec leurs représentants de comptes pour Microsoft Azure gérés par 21Vianet pour évaluer l’impact de cette retraite sur leurs propres opérations.

Conditions préalables pour les clusters AKS privés

  • Terraform installé localement. Pour obtenir des instructions d’installation, consultez Installer Terraform.

Important

À compter de November 30, 2025, Azure Kubernetes Service (AKS) ne prend plus en charge ni ne fournit plus de mises à jour de sécurité pour Azure Linux 2.0. L’image de nœud Azure Linux 2.0 est verrouillée sur la version 202512.06.0. À compter du 31 mars 2026, les images de nœud seront supprimées et vous ne pourrez pas mettre à l’échelle vos pools de nœuds. Migrez vers une version Azure Linux prise en charge en mettant à niveau vos pools de nœuds vers une version de Kubernetes prise en charge ou en migrant vers osSku AzureLinux3. Pour plus d'informations, consultez le problème de retrait sur GitHub et l'annonce de la mise hors service des mises à jour Azure. Pour rester informé des annonces et des mises à jour, suivez les notes de publication AKS.

Limites

  • Les plages d’adresses IP autorisées s’appliquent uniquement au serveur d’API public. Vous ne pouvez pas appliquer ces plages au point de terminaison du serveur d’API privé.
  • Les limitations du service Azure Private Link s’appliquent aux clusters privés.
  • Il n'existe aucune prise en charge des agents hébergés par Azure DevOps Microsoft avec des clusters privés. Envisagez d’utiliser des agents auto-hébergés.
  • La suppression ou la modification du point de terminaison privé dans le sous-réseau du client entraîne l’arrêt du cluster.
  • Azure Private Link service est pris en charge uniquement sur les Azure Load Balancer Standard. Le Azure Load Balancer de base n'est pas pris en charge.

Hub and spoke avec DNS personnalisée pour les clusters AKS privés

les architectures Hub et spoke sont couramment utilisées pour déployer des réseaux dans Azure. Dans la plupart de ces déploiements, les paramètres DNS dans les réseaux virtuels spoke sont configurés pour référencer un redirecteur DNS central afin d’autoriser la résolution DNS locale et basée sur Azure.

Le diagramme suivant illustre une architecture hub-and-spoke pour un cluster AKS privé avec dns personnalisé :

Hub-and-spoke de cluster privé

  • Lorsqu’un cluster privé est créé, un point de terminaison privé (1) et une zone DNS privée (2) sont créés dans le groupe de ressources géré par cluster par défaut. Le cluster utilise un enregistrement A dans la zone privée pour résoudre l’adresse IP du point de terminaison privé pour la communication avec le serveur d’API.
  • La zone DNS privée est liée uniquement au réseau virtuel auquel les nœuds de cluster sont attachés (3), ce qui signifie que le point de terminaison privé ne peut être résolu que par les hôtes de ce réseau virtuel lié. Dans les scénarios où aucun DNS personnalisé n'est configuré sur le réseau virtuel (par défaut), cela fonctionne sans problème car les hôtes pointent vers 168.63.129.16 pour le DNS qui peut résoudre les enregistrements dans la zone DNS privée grâce à la connexion.
  • Si vous conservez le comportement de zone DNS privée par défaut, AKS tente de lier la zone directement au réseau virtuel spoke qui héberge le cluster même si la zone est déjà liée à un réseau virtuel hub.
    • Dans les réseaux virtuels spoke qui utilisent des serveurs DNS personnalisés, cette action peut échouer si l’identité managée du cluster ne dispose pas du contributeur réseau sur le réseau virtuel spoke. Pour éviter l’échec, choisissez l’une des configurations prises en charge suivantes :
      • Zone DNS privée personnalisée : fournissez une zone privée existante et définissez privateDNSZone / --private-dns-zone son ID de ressource. Liez cette zone au réseau virtuel approprié (par exemple, le réseau virtuel hub) et définissez publicDNS à false / utiliser --disable-public-fqdn.
      • DNS public uniquement : désactivez la création de zone privée en définissant privateDNSZone / --private-dns-zonesur noneet en laissant publicDNS à sa valeur par défaut (true) / n’utilisez --disable-public-fqdnpas .
  • Si vous utilisez votre propre table de routage (BYO) avec kubenet et votre propre DNS avec des clusters privés, la création du cluster échoue. Vous devez associer RouteTable dans le groupe de ressources du nœud au sous-réseau après l’échec de la création du cluster afin que la création réussisse.

Limitations pour les clusters AKS privés avec dns personnalisé

  • La configuration de privateDNSZone / --private-dns-zone sur noneetpublicDNS: false / --disable-public-fqdn en même temps n’est pas pris en charge.
  • Le transfert conditionnel ne prend pas en charge les sous-domaines.

Créer un groupe de ressources

Créez un groupe de ressources à l’aide de la commande az group create. Vous pouvez également utiliser un groupe de ressources existant pour votre cluster AKS.

az group create \
    --name <private-cluster-resource-group> \
    --location <location>

Créer un cluster AKS privé avec mise en réseau de base par défaut

Créez un cluster privé avec la mise en réseau de base par défaut à l’aide de la commande az aks create avec l’indicateur --enable-private-cluster.

Paramètres clés dans cette commande :

  • --enable-private-cluster: active le mode de cluster privé.
az aks create \
    --name <private-cluster-name> \
    --resource-group <private-cluster-resource-group> \
    --load-balancer-sku standard \
    --enable-private-cluster \
    --generate-ssh-keys

  1. Créez un fichier nommé main.tf et ajoutez le code suivant pour définir la version Terraform et spécifier le fournisseur Azure :

    terraform {
  required_version = ">= 1.3.0"
  required_providers {
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "~> 4.0"
    }
  }
}

provider "azurerm" {
  features {}
  subscription_id = var.subscription_id
}

  2. Ajoutez le code suivant à main.tf pour créer des variables d’entrée pour votre ID d’abonnement Azure, le nom du groupe de ressources, l’emplacement et le nom du cluster AKS. Vous pouvez modifier les valeurs par défaut en fonction des besoins.

    variable "subscription_id" {
  description = "The Azure subscription ID."
  type = string
}

variable "resource_group_name" {
  description = "The name of the resource group for the AKS cluster."
  type        = string
  default     = "rg-private-aks-basic"
}

variable "location" {
  description = "The Azure region where the resources will be created."
  type        = string
  default     = "eastus"
}

variable "aks_cluster_name" {
  description = "The name of the AKS cluster."
  type        = string
  default     = "aks-private-basic"
}

  3. Ajoutez le code suivant à main.tf pour créer un groupe de ressources Azure :

    resource "azurerm_resource_group" "this" {
  name     = var.resource_group_name
  location = var.location
}

  4. Ajoutez le code suivant à main.tf pour créer un cluster AKS privé avec une mise en réseau de base :

    resource "azurerm_kubernetes_cluster" "this" {
  name                = var.aks_cluster_name
  location            = azurerm_resource_group.this.location
  resource_group_name = azurerm_resource_group.this.name
  dns_prefix          = "privatebasicaks"

  private_cluster_enabled = true

  default_node_pool {
    name       = "system"
    node_count = 1
    vm_size    = "Standard_DS2_v2"
  }

  identity {
    type = "SystemAssigned"
  }

  network_profile {
    load_balancer_sku = "standard"
    network_plugin    = "kubenet"
  }
}

  5. Suivez les étapes pour initialiser Terraform, mettre en forme et valider la configuration Terraform, créer un plan d’exécution Terraform, appliquer la configuration Terraform et se connecter au cluster AKS.

Créer un cluster AKS privé avec mise en réseau avancée

Créez un cluster privé avec une mise en réseau avancée à l’aide de la az aks create commande.

Paramètres clés dans cette commande :

  • --enable-private-cluster: active le mode de cluster privé.
  • --network-plugin azure : spécifie le plug-in de mise en réseau CNI Azure.
  • --vnet-subnet-id <subnet-id>: ID de ressource d’un sous-réseau existant dans un réseau virtuel.
  • --dns-service-ip <dns-service-ip>: adresse IP disponible dans la plage d’adresses du service Kubernetes à utiliser pour le service DNS de cluster. Par exemple : 10.2.0.10.
  • --service-cidr <service-cidr>: plage d’adresses IP de notation CIDR à partir de laquelle attribuer des adresses IP de cluster de service. Par exemple : 10.2.0.0/24.
az aks create \
    --resource-group <private-cluster-resource-group> \
    --name <private-cluster-name> \
    --load-balancer-sku standard \
    --enable-private-cluster \
    --network-plugin azure \
    --vnet-subnet-id <subnet-id> \
    --dns-service-ip <dns-service-ip> \
    --service-cidr <service-cidr> \
    --generate-ssh-keys

  1. Créez un fichier nommé main.tf et ajoutez le code suivant pour définir la version Terraform et spécifier le fournisseur Azure :

    terraform {
  required_version = ">= 1.3.0"
  required_providers {
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "~> 4.0"
    }
  }
}

provider "azurerm" {
  features {}
  subscription_id = var.subscription_id
}

  2. Ajoutez le code suivant à main.tf pour créer des variables d’entrée pour votre ID d’abonnement Azure, le nom du groupe de ressources, l’emplacement, le nom du cluster AKS, le nom du réseau virtuel et le nom du sous-réseau. Vous pouvez modifier les valeurs par défaut en fonction des besoins.

    variable "subscription_id" {
  description = "The Azure subscription ID."
  type = string
}

variable "resource_group_name" {
  description = "The name of the resource group for the AKS cluster."
  type = string
  default = "rg-private-aks-advanced"
}

variable "location" {
  description = "The Azure region where the resources will be created."
  type = string
  default = "eastus"
}

variable "aks_cluster_name" {
  description = "The name of the AKS cluster."
  type = string
  default = "aks-private-advanced"
}

variable "vnet_name" {
  description = "The name of the virtual network."
  type = string
  default = "vnet-private-aks"
}

variable "subnet_name" {
  description = "The name of the subnet used by AKS."
  type = string
  default = "snet-aks"
}

  3. Ajoutez le code suivant à main.tf pour créer un groupe de ressources, un réseau virtuel et un sous-réseau Azure :

    resource "azurerm_resource_group" "this" {
  name = var.resource_group_name
  location = var.location
}

resource "azurerm_virtual_network" "this" {
  name = var.vnet_name
  location = azurerm_resource_group.this.location
  resource_group_name = azurerm_resource_group.this.name
  address_space = ["10.0.0.0/8"]
}

resource "azurerm_subnet" "aks" {
  name = var.subnet_name
  resource_group_name  = azurerm_resource_group.this.name
  virtual_network_name = azurerm_virtual_network.this.name
  address_prefixes = ["10.240.0.0/16"]
}

  4. Ajoutez le code suivant à main.tf pour créer le cluster AKS avec une mise en réseau avancée :

    resource "azurerm_kubernetes_cluster" "this" {
  name = var.aks_cluster_name
  location = azurerm_resource_group.this.location
  resource_group_name = azurerm_resource_group.this.name
  dns_prefix = "privateadvancedaks"

  private_cluster_enabled = true

  default_node_pool {
    name = "system"
    node_count = 1
    vm_size = "Standard_DS2_v2"
    vnet_subnet_id = azurerm_subnet.aks.id
  }

  identity {
    type = "SystemAssigned"
  }

  network_profile {
    load_balancer_sku = "standard"
    network_plugin = "azure"
    dns_service_ip = "10.2.0.10"
    service_cidr = "10.2.0.0/24"
  }
}

  5. Suivez les étapes pour initialiser Terraform, mettre en forme et valider la configuration Terraform, créer un plan d’exécution Terraform, appliquer la configuration Terraform et se connecter au cluster AKS.

Utiliser des domaines personnalisés avec des clusters AKS privés

Si vous souhaitez configurer des domaines personnalisés qui ne peuvent être résolus qu’en interne, consultez Utiliser des domaines personnalisés.

Désactiver un nom de domaine complet public sur un cluster AKS privé

Désactiver un nom de domaine complet public sur un nouveau cluster

Désactivez un nom de domaine complet public lors de la création d’un cluster AKS privé à l’aide de la commande az aks create avec l’indicateur --disable-public-fqdn.

Paramètres clés dans cette commande :

  • --disable-public-fqdn: désactive le nom de domaine complet public (FQDN) pour le serveur d’API.
  • --assign-identity <resource-id>: spécifie l’identité managée à utiliser pour le cluster.
  • --private-dns-zone [system|none]: spécifie la zone DNS privée à utiliser pour le cluster. system est la valeur par défaut lors de la configuration d’une zone DNS privée. Si vous omettez --private-dns-zone, AKS crée une zone DNS privée dans le groupe de ressources de nœud. none désactive la création d’une zone DNS privée.
az aks create \
    --name <private-cluster-name> \
    --resource-group <private-cluster-resource-group> \
    --load-balancer-sku standard \
    --enable-private-cluster \
    --assign-identity <resource-id> \
    --private-dns-zone [system|none] \
    --disable-public-fqdn \
    --generate-ssh-keys

  1. Suivez les étapes 1 à 3 dans Créer un cluster AKS privé avec mise en réseau avancée ou créez un cluster AKS privé avec mise en réseau de base par défaut pour configurer la configuration Terraform et créer les ressources nécessaires en fonction de votre scénario. Cet exemple utilise la mise en réseau avancée.

  2. Ajoutez le code suivant à main.tf pour créer un cluster AKS privé avec une identité attribuée par l'utilisateur et le FQDN public désactivé :

    resource "azurerm_user_assigned_identity" "aks" {
  name = "id-private-aks-public-fqdn-off"
  location = azurerm_resource_group.this.location
  resource_group_name = azurerm_resource_group.this.name
}
resource "azurerm_kubernetes_cluster" "this" {
  name = var.aks_cluster_name
  location = azurerm_resource_group.this.location
  resource_group_name = azurerm_resource_group.this.name
  dns_prefix = "privateaks"
  private_cluster_enabled = true
  private_cluster_public_fqdn_enabled = false

  private_dns_zone_id = "System"

  default_node_pool {
    name = "system"
    node_count = 1
    vm_size = "Standard_DS2_v2"
    vnet_subnet_id = azurerm_subnet.aks.id
  }
  identity {
    type = "UserAssigned"
    identity_ids = [azurerm_user_assigned_identity.aks.id]
  }
  network_profile {
    load_balancer_sku = "standard"
    network_plugin = "azure"
    dns_service_ip = "10.2.0.10"
    service_cidr = "10.2.0.0/24"
  }
}

  3. Suivez les étapes pour initialiser Terraform, mettre en forme et valider la configuration Terraform, créer un plan d’exécution Terraform, appliquer la configuration Terraform et se connecter au cluster AKS.

Désactiver un FQDN public sur un cluster existant

Désactivez un FQDN public sur un cluster AKS existant à l’aide de la commande az aks update avec l’indicateur --disable-public-fqdn.

Paramètres clés dans cette commande :

  • --disable-public-fqdn: désactive le nom de domaine complet public (FQDN) pour le serveur d’API.
az aks update \
    --name <private-cluster-name> \
    --resource-group <private-cluster-resource-group> \
    --disable-public-fqdn

  1. Ajoutez le code suivant à l’existant main.tf pour désactiver le nom de domaine complet public sur un cluster AKS existant. Cet exemple utilise la mise en réseau avancée. Vous pouvez le modifier pour utiliser la mise en réseau de base par défaut en modifiant les ressources et paramètres Terraform pertinents.

    resource "azurerm_kubernetes_cluster" "this" {
  name = var.aks_cluster_name
  location = azurerm_resource_group.this.location
  resource_group_name = azurerm_resource_group.this.name
  dns_prefix = "privateaks"

  private_cluster_enabled = true
  private_cluster_public_fqdn_enabled = false
  private_dns_zone_id = "System"

  default_node_pool {
    name = "system"
    node_count = 1
    vm_size = "Standard_DS2_v2"
    vnet_subnet_id = azurerm_subnet.aks.id
  }

  identity {
    type = "UserAssigned"
    identity_ids = [azurerm_user_assigned_identity.aks.id]
  }

  network_profile {
    load_balancer_sku = "standard"
    network_plugin = "azure"
    dns_service_ip = "10.2.0.10"
    service_cidr = "10.2.0.0/24"
  }
}

  2. Appliquez la configuration Terraform mise à jour à l’aide des commandes terraform plan et terraform apply.

    terraform plan
terraform apply

Options de configuration pour dns privé

Vous pouvez configurer des paramètres DNS privés pour un cluster AKS privé à l’aide du Azure CLI (avec le paramètre --private-dns-zone) ou d’un modèle Azure Resource Manager (ARM) (avec la propriété privateDNSZone). Le tableau suivant présente les options disponibles pour le --private-dns-zone paramètre/ privateDNSZone propriété :

Réglage Descriptif
system Valeur par défaut lors de la configuration d’une zone DNS privée. Si vous omettez --private-dns-zone / privateDNSZone, AKS crée une zone DNS privée dans le groupe de ressources de nœud.
none Si vous définissez --private-dns-zone / privateDNSZone sur none, AKS ne crée pas de zone DNS privée.
<custom-private-dns-zone-resource-id> Pour utiliser ce paramètre, vous devez créer une zone DNS privée au format suivant pour Azure cloud global : privatelink.<region>.azmk8s.io ou <subzone>.privatelink.<region>.azmk8s.io. Vous avez besoin de l’ID de ressource de la zone DNS privée pour une utilisation ultérieure. Vous avez également besoin d'une identité attribuée par l'utilisateur ou d'un principal de service avec les rôles Contributeur de zone DNS privée et Contributeur réseau. Pour les clusters utilisant l’intégration au réseau virtuel du serveur d’API, une zone DNS privée prend en charge le format de nommage de private.<region>.azmk8s.io ou <subzone>.private.<region>.azmk8s.io. Vous ne pouvez pas modifier ou supprimer ces ressources après avoir créé le cluster, car cela peut entraîner des problèmes de performances et des échecs de mise à niveau de cluster. Vous pouvez utiliser --fqdn-subdomain <subdomain> avec<custom-private-dns-zone-resource-id> uniquement pour fournir des fonctionnalités de sous-domaine à privatelink.<region>.azmk8s.io. Si vous spécifiez une sous-zone, il existe une limite de 32 caractères pour le <subzone> nom.

Considérations relatives au DNS privé

Gardez à l’esprit les considérations suivantes lors de la configuration du DNS privé pour un cluster AKS privé :

  • Si la zone DNS privée se trouve dans un autre abonnement que le cluster AKS, vous devez inscrire le fournisseur Microsoft.ContainerService Azure dans les deux abonnements.
  • Si votre cluster AKS est configuré avec un principal de service Active Directory, AKS ne prend pas en charge l'utilisation d'une identité managée affectée par le système avec une zone DNS privée personnalisée. Le cluster doit utiliser l’authentification par identité managée déléguée à l’utilisateur.

Créer un cluster AKS privé avec une zone DNS privée

Créez un cluster AKS privé avec une zone DNS privée à l’aide de la az aks create commande.

Paramètres clés dans cette commande :

  • --enable-private-cluster: active le mode de cluster privé.
  • --private-dns-zone [system|none]: configure la zone DNS privée pour le cluster. system est la valeur par défaut lors de la configuration d’une zone DNS privée. Si vous omettez --private-dns-zone, AKS crée une zone DNS privée dans le groupe de ressources de nœud. none désactive la création d’une zone DNS privée.
  • --assign-identity <resource-id> : ID de ressource d'une identité managée affectée par l'utilisateur avec les rôles de Contributeur de la zone DNS privée et de Contributeur réseau.
az aks create \
    --name <private-cluster-name> \
    --resource-group <private-cluster-resource-group> \
    --load-balancer-sku standard \
    --enable-private-cluster \
    --assign-identity <resource-id> \
    --private-dns-zone [system|none] \
    --generate-ssh-keys

  1. Suivez les étapes 1 à 3 dans Créer un cluster AKS privé avec mise en réseau avancée ou créez un cluster AKS privé avec mise en réseau de base par défaut pour configurer la configuration Terraform et créer les ressources nécessaires en fonction de votre scénario. Cet exemple utilise la mise en réseau avancée.

  2. Ajoutez le code suivant pour main.tf créer un cluster AKS privé avec une zone DNS privée gérée par AKS :

    resource "azurerm_kubernetes_cluster" "this" {
 name                = var.aks_cluster_name
 location            = azurerm_resource_group.this.location
 resource_group_name = azurerm_resource_group.this.name
 dns_prefix          = "aks-system-dns"
 private_cluster_enabled = true
 private_dns_zone_id     = "System"
 default_node_pool {
   name           = "system"
   node_count     = 1
   vm_size        = "Standard_DS2_v2"
   vnet_subnet_id = azurerm_subnet.aks.id
 }
 identity {
   type = "SystemAssigned"
 }
 network_profile {
   network_plugin    = "azure"
   load_balancer_sku = "standard"
   dns_service_ip    = "10.2.0.10"
   service_cidr      = "10.2.0.0/24"
 }
}

  3. Suivez les étapes pour initialiser Terraform, mettre en forme et valider la configuration Terraform, créer un plan d’exécution Terraform, appliquer la configuration Terraform et se connecter au cluster AKS.

Créer un cluster AKS privé sans zone DNS privée

  1. Suivez les étapes 1 à 3 dans Créer un cluster AKS privé avec mise en réseau avancée ou créez un cluster AKS privé avec mise en réseau de base par défaut pour configurer la configuration Terraform et créer les ressources nécessaires en fonction de votre scénario. Cet exemple utilise la mise en réseau avancée.

  2. Ajoutez le code suivant à main.tf pour créer le cluster AKS sans zone DNS privée.

    resource "azurerm_kubernetes_cluster" "this" {
 name                = var.aks_cluster_name
 location            = azurerm_resource_group.this.location
 resource_group_name = azurerm_resource_group.this.name
 dns_prefix          = "aks-no-dns"
 private_cluster_enabled = true
 private_dns_zone_id     = "None"
 default_node_pool {
   name           = "system"
   node_count     = 1
   vm_size        = "Standard_DS2_v2"
   vnet_subnet_id = azurerm_subnet.aks.id
 }
 identity {
   type = "SystemAssigned"
 }
 network_profile {
   network_plugin    = "azure"
   load_balancer_sku = "standard"
   dns_service_ip    = "10.2.0.10"
   service_cidr      = "10.2.0.0/24"
 }
}

  3. Suivez les étapes pour initialiser Terraform, mettre en forme et valider la configuration Terraform, créer un plan d’exécution Terraform, appliquer la configuration Terraform et se connecter au cluster AKS.

Créer un cluster AKS privé avec une zone ou une sous-zone DNS privée personnalisée

Créez un cluster AKS privé avec une zone DNS privée personnalisée ou une sous-zone à l’aide de la az aks create commande.

Paramètres clés dans cette commande :

  • --enable-private-cluster: active le mode de cluster privé.
  • --private-dns-zone [<custom-private-dns-zone-resource-id>|<custom-private-dns-subzone-resource-id>] : ID de ressource d’une zone DNS privée ou sous-zone existante au format suivant pour Azure cloud global : privatelink.<region>.azmk8s.io ou <subzone>.privatelink.<region>.azmk8s.io.
  • --assign-identity <resource-id> : ID de ressource d'une identité managée affectée par l'utilisateur avec les rôles de Contributeur de la zone DNS privée et de Contributeur réseau.
az aks create \
    --name <private-cluster-name> \
    --resource-group <private-cluster-resource-group> \
    --load-balancer-sku standard \
    --enable-private-cluster \
    --assign-identity <resource-id> \
    --private-dns-zone [<custom-private-dns-zone-resource-id>|<custom-private-dns-subzone-resource-id>] \
    --generate-ssh-keys

Lorsque vous utilisez une zone DNS privée personnalisée, vous êtes responsable de la création et de la gestion de l'infrastructure DNS au lieu de vous appuyer sur un DNS géré par Azure. Cela inclut la création de la zone DNS, la liaison à votre réseau virtuel et l’attribution des autorisations nécessaires pour AKS pour gérer les enregistrements.

Pour les configurations DNS personnalisées, vous devez utiliser une identité managée affectée par l’utilisateur avec les rôles contributeur de zone DNS privé et Network Contributor.

  1. Suivez les étapes 1 à 3 dans Créer un cluster AKS privé avec mise en réseau avancée ou créez un cluster AKS privé avec mise en réseau de base par défaut pour configurer la configuration Terraform et créer les ressources nécessaires en fonction de votre scénario. Cet exemple utilise la mise en réseau avancée.

  2. Ajoutez le code à main.tf pour créer un cluster AKS privé avec une zone DNS privée personnalisée ou une sous-zone :

    resource "azurerm_user_assigned_identity" "aks" {
 name                = "aks-custom-dns-id"
 location            = azurerm_resource_group.this.location
 resource_group_name = azurerm_resource_group.this.name
}
resource "azurerm_private_dns_zone" "aks" {
 name                = "privatelink.eastus.azmk8s.io"
 resource_group_name = azurerm_resource_group.this.name
}
resource "azurerm_private_dns_zone_virtual_network_link" "link" {
 name                  = "aks-dns-link"
 resource_group_name   = azurerm_resource_group.this.name
 private_dns_zone_name = azurerm_private_dns_zone.aks.name
 virtual_network_id    = azurerm_virtual_network.this.id
}
resource "azurerm_role_assignment" "dns" {
 scope                = azurerm_private_dns_zone.aks.id
 role_definition_name = "Private DNS Zone Contributor"
 principal_id         = azurerm_user_assigned_identity.aks.principal_id
}
resource "azurerm_role_assignment" "network" {
 scope                = azurerm_virtual_network.this.id
 role_definition_name = "Network Contributor"
 principal_id         = azurerm_user_assigned_identity.aks.principal_id
}
resource "azurerm_kubernetes_cluster" "this" {
 name                = var.aks_cluster_name
 location            = azurerm_resource_group.this.location
 resource_group_name = azurerm_resource_group.this.name
 dns_prefix          = "aks-custom-dns"
 private_cluster_enabled = true
 private_dns_zone_id     = azurerm_private_dns_zone.aks.id
 default_node_pool {
   name           = "system"
   node_count     = 1
   vm_size        = "Standard_DS2_v2"
   vnet_subnet_id = azurerm_subnet.aks.id
 }
 identity {
   type         = "UserAssigned"
   identity_ids = [azurerm_user_assigned_identity.aks.id]
 }
 network_profile {
   network_plugin    = "azure"
   load_balancer_sku = "standard"
   dns_service_ip    = "10.2.0.10"
   service_cidr      = "10.2.0.0/24"
 }
 depends_on = [
   azurerm_role_assignment.dns,
   azurerm_role_assignment.network
 ]
}

  3. Suivez les étapes pour initialiser Terraform, mettre en forme et valider la configuration Terraform, créer un plan d’exécution Terraform, appliquer la configuration Terraform et se connecter au cluster AKS.

Créer un cluster AKS privé avec une zone DNS privée personnalisée et un sous-domaine personnalisé

Créez un cluster AKS privé avec une zone DNS privée personnalisée et un sous-domaine à l’aide de la az aks create commande.

Paramètres clés dans cette commande :

  • --enable-private-cluster: active le mode de cluster privé.
  • --private-dns-zone <custom-private-dns-zone-resource-id> : ID de ressource d’une zone DNS privée existante au format suivant pour Azure cloud global : privatelink.<region>.azmk8s.io.
  • --fqdn-subdomain <subdomain> : le sous-domaine à utiliser pour le FQDN du cluster dans la zone DNS privée personnalisée.
  • --assign-identity <resource-id> : ID de ressource d'une identité managée affectée par l'utilisateur avec les rôles de Contributeur de la zone DNS privée et de Contributeur réseau.
az aks create \
    --name <private-cluster-name> \
    --resource-group <private-cluster-resource-group> \
    --load-balancer-sku standard \
    --enable-private-cluster \
    --assign-identity <resource-id> \
    --private-dns-zone <custom-private-dns-zone-resource-id> \
    --fqdn-subdomain <subdomain> \
    --generate-ssh-keys

  1. Suivez les étapes 1 à 3 dans Créer un cluster AKS privé avec mise en réseau avancée ou créez un cluster AKS privé avec mise en réseau de base par défaut pour configurer la configuration Terraform et créer les ressources nécessaires en fonction de votre scénario. Cet exemple utilise la mise en réseau avancée.

  2. Ajoutez le code suivant pour main.tf créer un cluster AKS privé avec une zone DNS privée personnalisée et un sous-domaine :

    resource "azurerm_kubernetes_cluster" "this" {
 name                = var.aks_cluster_name
 location            = azurerm_resource_group.this.location
 resource_group_name = azurerm_resource_group.this.name
 dns_prefix          = "aks-subdomain"
 private_cluster_enabled = true
 private_dns_zone_id     = azurerm_private_dns_zone.aks.id
 fqdn_subdomain          = "team1"
 default_node_pool {
   name           = "system"
   node_count     = 1
   vm_size        = "Standard_DS2_v2"
   vnet_subnet_id = azurerm_subnet.aks.id
 }
 identity {
   type         = "UserAssigned"
   identity_ids = [azurerm_user_assigned_identity.aks.id]
 }
 network_profile {
   network_plugin    = "azure"
   load_balancer_sku = "standard"
   dns_service_ip    = "10.2.0.10"
   service_cidr      = "10.2.0.0/24"
 }
}

  3. Suivez les étapes pour initialiser Terraform, mettre en forme et valider la configuration Terraform, créer un plan d’exécution Terraform, appliquer la configuration Terraform et se connecter au cluster AKS.

Mettre à jour un cluster AKS privé existant à partir d’une zone DNS privée vers public

Vous pouvez uniquement effectuer une mise à jour à partir de byo (apportez votre propre) ou system vers none. Aucune autre combinaison de valeurs de mise à jour n’est prise en charge.

Avertissement

Lorsque vous mettez à jour un cluster privé de byo ou system vers none, les nœuds de l’agent changent pour utiliser un nom de domaine complet public. Dans un cluster AKS qui utilise Groupes de machines virtuelles identiques Azure, une mise à niveau de l'image de nœud est effectuée pour mettre à jour vos nœuds avec le nom de domaine complet (FQDN) public.

Mettez à jour un cluster privé de byo ou system à none en utilisant la commande az aks update avec le paramètre --private-dns-zone défini sur none.

az aks update \
    --name <private-cluster-name> \
    --resource-group <private-cluster-resource-group> \
    --private-dns-zone none

  1. Ajoutez le code suivant à l’existant main.tf pour mettre à jour le cluster AKS privé d’une zone DNS privée en public. Cet exemple utilise la mise en réseau avancée. Vous pouvez le modifier pour utiliser la mise en réseau de base par défaut en modifiant les ressources et paramètres Terraform pertinents.

    resource "azurerm_kubernetes_cluster" "this" {
 name                = var.aks_cluster_name
 location            = azurerm_resource_group.this.location
 resource_group_name = azurerm_resource_group.this.name
 dns_prefix          = "aks-update"
 private_cluster_enabled = true
 private_dns_zone_id     = "None"
 default_node_pool {
   name           = "system"
   node_count     = 1
   vm_size        = "Standard_DS2_v2"
   vnet_subnet_id = azurerm_subnet.aks.id
 }
 identity {
   type         = "UserAssigned"
   identity_ids = [azurerm_user_assigned_identity.aks.id]
 }
 network_profile {
   network_plugin    = "azure"
   load_balancer_sku = "standard"
   dns_service_ip    = "10.2.0.10"
   service_cidr      = "10.2.0.0/24"
 }
}

  2. Appliquez la configuration Terraform mise à jour à l’aide des commandes terraform plan et terraform apply.

    terraform plan
terraform apply

Initialisez Terraform

Initialisez Terraform dans le répertoire contenant votre main.tf fichier à l’aide de la terraform init commande. Cette commande télécharge le fournisseur Azure requis pour gérer les ressources Azure avec Terraform.

terraform init

Mettre en forme et valider la configuration Terraform

Formatez et validez la configuration Terraform à l’aide des commandes terraform fmt et terraform validate.

terraform fmt
terraform validate

Créer un plan d’exécution Terraform

Créez un plan d’exécution Terraform à l’aide de la commande terraform plan. Cette commande vous montre les ressources que Terraform créera ou modifiera dans votre abonnement Azure.

terraform plan -var="subscription_id=<your-subscription-id>"

Appliquer la configuration Terraform

Après avoir examiné et confirmé le plan d’exécution, appliquez la configuration Terraform à l’aide de la terraform apply commande. Cette commande crée ou modifie les ressources définies dans votre fichier main.tf dans votre abonnement Azure.

terraform apply -var="subscription_id=<your-subscription-id>"

Configurer kubectl pour se connecter à un cluster AKS privé

Pour gérer un cluster Kubernetes, utilisez le client de ligne de commande Kubernetes, kubectl. kubectl est déjà installé si vous utilisez Azure Cloud Shell. Pour installer kubectl localement, utilisez la commande az aks install-cli .

  1. Configurez kubectl pour se connecter à votre cluster Kubernetes à l’aide de la commande az aks get-credentials. Cette commande télécharge les informations d’identification et configure l’interface CLI Kubernetes pour les utiliser.

    az aks get-credentials --resource-group <private-cluster-resource-group> --name <private-cluster-name>

  2. Vérifiez la connexion à votre cluster à l’aide de la commande kubectl get. Cette commande renvoie la liste des nœuds de cluster.

    kubectl get nodes

    La commande retourne une sortie similaire à l’exemple de sortie suivant :

    NAME                                STATUS   ROLES   AGE    VERSION
aks-nodepool1-12345678-vmss000000   Ready    agent   3h6m   v1.15.11
aks-nodepool1-12345678-vmss000001   Ready    agent   3h6m   v1.15.11
aks-nodepool1-12345678-vmss000002   Ready    agent   3h6m   v1.15.11

Contenu connexe

  • Last updated on