Criar um cluster isolado de rede do Serviço Kubernetes do Azure (AKS)

As organizações normalmente têm requisitos rigorosos de segurança e conformidade para regular o tráfego de rede de saída (saída) de um cluster para eliminar os riscos de exfiltração de dados. Por padrão, os clusters padrão do Serviço Kubernetes do Azure (AKS) têm acesso irrestrito à Internet de saída. Esse nível de acesso à rede permite que os nós e serviços que gere acedam a recursos externos conforme necessário. Se desejar restringir o tráfego de saída, um número limitado de portas e endereços deve estar acessível para assegurar a execução saudável das tarefas de manutenção do cluster. O documento conceptual sobre regras de rede de saída e FQDN para clusters AKS fornece uma lista de endpoints necessários para o cluster AKS e seus complementos e funcionalidades opcionais.

Uma solução comum para restringir o tráfego de saída do cluster é usar um dispositivo de firewall para restringir o tráfego com base em regras de firewall. O firewall é aplicável quando seu aplicativo requer acesso de saída, mas quando as solicitações de saída precisam ser inspecionadas e protegidas. Configurar um firewall manualmente com as regras de saída e FQDNs necessários é um processo complicado, especialmente se seu único requisito for criar um cluster AKS isolado sem dependências de saída para a inicialização do cluster.

Para reduzir o risco de exfiltração de dados, o cluster isolado de rede permite inicializar o cluster AKS sem dependências de rede de saída, até mesmo para buscar componentes/imagens de cluster do Microsoft Artifact Registry (MAR). O operador de cluster pode configurar incrementalmente o tráfego de saída permitido para cada cenário que deseja habilitar. Este artigo orienta você pelas etapas de criação de um cluster isolado de rede.

Antes de começar

Leia a visão geral conceitual desse recurso, que fornece uma explicação de como os clusters isolados de rede funcionam. O artigo introdutório também:
- Explica duas opções para o recurso privado do Azure Container Registry (ACR) usado para a inicialização do cluster - ACR gerido pelo AKS ou ACR próprio.
- Explica dois modos privados de cluster para criar acesso privado a servidor API - baseado em links privados ou integração VNet com servidor API.
- Explica os dois tipos de saída para controle de saída de cluster - none ou block (visualização).
- Descreve as limitações atuais de clusters isolados de rede.

Observação

O tipo de saída none está geralmente disponível. O tipo block de saída está em prévia.

Importante

Os recursos de pré-visualização do AKS estão disponíveis numa base de autosserviço e adesão voluntária. As visualizações prévias são fornecidas "como estão" e "conforme disponíveis" e são excluídas dos contratos de nível de serviço e da garantia limitada. As versões de teste do AKS são parcialmente cobertas pelo suporte ao cliente numa base de melhor esforço. Assim sendo, estas funcionalidades não se destinam ao uso em produção. Para obter mais informações, consulte os seguintes artigos de suporte:

Utilize o ambiente Bash no Azure Cloud Shell. Para obter mais informações, consulte Introdução ao Azure Cloud Shell.
Se preferir executar comandos de referência da CLI localmente, instale o CLI do Azure. Se estiver a usar Windows ou macOS, considere executar o CLI do Azure num contentor Docker. Para obter mais informações, consulte Como executar a CLI do Azure em um contêiner do Docker.
- Se você estiver usando uma instalação local, entre na CLI do Azure usando o comando az login . Para concluir o processo de autenticação, siga os passos exibidos no seu terminal. Para outras opções de entrada, consulte Autenticar no Azure usando a CLI do Azure.
- Quando solicitado, instale a extensão do CLI do Azure na primeira utilização. Para obter mais informações sobre extensões, consulte Usar e gerenciar extensões com a CLI do Azure.
- Execute az version para descobrir a versão e as bibliotecas dependentes que estão instaladas. Para atualizar para a versão mais recente, execute az upgrade.

Este artigo requer a versão 2.73.0 ou posterior da CLI do Azure. Se você estiver usando o Azure Cloud Shell, a versão mais recente já está instalada lá.
Você deve instalar a extensão da CLI do Azure versão aks-preview ou posterior, se estiver a usar o tipo de saída block (pré-visualização).
- Se você ainda não tiver a aks-preview extensão, instale-a usando o az extension add comando.
```
az extension add --name aks-preview
```
- Se você já tiver a aks-preview extensão, atualize-a para garantir que você tenha a versão mais recente usando o az extension update comando.
```
az extension update --name aks-preview
```

Clusters isolados de rede são suportados em clusters AKS usando o Kubernetes versão 1.30 ou superior.
Se você estiver optando por usar a opção Bring your own (BYO) Azure Container Registry (ACR), precisará garantir que o ACR seja a camada de serviço Premium SKU.
Se estiver a usar um cluster isolado em rede configurado com API Server VNet Integration, siga os pré-requisitos e orientações em Use API Server VNet Integration with Azure Kubernetes Service.

Definir variáveis de ambiente

Defina as variáveis de ambiente utilizadas ao longo deste artigo. O nome ACR deve ser globalmente único e conter apenas caracteres alfanuméricos minúsculos.

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

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

Uma conta do Azure com uma assinatura ativa. Se você não tiver uma, crie uma conta gratuita antes de começar.
Instala e configura o Terraform.
CLI do Azure instalada e com sessão iniciada com az login, usada para verificar a implementação e estabelecer ligação ao cluster. Instala o CLI do Azure se ainda não o tiveres.
kubectl instalado para se ligar ao cluster. Se você usa o Azure Cloud Shell, kubectl já está instalado. Para instalar localmente, use o az aks install-cli comando.
jq instalado, usado para analisar o estado do Terraform ao verificar a implementação. O Azure Cloud Shell já tem o jq instalado.

Implantar um cluster isolado de rede com ACR gerenciado pelo AKS

O AKS cria, gerencia e reconcilia um recurso ACR nessa opção. Você não precisa atribuir permissões ou gerenciar o ACR. O AKS gerencia as regras de cache, o link privado e o ponto de extremidade privado usados no cluster isolado da rede.

Criar um cluster isolado de rede

Ao criar um cluster AKS isolado em rede, escolha um dos seguintes modos privados de cluster: Integração VNet baseada em links privados ou API Server VNet.

Define a fonte do artefacto e o tipo de saída com base nos requisitos de isolamento da tua rede.

Parâmetro	Valores aceites / efeito
`--bootstrap-artifact-source`	`Direct`extrai imagens diretamente do Microsoft Artifact Registry (MAR) e não está isolado na rede. `Cache` extrai imagens de um ACR privado e é isolado pela rede.
`--outbound-type`	`none` Não configura as ligações de saída para o cluster, por isso podes configurá-las. `block` (pré-visualização) bloqueia todas as ligações de saída.

Baseado em link privado

Crie um cluster isolado de rede baseado em link privado executando o comando az aks create com --bootstrap-artifact-source, --enable-private-clustere --outbound-type parâmetros.

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

Integração de Servidor API na VNet

Crie um cluster isolado de rede configurado com a Integração VNet do API Server executando o comando az aks create com os parâmetros --bootstrap-artifact-source, --enable-private-cluster, --enable-apiserver-vnet-integration e --outbound-type.

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

Atualizar um cluster AKS existente para o tipo isolado de rede

Se você preferir habilitar o isolamento de rede em um cluster AKS existente em vez de criar um novo cluster, use o comando az aks update .

Para habilitar o recurso isolado de rede em um cluster AKS existente, primeiro execute o seguinte comando para atualizar bootstrap-artifact-source:

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

Depois tens de reimaginar manualmente todos os pools de nós existentes:

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

Observação

Você precisa garantir que a saída esteja disponível até que a primeira reatualização de imagem seja concluída. Para verificar se a reimagem foi concluída, execute:

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

Aguarde e verifique se a reimagem foi concluída e, em seguida, execute o seguinte comando para atualizar outbound-type:

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

Importante

Lembre-se de reimaginar instantaneamente os pools de nós do cluster após atualizar a fonte de artefatos para Cache. Caso contrário, o recurso não terá efeito para o cluster.

Implante um cluster isolado de rede utilizando o seu próprio ACR

AKS suporta trazer o seu próprio (BYO) ACR. Para suportar o cenário BYO ACR, deverá configurar um ponto de extremidade privado ACR e uma zona DNS privada antes de criar o cluster AKS.

As etapas a seguir mostram como preparar esses recursos:

Rede virtual personalizada e sub-redes para AKS e ACR.
ACR, regra de cache ACR, ponto final privado e zona de DNS privada.
A identidade do plano de controlo personalizado e a identidade do kubelet.

Etapa 1: Criar a rede virtual e as sub-redes

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

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

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

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

Etapa 2: Desabilitar a conectividade de saída de rede virtual (opcional)

Por exemplo, torne a sub-rede AKS privada definindo o seu acesso de saída predefinido para false.

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

Para outros métodos suportados e considerações de transição, veja Desativar a conectividade de saída da rede virtual.

Etapa 3: Criar o ACR e habilitar o cache de artefatos

Crie o ACR com o acesso à rede pública desativado.

az acr create --resource-group ${RESOURCE_GROUP} --name ${REGISTRY_NAME} --sku Premium --public-network-enabled false

REGISTRY_ID=$(az acr show --name ${REGISTRY_NAME} -g ${RESOURCE_GROUP}  --query 'id' --output tsv)

Crie uma regra de cache ACR usando o seguinte comando para permitir que os utilizadores armazenem em cache imagens e binários de contentores MAR no novo ACR. O nome da regra da cache e os nomes dos repositórios devem seguir as orientações da secção seguinte.
```
az acr cache create -n aks-managed-mcr -r ${REGISTRY_NAME} -g ${RESOURCE_GROUP} --source-repo "mcr.microsoft.com/*" --target-repo "aks-managed-repository/*"
```

Observação

Com o BYO ACR, é sua responsabilidade garantir que a regra de cache ACR seja criada e mantida corretamente como acima. Esta etapa é fundamental para a criação, o funcionamento e a atualização do cluster. Esta regra de cache NÃO deve ser modificada.

Etapa 4: Criar um ponto de extremidade privado para o ACR

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

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

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

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

Etapa 5: Criar uma zona DNS privada e adicionar registros

Crie uma zona DNS privada chamada privatelink.azurecr.io. Adicione os registos para o ponto de extremidade REST do registo {REGISTRY_NAME}.azurecr.io e o ponto de extremidade de dados do registo {REGISTRY_NAME}.{LOCATION}.data.azurecr.io.

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

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

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

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

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

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

Etapa 6: Criar plano de controle e identidades kubelet

Identidade do plano de controlo

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

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

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

Identidade Kubelet

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

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

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

Se estiver a atualizar um cluster AKS existente, ignore os comandos de criação de identidade anteriores e recupere o ID de objeto identidade kubelet existente:

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

Atribuir à identidade do kubelet permissões de extração do ACR

Verifique o modo de permissões de atribuição de funções do registo e selecione a função de extração correspondente. Os registos com ABAC ativado utilizam a função Container Registry Repository Reader. Os registos sem ABAC ativado utilizam a função AcrPull.

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

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

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

Depois de configurar esses recursos, você pode continuar a criar o cluster AKS isolado de rede com o BYO ACR.

Etapa 7: Criar cluster isolado de rede usando BYO ACR

Ao criar um cluster isolado em rede, escolha um dos seguintes modos de cluster privado: Private Link-Based ou API Server VNet Integration.

Define a fonte do artefacto e o tipo de saída com base nos requisitos de isolamento da tua rede.

Parâmetro	Valores aceites / efeito
`--bootstrap-artifact-source`	`Direct`extrai imagens diretamente do Microsoft Artifact Registry (MAR) e não está isolado na rede. `Cache` extrai imagens de um ACR privado e é isolado pela rede.
`--outbound-type`	`none` Não configura as ligações de saída para o cluster, por isso podes configurá-las. `block` (pré-visualização) bloqueia todas as ligações de saída.

Baseado em link privado

Crie um cluster isolado de rede baseado em link privado que acesse seu ACR executando o comando az aks create com os parâmetros necessários.

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

Integração de Servidor API na VNet

Para um cluster isolado de rede configurado com API Server VNet Integration, crie primeiro uma sub-rede e atribua o papel correto com os seguintes comandos:

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

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

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

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

Crie um cluster isolado de rede privada configurado com API Server VNet Integration e aceda ao seu ACR executando o comando az aks create com os parâmetros necessários.

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

Atualizar um cluster AKS existente

Se você preferir habilitar o isolamento de rede em um cluster AKS existente em vez de criar um novo cluster, use o comando az aks update .

Ao criar o endereço privado e a zona DNS privada para o ACR BYO, utilize a rede virtual e as sub-redes do cluster AKS já existentes. Ao atribuir a função AcrPull adequada à identidade kubelet, utilize a identidade kubelet já existente do cluster AKS existente.

Para habilitar o recurso isolado de rede em um cluster AKS existente, primeiro execute o seguinte comando para atualizar bootstrap-artifact-source:

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

Depois tens de reimaginar manualmente todos os pools de nós existentes:

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

Observação

Você precisa garantir que a saída esteja disponível até que a primeira reatualização de imagem seja concluída. Para verificar se a reimagem foi concluída, execute:

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

Aguarde e verifique se a reimagem foi concluída e, em seguida, execute o seguinte comando para atualizar outbound-type:

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

Importante

Lembre-se de reimaginar instantaneamente os pools de nós do cluster após atualizar a fonte de artefatos para Cache. Caso contrário, o recurso não terá efeito para o cluster.

Atualize o seu ID ACR

Pode atualizar o ACR privado utilizado por um cluster com isolamento de rede. Para identificar o ID do recurso ACR, use o az aks show comando.

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

A atualização do ID ACR é realizada executando o az aks update comando com os --bootstrap-artifact-source parâmetros e --bootstrap-container-registry-resource-id .

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

Ao atualizar a ID ACR em um cluster existente, você precisa recriar manualmente a imagem de todos os nós existentes.

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

Importante

Lembre-se de criar uma nova imagem dos pools de nós do cluster depois de habilitar o recurso de cluster isolado de rede. Caso contrário, o recurso não terá efeito para o cluster.

Implementar um cluster isolado na rede com o Terraform

Observação

O código de exemplo deste artigo encontra-se no repositório Azure Terraform GitHub. Pode consultar o registo de resultados dos testes das versões atuais e anteriores do Terraform.

Veja mais artigos e código de exemplo mostrando como usar o Terraform para gerenciar recursos do Azure.

Esta amostra do Terraform implementa um cluster isolado na rede utilizando a opção ACR gerida por AKS descrita anteriormente neste artigo. O provedor AzureRM ainda não expõe todas as definições de arranque com isolamento de rede que este exemplo utiliza, pelo que o exemplo recorre ao provedor AzAPI para implementar o recurso de cluster gerido com a versão da API necessária. Um exemplo de Terraform para a opção de trazer o seu próprio ACR (BYO) não está disponível neste momento. Para usar o BYO ACR, siga as orientações da CLI do Azure apresentadas anteriormente neste artigo.

O exemplo utiliza os seguintes recursos:

Um grupo de recursos (Microsoft.Resources/resourceGroups).
Um cluster AKS isolado na rede (Microsoft.ContainerService/managedClusters) que utiliza:
- Uma identidade gerida atribuída pelo sistema.
- Um único pool de nós do sistema com Standard_D2s_v3 nó e o dimensionamento automático desativado.
- O plugin de rede azure, com outboundType definido como none, para que o cluster não tenha dependências de rede de saída para o arranque inicial.
- apiServerAccessProfile.enablePrivateCluster definido para true, que cria um cluster privado privado baseado em links.
- bootstrapProfile.artifactSourcedefinido para Cache, para que o AKS crie, gere e reconcilie a sua própria cache ACR para arrancar o cluster em vez de puxar diretamente do Microsoft Artifact Registry (MAR). Como descrito anteriormente neste artigo, não precisa de criar ou gerir este ACR por si próprio, e o AKS trata das regras de cache, do link privado e do endpoint privado que o cluster isolado na rede utiliza.

O cluster é criado com a versão Kubernetes padrão suportada na região de implementação. Para fixar uma versão específica, adicione kubernetesVersion ao bloco properties do cluster em main.tf e confirme que a versão está disponível na região utilizando o comando az aks get-versions.

Crie um diretório para testar o código de exemplo do Terraform e torne-o o diretório atual.

Crie um ficheiro com nome main.tf e copie para ele a seguinte configuração de exemplo testada.

terraform {
  required_version = ">= 1.6.0"

  required_providers {
    azapi = {
      source  = "Azure/azapi"
      version = "~> 2.0"
    }
    random = {
      source  = "hashicorp/random"
      version = "~> 3.6"
    }
  }
}

provider "azapi" {}

resource "random_string" "suffix" {
  length  = 6
  upper   = false
  special = false
}

locals {
  location            = "westus2"
  resource_group_name = "rg-aks-network-isolated-${random_string.suffix.result}"
  aks_name            = "aks-netisolated-${random_string.suffix.result}"
  dns_prefix          = "aksnetiso${random_string.suffix.result}"
}

resource "azapi_resource" "resource_group" {
  type     = "Microsoft.Resources/resourceGroups@2024-03-01"
  name     = local.resource_group_name
  location = local.location
}

resource "azapi_resource" "aks_cluster" {
  type      = "Microsoft.ContainerService/managedClusters@2025-08-01"
  name      = local.aks_name
  parent_id = azapi_resource.resource_group.id
  location  = local.location

  identity {
    type = "SystemAssigned"
  }

  body = {
    properties = {
      dnsPrefix = local.dns_prefix
      agentPoolProfiles = [
        {
          name              = "systempool"
          count             = 1
          vmSize            = "Standard_D2s_v3"
          mode              = "System"
          osType            = "Linux"
          type              = "VirtualMachineScaleSets"
          enableAutoScaling = false
        }
      ]
      networkProfile = {
        networkPlugin = "azure"
        outboundType  = "none"
      }
      apiServerAccessProfile = {
        enablePrivateCluster = true
      }
      bootstrapProfile = {
        artifactSource = "Cache"
      }
    }
  }
}

Inicializar Terraform

Execute terraform init para inicializar a implantação do Terraform. Este comando transfere os fornecedores azapi e random necessários para gerir os recursos neste exemplo.

terraform init -upgrade

Formatar e validar a configuração

Execute terraform fmt para formatar o ficheiro de configuração e terraform validate confirmar que a configuração é sintaticamente válida.

terraform fmt
terraform validate

Criar um plano de execução do Terraform

Execute terraform plan para criar um plano de execução.

terraform plan -out main.tfplan

Aplicar um plano de execução do Terraform

Execute terraform apply para aplicar o plano de execução à sua subscrição do Azure.

terraform apply main.tfplan

A criação do grupo de recursos e do cluster AKS privado e isolado da rede demora vários minutos a ser concluída.

Verificar a implantação

Esta amostra não define outputs do Terraform, por isso utilize terraform show -json com jq para obter os nomes gerados do grupo de recursos e do cluster a partir do estado dos recursos após a conclusão de terraform apply. Geres ambos os recursos com o azapi fornecedor, e o atributo deles name contém o nome do recurso resolvido.

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

Confirme que o cluster foi criado com as definições de isolamento de rede esperadas usando o az aks show comando.

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

A saída mostra outboundType definido para none, artifactSource definido para Cache, e privateCluster definido para true, confirmando que o cluster está isolado na rede e arranca a partir da cache ACR gerida pelo AKS.

Ligar ao cluster

Como este é um cluster privado, ligue-se a partir de um cliente que tenha visibilidade de rede para o ponto final privado do cluster, como uma VM na mesma rede virtual ou numa rede virtual emparelhada, ou do Azure Cloud Shell, se estiver ligado à rede virtual do cluster. Obtenha as credenciais do cluster usando o az aks get-credentials comando e depois verifique a ligação usando o kubectl get nodes comando.

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

Limpeza de recursos

Se já não precisar dos recursos criados neste artigo, remova-os para evitar incorrer em novas despesas.

Warning

Executar terraform destroy remove todos os recursos rastreados no ficheiro de estado Terraform para esta configuração, incluindo o grupo de recursos e o cluster AKS. Revê o plano cuidadosamente antes de destruires e evita executá-lo contra infraestruturas partilhadas ou de produção.

Execute terraform plan com a opção -destroy para verificar o que o Terraform irá remover.

terraform plan -destroy -out main.destroy.tfplan

Execute terraform apply para aplicar o plano de eliminação e remover todos os recursos criados por este exemplo.

terraform apply main.destroy.tfplan

Validar que o cluster isolado da rede está ativado no AKS

Para validar que a funcionalidade de cluster isolado de rede está ativada, use o az aks show comando.

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

O resultado seguinte mostra um cluster isolado da rede configurado com o tipo de saída none. Confirme que outboundType está definido como none ou block, e que artifactSource está definido como Cache. O campo containerRegistryId identifica o ACR usado para bootstrapping.

{
  "kubernetesVersion": "<major>.<minor>.<patch>",
  "name": "myAKSCluster",
  "type": "Microsoft.ContainerService/ManagedClusters",
  "properties": {
    "networkProfile": {
      "outboundType": "none"
    },
    "bootstrapProfile": {
      "artifactSource": "Cache",
      "containerRegistryId": "/subscriptions/my-subscription-id/resourceGroups/my-node-resource-group-name/providers/Microsoft.ContainerRegistry/registries/my-registry-name"
    }
  }
}

Desativar cluster isolado de rede no AKS

Desative o recurso de cluster isolado de rede executando o comando az aks update com os parâmetros --bootstrap-artifact-source e --outbound-type.

az aks update --resource-group ${RESOURCE_GROUP} --name ${AKS_NAME} --bootstrap-artifact-source Direct --outbound-type LoadBalancer

Ao desabilitar o recurso em um cluster existente, você precisa recriar manualmente a imagem de todos os nós existentes.

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

Importante

Lembre-se de criar uma nova imagem dos pools de nós do cluster depois de desabilitar o recurso de cluster isolado de rede. Caso contrário, o recurso não terá efeito para o cluster.

Solução de problemas

Se estiver a enfrentar problemas, como falhas ao extrair imagens, consulte Solucionar problemas de clusters isolados na rede do Serviço Azure Kubernetes (AKS).

Próximos passos

Se você quiser configurar a configuração de restrição de saída usando o Firewall do Azure, visite Controlar o tráfego de saída usando o Firewall do Azure no AKS.

Se quiser restringir como os pods se comunicam entre eles e as restrições de tráfego East-West dentro do cluster, veja Proteger o tráfego entre pods usando políticas de rede no AKS.

Comentários

Esta página foi útil?

Última atualização a 2026-09-14

Criar um cluster isolado de rede do Serviço Kubernetes do Azure (AKS)

Antes de começar

Definir variáveis de ambiente

Implantar um cluster isolado de rede com ACR gerenciado pelo AKS

Criar um cluster isolado de rede

Baseado em link privado

Integração de Servidor API na VNet

Atualizar um cluster AKS existente para o tipo isolado de rede

Implante um cluster isolado de rede utilizando o seu próprio ACR

Etapa 1: Criar a rede virtual e as sub-redes

Etapa 2: Desabilitar a conectividade de saída de rede virtual (opcional)

Etapa 3: Criar o ACR e habilitar o cache de artefatos

Etapa 4: Criar um ponto de extremidade privado para o ACR

Etapa 5: Criar uma zona DNS privada e adicionar registros

Etapa 6: Criar plano de controle e identidades kubelet

Identidade do plano de controlo

Identidade Kubelet

Atribuir à identidade do kubelet permissões de extração do ACR

Etapa 7: Criar cluster isolado de rede usando BYO ACR

Baseado em link privado

Integração de Servidor API na VNet

Atualizar um cluster AKS existente

Atualize o seu ID ACR

Implementar um cluster isolado na rede com o Terraform

Inicializar Terraform

Formatar e validar a configuração

Criar um plano de execução do Terraform

Aplicar um plano de execução do Terraform

Verificar a implantação

Ligar ao cluster

Limpeza de recursos

Validar que o cluster isolado da rede está ativado no AKS

Desativar cluster isolado de rede no AKS

Solução de problemas

Próximos passos

Comentários

Recursos adicionais