Dela via

Skapa ett privat Azure Kubernetes Service (AKS) kluster

Den här artikeln hjälper dig att distribuera ett privat länkbaserat AKS-kluster med hjälp av Azure CLI eller Terraform. Om du är intresserad av att skapa ett AKS-kluster utan nödvändig privat länk eller tunnel kan du läsa Skapa ett Azure Kubernetes Service (AKS) kluster med API Server VNet-integrering.

Översikt över privata kluster i AKS

I ett privat kluster har kontrollplanet eller API-servern interna IP-adresser som definieras i dokumentet RFC1918 – Adressallokering för privat Internet . Genom att använda en privat kluster kan du säkerställa att nätverkstrafiken mellan din API-server och dina nodpooler förblir endast på det privata nätverket.

Kontrollplanet eller API-servern finns i en AKS-hanterad Azure resursgrupp och klustret eller nodpoolen finns i resursgruppen. Servern och klustret eller nodpoolen kan kommunicera med varandra via tjänsten Azure Private Link i det virtuella API-servernätverket och en privat slutpunkt som exponeras i aks-klustrets undernät.

När du skapar ett privat AKS-kluster skapar AKS både privata och offentliga fullständigt kvalificerade domännamn (FQDN) med motsvarande DNS-zoner som standard. Detaljerade DNS-konfigurationsalternativ finns i Konfigurera en privat DNS-zon, privat DNS-underzon eller anpassad underdomän.

Tillgänglighet i regionen

Privata kluster är tillgängliga i offentliga regioner, Azure Government och Microsoft Azure som drivs av 21Vianet-regioner där AKS stöds.

Viktigt

Alla Microsoft Defender för molnet funktioner kommer officiellt att dras tillbaka i Azure i Kina-regionen den 18 augusti 2026. På grund av denna kommande pensionering kan Azure kunder i Kina inte längre registrera nya prenumerationer på tjänsten. En ny prenumeration är en prenumeration som inte redan har registrerats för den Microsoft Defender för molnet tjänsten före den 18 augusti 2025, datumet för avregistreringsmeddelandet. Mer information om utfasningen finns i Microsoft Defender för molnet Utfasning i Microsoft Azure som drivs av 21Vianet-annons.

Kunder bör arbeta med sina kontorepresentanter för Microsoft Azure som drivs av 21Vianet för att bedöma effekten av denna tillbakadragning på deras egen verksamhet.

Krav för privata AKS-kluster

  • En aktiv Azure-abonnemang. Om du inte har någon Azure prenumeration skapar du ett free-konto innan du börjar.

  • Ange din prenumerationskontext med kommandot az account set . Som exempel:

    az account set --subscription "00000000-0000-0000-0000-000000000000"

  • Azure CLI version 2.28.0 eller senare. Hitta din version med kommandot az --version . Om du behöver installera eller uppgradera kan du läsa Installera Azure CLI.

  • Om du använder Azure Resource Manager (ARM) eller Azure REST API måste AKS API-versionen vara 2021-05-01 eller senare.

  • Om du vill använda en anpassad DNS-server lägger du till den offentliga IP-adressen Azure 168.63.129.16 som den överordnade DNS-servern på den anpassade DNS-servern och ser till att lägga till den här offentliga IP-adressen som first DNS-server. Mer information om ip-adressen för Azure finns i Vad är IP-adressen 168.63.129.16?

  • Befintliga AKS-kluster som är aktiverade med API Server VNet-integrering kan ha aktiverat privat klusterläge. Mer information finns i Aktivera eller inaktivera privat klusterläge i ett befintligt kluster med API Server VNet-integrering.

  • Om du behöver aktivera Azure Container Registry i ett privat AKS-kluster set upp en privat länk för containerregistret i det virtuella klusternätverket (VNet) eller konfigurera peering mellan containerregistrets virtuella nätverk och det privata klustrets virtuella nätverk.

  • kubectl installerat. Du kan installera den lokalt med hjälp av az aks install-cli kommandot .

Viktigt

Från och med November 30, 2025 Azure Kubernetes Service (AKS) inte längre stöder eller tillhandahåller säkerhetsuppdateringar för Azure Linux 2.0. Nodbilden Azure Linux 2.0 är fryst på 202512.06.0 release. Från och med den 31 mars 2026 tas nodbilder bort och du kan inte skala dina nodpooler. Migrera till en Azure Linux-version som stöds genom att uppgradera dina nodpooler till en Kubernetes-version som stöds eller migrera till osSku AzureLinux3. Mer information finns i pensionsfrågan på GitHub och pensionsmeddelandet från Azure Updates. För att hålla dig informerad om meddelanden och uppdateringar, följ AKS-versionsinformation.

Begränsningar

  • IP-auktoriserade intervall gäller endast för den offentliga API-servern. Du kan inte tillämpa dessa intervall på den privata API-serverslutpunkten.
  • Azure Private Link tjänstbegränsningar gäller för privata kluster.
  • Det saknas stöd för Azure DevOps Microsoft-värdade agenter med privata kluster. Överväg att använda lokalt installerade agenter.
  • Om du tar bort eller ändrar den privata slutpunkten i kundens undernät slutar klustret att fungera.
  • Azure Private Link-tjänsten stöds endast på Standard Azure Load Balancer. Grundläggande Azure Load Balancer stöds inte.

Hubb och ekernätverk med anpassad DNS för privata AKS-kluster

Hub- och ekerarkitekturer används ofta för att distribuera nätverk i Azure. I många av dessa distributioner konfigureras DNS-inställningarna i spoke VNets för att referera till en central DNS-vidarebefordrare för att möjliggöra DNS-upplösning för lokala miljöer och Azure.

Följande diagram illustrerar en hubb- och ekerarkitektur för ett privat AKS-kluster med anpassad DNS:

Privat kluster hubb och ekermodell

  • När ett privat kluster skapas skapas som standard en privat slutpunkt (1) och en privat DNS-zon (2) i den klusterhanterade resursgruppen. Klustret använder en A-post i den privata zonen för att lösa IP-adressen till den privata slutpunkten för kommunikation med API-servern.
  • Den privata DNS-zonen är endast länkad till det virtuella nätverk som klusternoderna är kopplade till (3), vilket innebär att den privata slutpunkten endast kan matchas av värdar i det länkade virtuella nätverket. I scenarier där ingen anpassad DNS har konfigurerats på det virtuella nätverket (standard) fungerar det utan problem eftersom värdarna pekar på 168.63.129.16 för DNS som kan lösa upp poster i den privata DNS-zonen tack vare länken.
  • Om du behåller standardbeteendet för privat DNS-zon försöker AKS länka zonen direkt till det virtuella ekernätverket som är värd för klustret även när zonen redan är länkad till ett virtuellt navnätverk.
    • I virtuella ekernätverk som använder anpassade DNS-servrar kan denna åtgärd misslyckas om klustrets hanterade identitet saknar Nätverksbidragsgivare på ekernätverket. Om du vill förhindra felet väljer du någon av följande konfigurationer som stöds:
      • Anpassad privat DNS-zon: Ange en befintlig privat zon och ange privateDNSZone / --private-dns-zone dess resurs-ID. Länka zonen till lämpligt VNet (till exempel det virtuella hubbnätverket) och ange publicDNS till false /använd --disable-public-fqdn.
      • Endast offentlig DNS: Inaktivera skapande av privat zon genom att ange privateDNSZone / --private-dns-zonetill noneoch lämna publicDNS som standardvärde (true) /använd --disable-public-fqdninte .
  • Om du använder byo-routningstabellen (Bring Your Own) med kubenet och BYO DNS med privata kluster misslyckas klusterskapandet. För att göra klusterskapandet framgångsrikt behöver du associera RouteTable i nodresursgruppen till subnettet efter det att klusterskapandet misslyckades.

Begränsningar för privata AKS-kluster med anpassad DNS

  • Inställningen privateDNSZone / --private-dns-zone till noneochpublicDNS: false / --disable-public-fqdn på samma gång stöds inte.
  • Villkorsstyrd vidarebefordran stöder inte underdomäner.

Skapa en resursgrupp

Skapa en resursgrupp med kommandot az group create. Du kan också använda en befintlig resursgrupp för din AKS-kluster.

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

Skapa ett privat AKS-kluster med grundläggande standardnätverk

Skapa ett privat kluster med grundläggande nätverk som standard genom att använda kommandot az aks create med flaggan --enable-private-cluster.

Nyckelparametrar i det här kommandot:

  • --enable-private-cluster: Aktiverar privat klusterläge.
az aks create \
    --name <private-cluster-name> \
    --resource-group <private-cluster-resource-group> \
    --load-balancer-sku standard \
    --enable-private-cluster \
    --generate-ssh-keys

  1. Skapa en fil med namnet main.tf och lägg till följande kod för att definiera Terraform-versionen och ange Azure provider:

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

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

  2. Lägg till följande kod i main.tf för att skapa indatavariabler för ditt Azure prenumerations-ID, resursgruppsnamn, plats och AKS-klusternamn. Du kan ändra standardvärdena efter behov.

    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. Lägg till följande kod i main.tf för att skapa en Azure resursgrupp:

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

  4. Lägg till följande kod till main.tf för att skapa ett privat AKS-kluster med grundläggande nätverksfunktioner:

    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. Följ stegen för att initiera Terraform, formatera och verifiera Terraform-konfigurationen, skapa en Terraform-körningsplan, tillämpa Terraform-konfigurationen och ansluta till AKS-klustret.

Skapa ett privat AKS-kluster med avancerade nätverk

Skapa ett privat kluster med avancerat nätverk med hjälp av az aks create kommandot .

Nyckelparametrar i det här kommandot:

  • --enable-private-cluster: Aktiverar privat klusterläge.
  • --network-plugin azure: Anger pluginet för Azure CNI-nätverksanslutning.
  • --vnet-subnet-id <subnet-id>: Resurs-ID för ett befintligt undernät i ett virtuellt nätverk.
  • --dns-service-ip <dns-service-ip>: En tillgänglig IP-adress inom Kubernetes-tjänstadressintervallet som ska användas för klustrets DNS-tjänst. Till exempel 10.2.0.10.
  • --service-cidr <service-cidr>: Ett IP-intervall för CIDR-notation som tjänstkluster-IP-adresser ska tilldelas från. Till exempel 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. Skapa en fil med namnet main.tf och lägg till följande kod för att definiera Terraform-versionen och ange Azure provider:

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

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

  2. Lägg till följande kod i main.tf för att skapa indatavariabler för ditt Azure prenumerations-ID, resursgruppsnamn, plats, AKS-klusternamn, virtuellt nätverk (VNet) och undernätsnamn. Du kan ändra standardvärdena efter behov.

    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. Lägg till följande kod i main.tf för att skapa en Azure resursgrupp, VNet och undernät:

    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. Lägg till följande kod i main.tf för att skapa AKS-klustret med avancerade nätverksfunktioner.

    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. Följ stegen för att initiera Terraform, formatera och verifiera Terraform-konfigurationen, skapa en Terraform-körningsplan, tillämpa Terraform-konfigurationen och ansluta till AKS-klustret.

Använda anpassade domäner med privata AKS-kluster

Om du vill konfigurera anpassade domäner som bara kan lösas internt kan du läsa Använda anpassade domäner.

Inaktivera ett offentligt fullständigt domännamn i ett privat AKS-kluster

Inaktivera en offentlig FQDN på ett nytt kluster

Inaktivera en offentlig FQDN när du skapar ett privat AKS-kluster med hjälp av az aks create-kommandot med --disable-public-fqdn-flaggan.

Nyckelparametrar i det här kommandot:

  • --disable-public-fqdn: Inaktiverar det offentliga fullständigt kvalificerade domännamnet (FQDN) för API-servern.
  • --assign-identity <resource-id>: Anger den hanterade identitet som ska användas för klustret.
  • --private-dns-zone [system|none]: Anger den privata DNS-zon som ska användas för klustret. system är standardvärdet när du konfigurerar en privat DNS-zon. Om du utelämnar --private-dns-zoneskapar AKS en privat DNS-zon i nodresursgruppen. none inaktiverar skapandet av en privat DNS-zon.
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. Följ steg 1–3 i Skapa ett privat AKS-kluster med avancerat nätverk eller Skapa ett privat AKS-kluster med standard grundläggande nätverk för att konfigurera Terraform-konfigurationen och skapa nödvändiga resurser beroende på ditt scenario. I det här exemplet används avancerade nätverk.

  2. Lägg till följande kod för att main.tf skapa ett privat AKS-kluster med en användartilldelad identitet och det offentliga fullständiga domännamnet inaktiverat:

    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. Följ stegen för att initiera Terraform, formatera och verifiera Terraform-konfigurationen, skapa en Terraform-körningsplan, tillämpa Terraform-konfigurationen och ansluta till AKS-klustret.

Inaktivera en offentlig FQDN på en befintlig kluster

Inaktivera ett offentligt FQDN på ett befintligt AKS-kluster med kommandot az aks update med --disable-public-fqdn flaggan .

Nyckelparametrar i det här kommandot:

  • --disable-public-fqdn: Inaktiverar det offentliga fullständigt kvalificerade domännamnet (FQDN) för API-servern.
az aks update \
    --name <private-cluster-name> \
    --resource-group <private-cluster-resource-group> \
    --disable-public-fqdn

  1. Lägg till följande kod i den befintliga main.tf koden för att inaktivera det offentliga fullständiga domännamnet i ett befintligt AKS-kluster. I det här exemplet används avancerade nätverk. Du kan ändra det så att standardnätverk används genom att ändra relevanta Terraform-resurser och -parametrar.

    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. Använd den uppdaterade Terraform-konfigurationen med hjälp av terraform plan kommandona och terraform apply .

    terraform plan
terraform apply

Konfigurationsalternativ för privat DNS

Du kan konfigurera privata DNS-inställningar för ett privat AKS-kluster med hjälp av Azure CLI (med parametern --private-dns-zone) eller en Azure Resource Manager-mall (ARM) (med egenskapen privateDNSZone). I följande tabell beskrivs de tillgängliga alternativen för parametern --private-dns-zone / privateDNSZone egenskapen:

Inställning Description
system Standardvärdet när du konfigurerar en privat DNS-zon. Om du utelämnar --private-dns-zone / privateDNSZoneskapar AKS en privat DNS-zon i nodresursgruppen.
none Om du anger --private-dns-zone / privateDNSZone till noneskapar AKS inte en privat DNS-zon.
<custom-private-dns-zone-resource-id> Om du vill använda den här parametern måste du skapa en privat DNS-zon i följande format för Azure globala molnet: privatelink.<region>.azmk8s.io eller <subzone>.privatelink.<region>.azmk8s.io. Du behöver resurs-ID för den privata DNS-zonen för framtida användning. Du behöver också en användartilldelad identitet eller tjänstens huvudnamn med rollerna Private DNS Zone Contributor och Network Contributor. För kluster som använder API Server VNet-integrering stöder en privat DNS-zon namngivningsformatet private.<region>.azmk8s.io för eller <subzone>.private.<region>.azmk8s.io. Du kan inte ändra eller ta bort resursen när du har skapat klustret eftersom det kan orsaka prestandaproblem och klusteruppgraderingsfel. Du kan använda --fqdn-subdomain <subdomain> tillsammans med <custom-private-dns-zone-resource-id> endast för att ge underdomänfunktioner till privatelink.<region>.azmk8s.io. Om du anger en underzon finns det en gräns på 32 tecken för <subzone> namnet.

Överväganden för privat DNS

Tänk på följande när du konfigurerar privat DNS för ett privat AKS-kluster:

  • Om den privata DNS-zonen finns i en annan prenumeration än AKS-klustret måste du registrera providern Microsoft.ContainerService Azure i båda prenumerationerna.
  • Om ditt AKS-kluster har konfigurerats med ett služba Active Directory tjänsthuvudnamn stöder AKS inte användning av en systemtilldelad hanteringsidentitet med en anpassad privat DNS-zon. Klustret måste använda användartilldelad hanterad identitetsautentisering.

Skapa ett privat AKS-kluster med en privat DNS-zon

Skapa ett privat AKS-kluster med en privat DNS-zon med kommandot az aks create .

Nyckelparametrar i det här kommandot:

  • --enable-private-cluster: Aktiverar privat klusterläge.
  • --private-dns-zone [system|none]: Konfigurerar den privata DNS-zonen för klustret. system är standardvärdet när du konfigurerar en privat DNS-zon. Om du utelämnar --private-dns-zoneskapar AKS en privat DNS-zon i nodresursgruppen. none inaktiverar skapandet av en privat DNS-zon.
  • --assign-identity <resource-id>: Resurs-ID för en användartilldelad hanterad identitet med rollerna Private DNS Zone Contributor och Network Contributor.
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. Följ steg 1–3 i Skapa ett privat AKS-kluster med avancerat nätverk eller Skapa ett privat AKS-kluster med standard grundläggande nätverk för att konfigurera Terraform-konfigurationen och skapa nödvändiga resurser beroende på ditt scenario. I det här exemplet används avancerade nätverk.

  2. Lägg till följande kod för att main.tf skapa ett privat AKS-kluster med en AKS-hanterad privat DNS-zon:

    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. Följ stegen för att initiera Terraform, formatera och verifiera Terraform-konfigurationen, skapa en Terraform-körningsplan, tillämpa Terraform-konfigurationen och ansluta till AKS-klustret.

Skapa ett privat AKS-kluster utan en privat DNS-zon

  1. Följ steg 1–3 i Skapa ett privat AKS-kluster med avancerat nätverk eller Skapa ett privat AKS-kluster med standard grundläggande nätverk för att konfigurera Terraform-konfigurationen och skapa nödvändiga resurser beroende på ditt scenario. I det här exemplet används avancerade nätverk.

  2. Lägg till följande kod i main.tf för att skapa AKS-klustret utan en privat DNS-zon.

    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. Följ stegen för att initiera Terraform, formatera och verifiera Terraform-konfigurationen, skapa en Terraform-körningsplan, tillämpa Terraform-konfigurationen och ansluta till AKS-klustret.

Skapa ett privat AKS-kluster med en anpassad privat DNS-zon eller privat DNS-underdelzon

Skapa ett privat AKS-kluster med en anpassad privat DNS-zon eller underzon med kommandot az aks create .

Nyckelparametrar i det här kommandot:

  • --enable-private-cluster: Aktiverar privat klusterläge.
  • --private-dns-zone [<custom-private-dns-zone-resource-id>|<custom-private-dns-subzone-resource-id>]: Resurs-ID för en befintlig privat DNS-zon eller underzon i följande format för Azure globala molnet: privatelink.<region>.azmk8s.io eller <subzone>.privatelink.<region>.azmk8s.io.
  • --assign-identity <resource-id>: Resurs-ID för en användartilldelad hanterad identitet med rollerna Private DNS Zone Contributor och Network Contributor.
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

När du använder en anpassad privat DNS-zon ansvarar du för att skapa och hantera DNS-infrastrukturen i stället för att förlita dig på Azure hanterad DNS. Detta inkluderar att skapa DNS-zonen, länka den till ditt virtuella nätverk och tilldela nödvändiga behörigheter för AKS för att hantera poster.

För anpassade DNS-konfigurationer måste du använda en användartilldelad hanterad identitet med rollerna Private DNS Zone Contributor och Network Contributor.

  1. Följ steg 1–3 i Skapa ett privat AKS-kluster med avancerat nätverk eller Skapa ett privat AKS-kluster med standard grundläggande nätverk för att konfigurera Terraform-konfigurationen och skapa nödvändiga resurser beroende på ditt scenario. I det här exemplet används avancerade nätverk.

  2. Lägg till koden i main.tf för att skapa ett privat AKS-kluster med en anpassad privat DNS-zon eller underzon:

    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. Följ stegen för att initiera Terraform, formatera och verifiera Terraform-konfigurationen, skapa en Terraform-körningsplan, tillämpa Terraform-konfigurationen och ansluta till AKS-klustret.

Skapa en privat AKS-kluster med en anpassad privat DNS-zon och anpassad underdomän.

Skapa ett privat AKS-kluster med en anpassad privat DNS-zon och underdomän med kommandot az aks create .

Nyckelparametrar i det här kommandot:

  • --enable-private-cluster: Aktiverar privat klusterläge.
  • --private-dns-zone <custom-private-dns-zone-resource-id>: Resurs-ID för en befintlig privat DNS-zon i följande format för Azure globala molnet: privatelink.<region>.azmk8s.io.
  • --fqdn-subdomain <subdomain>: Underdomänen som ska användas för klustrets FQDN i den anpassade privata DNS-zonen.
  • --assign-identity <resource-id>: Resurs-ID för en användartilldelad hanterad identitet med rollerna Private DNS Zone Contributor och Network Contributor.
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. Följ steg 1–3 i Skapa ett privat AKS-kluster med avancerat nätverk eller Skapa ett privat AKS-kluster med standard grundläggande nätverk för att konfigurera Terraform-konfigurationen och skapa nödvändiga resurser beroende på ditt scenario. I det här exemplet används avancerade nätverk.

  2. Lägg till följande kod i main.tf för att skapa ett privat AKS-kluster med en privat, anpassad DNS-zon och underdomän:

    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. Följ stegen för att initiera Terraform, formatera och verifiera Terraform-konfigurationen, skapa en Terraform-körningsplan, tillämpa Terraform-konfigurationen och ansluta till AKS-klustret.

Uppdatera ett befintligt privat AKS-kluster från en privat DNS-zon till offentlig

Du kan bara uppdatera från byo (ta med din egen) eller system till none. Ingen annan kombination av uppdateringsvärden stöds.

Varning

När du uppdaterar ett privat kluster från byo eller system till noneändras agentnoderna till att använda ett offentligt FQDN. I ett AKS-kluster som använder Azure Virtual Machine Scale Sets utförs en nodbildsuppgradering för att uppdatera noderna med det offentliga fullständiga domännamnet (FQDN).

Uppdatera ett privat kluster från byo eller system till none med kommandot az aks update med parametern inställd på --private-dns-zonenone.

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

  1. Lägg till följande kod i den befintliga main.tf koden för att uppdatera det privata AKS-klustret från en privat DNS-zon till offentlig. I det här exemplet används avancerade nätverk. Du kan ändra det så att standardnätverk används genom att ändra relevanta Terraform-resurser och -parametrar.

    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. Använd den uppdaterade Terraform-konfigurationen med hjälp av terraform plan kommandona och terraform apply .

    terraform plan
terraform apply

Initiera Terraform

Initiera Terraform i katalogen som innehåller main.tf filen med hjälp av terraform init kommandot . Det här kommandot laddar ned den Azure provider som krävs för att hantera Azure resurser med Terraform.

terraform init

Formatera och verifiera Terraform-konfigurationen

Formatera och verifiera Terraform-konfigurationen med hjälp av kommandona terraform fmt och terraform validate .

terraform fmt
terraform validate

Skapa en Terraform-utförandeplan

Skapa en Terraform-körningsplan med kommandot terraform plan . Det här kommandot visar de resurser som Terraform skapar eller ändrar i din Azure-prenumeration.

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

Applicera Terraform-konfigurationen

När du har granskat och bekräftat körningsplanen, verkställer du Terraform-konfigurationen med kommandot terraform apply. Det här kommandot skapar eller ändrar de resurser som definierats i din main.tf-fil i din Azure-prenumeration.

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

Konfigurera kubectl för att ansluta till ett privat AKS-kluster

Om du vill hantera ett Kubernetes-kluster använder du Kubernetes-kommandoradsklienten kubectl. kubectl är redan installerat om du använder Azure Cloud Shell. Om du vill installera kubectl lokalt använder du kommandot az aks install-cli.

  1. Konfigurera kubectl för att ansluta till kubernetes-klustret med hjälp av az aks get-credentials kommandot . Det här kommandot laddar ned autentiseringsuppgifter och konfigurerar Kubernetes CLI för att använda dem.

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

  2. Kontrollera anslutningen till klustret med hjälp av kubectl get kommandot . Det här kommandot returnerar en lista över klusternoderna.

    kubectl get nodes

    Kommandot returnerar utdata som liknar följande exempelutdata:

    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

Relaterat innehåll

  • Last updated on