Criar um cluster privado do Azure Kubernetes Service (AKS)

Este artigo ajuda-o a implementar um cluster AKS privado baseado em links usando CLI do Azure ou Terraform. Se estiver interessado em criar um cluster AKS sem ligação privada ou túnel obrigatório, veja Criar um cluster Azure Kubernetes Service (AKS) com integração com VNet do API Server.

Visão geral dos clusters privados no AKS

Em um cluster privado, o plano de controle ou servidor de API tem endereços IP internos que são definidos no documento RFC1918 - Address Allocation for Private Internet . Usando um cluster privado, você pode garantir que o tráfego de rede entre o servidor de API e os pools de nós permaneça apenas na rede privada.

O plano de controlo ou servidor API está num grupo de recursos Azure gerido pelo AKS, e o seu cluster ou pool de nós está no seu grupo de recursos. O servidor e o cluster ou pool de nós podem comunicar entre si através do serviço Azure Private Link na rede virtual do servidor API e de um endpoint privado exposto na sub-rede do seu cluster AKS.

Quando cria um cluster AKS privado, o AKS cria nomes de domínio totalmente qualificados (FQDNs) privados e públicos com zonas DNS correspondentes por defeito. Para opções detalhadas de configuração DNS, consulte Configurar uma zona DNS privada, subzona DNS privada ou subdomínio personalizado.

Disponibilidade da região

Clusters privados estão disponíveis em regiões públicas, Azure Government e Microsoft Azure operado pela 21Vianet em regiões onde AKS é suportado.

Importante

Todas as funcionalidades do Microsoft Defender para a Cloud serão oficialmente retiradas da região Azure na China a 18 de agosto de 2026. Devido a esta reforma iminente, os clientes da Azure na China já não podem integrar novas subscrições ao serviço. Uma nova subscrição é qualquer subscrição que não estivesse já integrada no serviço Microsoft Defender para a Cloud antes de 18 de agosto de 2025, data do anúncio da reforma. Para mais informações sobre a descontinuação, consulte Anúncio de Depreciação do Microsoft Defender para a Cloud no Microsoft Azure Operado pela 21Vianet.

Os clientes devem trabalhar com os seus representantes de conta do Microsoft Azure operado pela 21Vianet para avaliar o impacto desta reforma nas suas próprias operações.

Pré-requisitos para clusters privados AKS

  • Terraform instalado localmente. Para instruções de instalação, consulte Instalar Terraform.

Importante

A partir de 30 de novembro de 2025, Azure Kubernetes Service (AKS) já não suporta nem fornece atualizações de segurança para Azure Linux 2.0. A imagem Azure do nó Linux 2.0 está congelada na versão 202512.06.0. A partir de 31 de março de 2026, as imagens dos nós serão removidas e não poderá ajustar o tamanho dos seus pools de nós. Migre para uma versão Azure Linux suportada atualizando os seus pools de nós para uma versão Kubernetes suportada ou migrando para osSku AzureLinux3. Para mais informações, consulte a issue de reforma do GitHub e o anúncio de retirada das atualizações do Azure. Para se manter informado sobre anúncios e atualizações, siga as Notas de Lançamento do AKS.

Limitações

  • Os intervalos autorizados por IP aplicam-se apenas ao servidor público da API. Não podes aplicar estes intervalos ao endpoint do servidor privado de API.
  • As limitações do serviço Azure Private Link aplicam-se a clusters privados.
  • Não há suporte para agentes do Azure DevOps alojados pela Microsoft em clusters privados. Considere o uso de agentes auto-hospedados.
  • Eliminar ou modificar o endpoint privado na sub-rede do cliente faz com que o cluster deixe de funcionar.
  • O serviço Azure Private Link é suportado apenas no Standard Balanceador de Carga do Azure. O Balanceador de Carga do Azure básico não é suportado.

Modelo hub-and-spoke com DNS personalizado para clusters privados de AKS

Hub e spoke são frequentemente usadas para implementar redes no Azure. Em muitas destas implementações, as definições DNS nos VNets spoke são configuradas para referenciar um encaminhador DNS central para permitir resolução DNS on-premises e baseada em Azure.

O diagrama seguinte ilustra uma arquitetura hub and spoke para um cluster AKS privado com DNS personalizado:

Ponto de ligação e distribuição de cluster privado

  • Quando um cluster privado é criado, um endpoint privado (1) e uma zona DNS privada (2) são criados no grupo de recursos geridos pelo cluster por defeito. O cluster usa um A registo na zona privada para resolver o endereço IP do ponto final privado para comunicação com o servidor de API.
  • A zona DNS privada está ligada apenas ao VNet ao qual os nós do cluster estão ligados (3), o que significa que o endpoint privado só pode ser resolvido por hosts nesse VNet ligado. Em cenários em que não há DNS personalizado configurado no VNet (por defeito), funciona sem problemas, pois os hosts apontam para 168.63.129.16 para DNS que consegue resolver registos na zona DNS privada devido à ligação.
  • Se mantiveres o comportamento predefinido da zona DNS privada, o AKS tenta ligar a zona diretamente ao VNet spoke que aloja o cluster, mesmo quando a zona já está ligada a um VNet hub.
    • Em VNet spoke que utilizam servidores DNS personalizados, esta ação pode falhar se a identidade gerida do cluster não tiver Network Contributor no VNet spoke. Para evitar a falha, escolha uma das seguintes configurações suportadas:
      • Zona DNS privada personalizada: Forneça uma zona privada existente e defina privateDNSZone / --private-dns-zone para o seu ID de recurso. Liga essa zona ao VNet apropriado (por exemplo, o VNet do hub) e define publicDNS para false / usa --disable-public-fqdn.
      • Apenas DNS público: Desative a criação de zonas privadas definindo privateDNSZone / --private-dns-zonenone deixe publicDNS no valor padrão (true) / não use --disable-public-fqdn.
  • A criação de clusters falha se estiveres a usar a tua própria tabela de rotas (BYO) com kubenet e DNS BYO com clusters privados. Você precisa associar o RouteTable no grupo de recursos do nó à sub-rede caso a criação do cluster falhe, para garantir que a criação seja bem-sucedida.

Limitações para clusters privados AKS com DNS personalizado

  • Definir privateDNSZone / --private-dns-zone para noneepublicDNS: false / --disable-public-fqdn ao mesmo tempo não é suportado.
  • O encaminhamento condicional não suporta subdomínios.

Criar um grupo de recursos

Crie um grupo de recursos usando o comando az group create. Você também pode usar um grupo de recursos existente para seu cluster AKS.

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

Criar um cluster AKS privado com rede padrão básica

Crie um cluster privado com rede básica padrão usando o az aks create comando com o --enable-private-cluster sinalizador.

Parâmetros-chave neste comando:

  • --enable-private-cluster: Ativa o modo de cluster privado.
az aks create \
    --name <private-cluster-name> \
    --resource-group <private-cluster-resource-group> \
    --load-balancer-sku standard \
    --enable-private-cluster \
    --generate-ssh-keys

  1. Crie um ficheiro chamado main.tf e adicione o seguinte código para definir a versão do Terraform e especificar o fornecedor 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. Adicione o seguinte código a main.tf para criar variáveis de entrada para o seu ID de subscrição Azure, nome do grupo de recursos, localização e nome do cluster AKS. Pode modificar os valores padrão conforme necessário.

    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. Adicione o seguinte código a main.tf para criar um grupo de recursos Azure:

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

  4. Adicione o seguinte código no main.tf para criar um cluster AKS privado com rede básica:

    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. Siga os passos para inicializar o Terraform, formatar e validar a configuração do Terraform, criar um plano de execução do Terraform, aplicar a configuração do Terraform e ligar-se ao cluster AKS.

Crie um cluster AKS privado com redes avançadas

Crie um cluster privado com redes avançadas usando o az aks create comando.

Parâmetros-chave neste comando:

  • --enable-private-cluster: Ativa o modo de cluster privado.
  • --network-plugin azure: Especifica o plugin de rede Azure CNI.
  • --vnet-subnet-id <subnet-id>: O ID de recurso de uma sub-rede existente num VNet.
  • --dns-service-ip <dns-service-ip>: Um endereço IP disponível dentro do intervalo de endereços do serviço Kubernetes para usar no serviço DNS do cluster. Por exemplo, 10.2.0.10.
  • --service-cidr <service-cidr>: Um intervalo de IPs de notação CIDR a partir do qual atribuir IPs do cluster de serviços. Por exemplo, 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. Crie um ficheiro chamado main.tf e adicione o seguinte código para definir a versão do Terraform e especificar o fornecedor 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. Adicione o seguinte código a main.tf para criar variáveis de entrada para o seu ID de subscrição Azure, nome do grupo de recursos, localização, nome do cluster AKS, nome da rede virtual (VNet) e nome da subrede. Pode modificar os valores padrão conforme necessário.

    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. Adicione o seguinte código a main.tf para criar um grupo de recursos Azure, VNet e subrede:

    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. Adicione o seguinte código a main.tf para criar o cluster AKS com redes avançadas.

    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. Siga os passos para inicializar o Terraform, formatar e validar a configuração do Terraform, criar um plano de execução do Terraform, aplicar a configuração do Terraform e ligar-se ao cluster AKS.

Use domínios personalizados com clusters AKS privados

Se você quiser configurar domínios personalizados que só podem ser resolvidos internamente, consulte Usar domínios personalizados.

Desativar um FQDN público num cluster AKS privado

Desabilitar um FQDN público em um novo cluster

Desative um FQDN público ao criar um cluster AKS privado usando o az aks create comando com o --disable-public-fqdn sinalizador.

Parâmetros-chave neste comando:

  • --disable-public-fqdn: Desativa o domínio público totalmente qualificado (FQDN) para o servidor API.
  • --assign-identity <resource-id>: Especifica a identidade gerida a usar para o cluster.
  • --private-dns-zone [system|none]: Especifica a zona DNS privada a usar para o cluster. system é o valor predeterminado ao configurar uma zona DNS privada. Se omitir --private-dns-zone, AKS criará uma zona DNS privada no grupo de recursos de nós. none desativa a criação de uma zona DNS privada.
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. Siga os passos 1-3 em Criar um cluster AKS privado com redes avançadas ou criar um cluster AKS privado com rede básica por defeito para configurar a configuração do Terraform e criar os recursos necessários dependendo do seu cenário. Este exemplo utiliza redes avançadas.

  2. Adicione o seguinte código para main.tf criar um cluster AKS privado com uma identidade atribuída pelo utilizador e o FQDN público desativado:

    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. Siga os passos para inicializar o Terraform, formatar e validar a configuração do Terraform, criar um plano de execução do Terraform, aplicar a configuração do Terraform e ligar-se ao cluster AKS.

Desabilitar um FQDN público em um cluster existente

Desativar um FQDN público em um cluster AKS existente usando o comando az aks update com a flag --disable-public-fqdn.

Parâmetros-chave neste comando:

  • --disable-public-fqdn: Desativa o domínio público totalmente qualificado (FQDN) para o servidor API.
az aks update \
    --name <private-cluster-name> \
    --resource-group <private-cluster-resource-group> \
    --disable-public-fqdn

  1. Adicione o seguinte código ao existente main.tf para desativar o FQDN público num cluster AKS existente. Este exemplo utiliza redes avançadas. Podes modificá-lo para usar a rede básica predefinida, alterando os recursos e parâmetros relevantes do Terraform.

    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. Aplica a configuração atualizada do Terraform usando os terraform plan comandos e terraform apply .

    terraform plan
terraform apply

Opções de configuração para DNS privado

Pode configurar definições privadas de DNS para um cluster AKS privado usando o CLI do Azure (com o parâmetro --private-dns-zone) ou um modelo Azure Resource Manager (ARM) (com a propriedade privateDNSZone). A tabela seguinte descreve as opções disponíveis para o --private-dns-zone parâmetro / privateDNSZone propriedade:

Configuração Description
system O valor padrão ao configurar uma zona DNS privada. Se omitir --private-dns-zone / privateDNSZone, o AKS cria uma zona DNS privada no grupo de recursos de nós.
none Se definires --private-dns-zone / privateDNSZone para none, o AKS não cria uma zona DNS privada.
<custom-private-dns-zone-resource-id> Para usar este parâmetro, é necessário criar uma zona DNS privada no seguinte formato para Azure cloud global: privatelink.<region>.azmk8s.io ou <subzone>.privatelink.<region>.azmk8s.io. Precisa do ID do recurso da zona DNS privada para uso futuro. Também precisa de uma identidade atribuída pelo utilizador ou de um principal de serviço com os papéis de Contribuidor de Zona de DNS Privada e Contribuidor de Rede. Para clusters que utilizam integração API Server VNet, uma zona DNS privada suporta o formato de nomenclatura de private.<region>.azmk8s.io ou <subzone>.private.<region>.azmk8s.io. Não podes alterar ou eliminar esses recursos de recursos depois de criares o cluster, pois isso pode causar problemas de desempenho e falhas na atualização do cluster. Você pode usar --fqdn-subdomain <subdomain> com <custom-private-dns-zone-resource-id> apenas para fornecer recursos de subdomínio para privatelink.<region>.azmk8s.io. Se estiveres a especificar uma subzona, há um limite de 32 caracteres para o <subzone> nome.

Considerações para DNS privado

Tenha em mente as seguintes considerações ao configurar DNS privado para um cluster AKS privado:

  • Se a zona DNS privada estiver numa subscrição diferente do cluster AKS, precisa de registar o fornecedor Microsoft.ContainerService Azure em ambas as subscrições.
  • Se o seu cluster AKS estiver configurado com um principal de serviço Active Directory, o AKS não suporta o uso de uma identidade gerida atribuída pelo sistema com zona DNS privada personalizada. O cluster deve usar a autenticação de identidade gerenciada atribuída pelo usuário.

Criar um cluster AKS privado com uma zona DNS privada

Cria um cluster AKS privado com uma zona DNS privada usando o az aks create comando.

Parâmetros-chave neste comando:

  • --enable-private-cluster: Ativa o modo de cluster privado.
  • --private-dns-zone [system|none]: Configura a zona DNS privada para o cluster. system é o valor predeterminado ao configurar uma zona DNS privada. Se omitir --private-dns-zone, AKS criará uma zona DNS privada no grupo de recursos de nós. none desativa a criação de uma zona DNS privada.
  • --assign-identity <resource-id>: O ID de recurso de uma identidade gerida atribuída pelo utilizador com os papéis Colaborador de Zona DNS Privada e Colaborador de Rede.
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. Siga os passos 1-3 em Criar um cluster AKS privado com redes avançadas ou criar um cluster AKS privado com rede básica por defeito para configurar a configuração do Terraform e criar os recursos necessários dependendo do seu cenário. Este exemplo utiliza redes avançadas.

  2. Adicione o seguinte código para main.tf criar um cluster AKS privado com uma zona DNS privada gerida pelo 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. Siga os passos para inicializar o Terraform, formatar e validar a configuração do Terraform, criar um plano de execução do Terraform, aplicar a configuração do Terraform e ligar-se ao cluster AKS.

Criar um cluster AKS privado sem uma zona DNS privada

  1. Siga os passos 1-3 em Criar um cluster AKS privado com redes avançadas ou criar um cluster AKS privado com rede básica por defeito para configurar a configuração do Terraform e criar os recursos necessários dependendo do seu cenário. Este exemplo utiliza redes avançadas.

  2. Adicione o seguinte código para main.tf criar o cluster AKS sem uma zona DNS privada:

    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. Siga os passos para inicializar o Terraform, formatar e validar a configuração do Terraform, criar um plano de execução do Terraform, aplicar a configuração do Terraform e ligar-se ao cluster AKS.

Criar um cluster AKS privado com uma zona DNS privada personalizada ou uma subzona DNS privada

Crie um cluster AKS privado com uma zona ou subzona DNS privada personalizada usando o az aks create comando.

Parâmetros-chave neste comando:

  • --enable-private-cluster: Ativa o modo de cluster privado.
  • --private-dns-zone [<custom-private-dns-zone-resource-id>|<custom-private-dns-subzone-resource-id>]: O ID de recurso de uma zona ou subzona DNS privada existente no seguinte formato para Azure cloud global: privatelink.<region>.azmk8s.io ou <subzone>.privatelink.<region>.azmk8s.io.
  • --assign-identity <resource-id>: O ID de recurso de uma identidade gerida atribuída pelo utilizador com os papéis Colaborador de Zona DNS Privada e Colaborador de Rede.
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

Ao usar uma zona DNS privada personalizada, é responsável por criar e gerir a infraestrutura DNS em vez de depender do DNS gerido pelo Azure. Isto inclui criar a zona DNS, ligá-la ao seu VNet e atribuir as permissões necessárias ao AKS para gerir os registos.

Para configurações DNS personalizadas, deve usar obrigatoriamente uma identidade gerida atribuída pelo utilizador com os papéis DNS Privado Zone Contributor e Network Contributor.

  1. Siga os passos 1-3 em Criar um cluster AKS privado com redes avançadas ou criar um cluster AKS privado com rede básica por defeito para configurar a configuração do Terraform e criar os recursos necessários dependendo do seu cenário. Este exemplo utiliza redes avançadas.

  2. Adicione o código para main.tf criar um cluster AKS privado com uma zona ou subzona DNS privada personalizada:

    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. Siga os passos para inicializar o Terraform, formatar e validar a configuração do Terraform, criar um plano de execução do Terraform, aplicar a configuração do Terraform e ligar-se ao cluster AKS.

Criar um cluster AKS privado com uma zona DNS privada personalizada e um subdomínio personalizado

Crie um cluster AKS privado com uma zona DNS privada personalizada e subdomínio usando o az aks create comando.

Parâmetros-chave neste comando:

  • --enable-private-cluster: Ativa o modo de cluster privado.
  • --private-dns-zone <custom-private-dns-zone-resource-id>: O ID de recurso de uma zona DNS privada existente no seguinte formato para Azure cloud global: privatelink.<region>.azmk8s.io.
  • --fqdn-subdomain <subdomain>: O subdomínio a usar para o cluster FQDN dentro da zona DNS privada personalizada.
  • --assign-identity <resource-id>: O ID de recurso de uma identidade gerida atribuída pelo utilizador com os papéis Colaborador de Zona DNS Privada e Colaborador de Rede.
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. Siga os passos 1-3 em Criar um cluster AKS privado com redes avançadas ou criar um cluster AKS privado com rede básica por defeito para configurar a configuração do Terraform e criar os recursos necessários dependendo do seu cenário. Este exemplo utiliza redes avançadas.

  2. Adicione o seguinte código para main.tf criar um cluster AKS privado com uma zona DNS privada personalizada e subdomínio:

    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. Siga os passos para inicializar o Terraform, formatar e validar a configuração do Terraform, criar um plano de execução do Terraform, aplicar a configuração do Terraform e ligar-se ao cluster AKS.

Atualize um cluster AKS privado existente de uma zona DNS privada para público

Só podes atualizar a partir de byo (bring your own) ou system para none. Nenhuma outra combinação de valores de atualização é suportada.

Advertência

Quando se atualiza um cluster privado de byo ou system para none, os nós dos agentes passam a usar um FQDN público. Num cluster AKS que utiliza Conjuntos de Dimensionamento de Máquinas Virtuais do Azure, é realizada uma atualização da imagem do nó para atualizar os nós com o FQDN público.

Atualize um cluster privado de byo ou system para none usando o az aks update comando com o --private-dns-zone parâmetro definido para none.

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

  1. Adicione o seguinte código ao existente main.tf para atualizar o cluster privado AKS de uma zona DNS privada para o público. Este exemplo utiliza redes avançadas. Podes modificá-lo para usar a rede básica predefinida, alterando os recursos e parâmetros relevantes do Terraform.

    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. Aplica a configuração atualizada do Terraform usando os terraform plan comandos e terraform apply .

    terraform plan
terraform apply

Inicializar Terraform

Inicialize o Terraform no diretório que contém o seu main.tf ficheiro usando o terraform init comando. Este comando descarrega o fornecedor Azure necessário para gerir os recursos do Azure com o Terraform.

terraform init

Formatar e validar a configuração do Terraform

Formate e valide a configuração do Terraform usando os terraform fmt comandos e terraform validate .

terraform fmt
terraform validate

Criar um plano de execução do Terraform

Crie um plano de execução Terraform usando o terraform plan comando. Este comando mostra-te os recursos que o Terraform irá criar ou modificar na tua subscrição do Azure.

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

Aplicar a configuração Terraform

Após rever e confirmar o plano de execução, aplique a configuração do Terraform usando o terraform apply comando. Este comando cria ou modifica os recursos definidos no seu ficheiro de main.tf na sua subscrição Azure.

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

Configure o kubectl para se ligar a um cluster AKS privado

Para gerenciar um cluster Kubernetes, use o cliente de linha de comando Kubernetes, kubectl. kubectl já está instalado se usares Azure Cloud Shell. Para instalar kubectl localmente, use o az aks install-cli comando.

  1. Configure kubectl para se conectar ao cluster do Kubernetes usando o az aks get-credentials comando. Este comando baixa credenciais e configura a CLI do Kubernetes para usá-las.

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

  2. Verifique a conexão ao seu cluster utilizando o comando kubectl get. Este comando devolve uma lista dos nodes do cluster.

    kubectl get nodes

    O comando devolve uma saída semelhante à seguinte saída de exemplo:

    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

Conteúdo relacionado

  • Last updated on