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

As organizações geralmente têm requisitos de segurança e conformidade rigorosos para regular o tráfego de rede de saída de um cluster para eliminar riscos de exfiltração de dados. Por padrão, os clusters padrão do AKS (Serviço de Kubernetes do Azure) do SKU têm acesso irrestrito à Internet de saída. Esse nível de acesso à rede permite que os nós e os serviços que você executa acessem recursos externos, conforme necessário. Se quiser restringir o tráfego de saída, um número limitado de portas e endereços precisar estar acessível para manter a integridade das tarefas de manutenção de cluster. O documento conceitual sobre as regras de saída de rede e FQDN para clusters do AKS fornece uma lista de pontos de extremidade necessários para o cluster do AKS e seus complementos e recursos 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 necessárias e FQDNs é um processo trabalhoso, especialmente se o único requisito for criar um cluster AKS isolado sem dependências externas para a inicialização do cluster.

Para reduzir o risco de exfiltração de dados, o cluster isolado de rede permite inicializar o cluster do AKS sem nenhuma dependência de rede de saída, mesmo para buscar componentes/imagens de cluster do Registro de Artefatos da Microsoft (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

Observação

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

Importante

As versões prévias de recursos do AKS estão disponíveis em uma base de autoatendimento e aceitação. As versõ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 prévias do AKS são parcialmente cobertas pelo suporte ao cliente em uma base de melhor esforço. Dessa forma, esses recursos não são destinados ao uso em produção. Para obter mais informações, consulte os seguintes artigos de suporte:

  • 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 aks-previewextensão da CLI do Azure versão 9.0.0b2 ou posterior se estiver usando o tipo block de saída (versão prévia).
    • Se você ainda não tem a extensão aks-preview, instale-a usando o comando az extension add. 
      az extension add --name aks-preview
    • Se você já tem a extensão aks-preview, atualize-a para garantir que você tenha a última versão usando o comando az extension update. 
      az extension update --name aks-preview

Definir variáveis de ambiente

Defina as variáveis de ambiente usadas ao longo deste artigo. O nome do ACR deve ser globalmente exclusivo 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.
  • Instale e configure o Terraform.
  • A CLI do Azure instalada e conectada usando az login, usado para verificar a implantação e conectar-se ao cluster. Instale CLI do Azure se você ainda não o tiver.
  • kubectl instalado para se conectar ao cluster. Se você usar o Azure Cloud Shell, o kubectl já estará instalado. Para instalá-lo localmente, use o az aks install-cli comando.
  • jq instalado, usado para analisar o estado do Terraform ao verificar a implantação. O Azure Cloud Shell já vem com jq instalado.

Implantar um cluster isolado de rede com o 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 de rede.

Criar um cluster isolado de rede

Ao criar um cluster AKS com isolamento de rede, escolha um dos seguintes modos de cluster privado: baseado em Private Link ou Integração de VNet do Servidor de API.

Defina a origem e o tipo de saída do artefato com base nos requisitos de isolamento de rede.

Parâmetro Valores/efeito aceitos
--bootstrap-artifact-source Direct obtém imagens diretamente do Registro de Artefatos da Microsoft (MAR) e não tem isolamento de rede. Cache extrai imagens de um ACR privado e é isolado da rede.
--outbound-type none não configura conexões de saída para o cluster, portanto, você pode configurá-las. block (versão prévia) bloqueia todas as conexões de saída.

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 à VNet

Crie um cluster isolado de rede configurado com a Integração VNet do Servidor de API 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 do AKS existente para o tipo isolado de rede

Se você preferir habilitar o isolamento de rede em um cluster do 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 do 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

Você precisa refazer manualmente a imagem de 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 exista até que a primeira imagem seja concluída. Para verificar se a imagem nova 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 nova imagem foi concluída e 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 reconfigurar os pools de nós do cluster imediatamente após atualizar a origem do artefato para o cache. Caso contrário, o recurso não terá efeito para o cluster.

Implantar um cluster isolado da rede com o seu próprio ACR

O AKS dá suporte à criação de seu próprio ACR (BYO). Para dar suporte ao cenário do BYO ACR, você precisa configurar um ponto de extremidade privado do ACR e uma zona DNS privada antes de criar o cluster do AKS.

As etapas a seguir mostram como preparar esses recursos:

  • Rede virtual personalizada e sub-redes para AKS e ACR.
  • ACR, regra de cache do ACR, ponto de extremidade privado e zona DNS privada.
  • Identidade do plano de controle personalizado e identidade 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 da rede virtual (opcional)

Por exemplo, torne a sub-rede do AKS privada definindo seu acesso de saída padrão como 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 com suporte e considerações de transição, consulte Desabilitar a conectividade de saída da rede virtual.

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

  1. Crie o ACR com o acesso à rede pública desabilitado.

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

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

  2. Crie uma regra de cache do ACR usando o comando a seguir para permitir que os usuários armazenem em cache imagens e binários de contêiner MAR no novo ACR. O nome da regra de cache e os nomes de repositório devem seguir as diretrizes na próxima seção.

    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 do ACR seja criada e mantida corretamente como acima. Esta etapa é essencial para a criação, o funcionamento e a atualização do cluster. Essa 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

Criar uma zona de DNS privado chamada privatelink.azurecr.io. Adicione os registros para o ponto de extremidade REST {REGISTRY_NAME}.azurecr.io do registro e o ponto de extremidade de dados {REGISTRY_NAME}.{LOCATION}.data.azurecr.io do registro.

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 identidades de plano de controle e kubelet

Identidade do painel de controle

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 do 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 você estiver atualizando um cluster do AKS existente, ignore os comandos de criação de identidade anteriores e recupere a ID do objeto de identidade kubelet existente:

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

Conceda permissões de pull do ACR à identidade do kubelet

Verifique o modo de permissões para atribuição de função do registro e selecione a função de extração correspondente. Os registros habilitados para ABAC usam a função Container Registry Repository Reader. Os registros não habilitados para ABAC usam a AcrPull função.

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 do AKS isolado de rede com o BYO ACR.

Etapa 7: Criar um cluster isolado de rede usando o BYO ACR

Ao criar um cluster com isolamento de rede, escolha um dos seguintes modos de cluster privado: baseado em Link Privado ou Integração de VNet do Servidor de API.

Defina a origem e o tipo de saída do artefato com base nos requisitos de isolamento de rede.

Parâmetro Valores/efeito aceitos
--bootstrap-artifact-source Direct obtém imagens diretamente do Registro de Artefatos da Microsoft (MAR) e não tem isolamento de rede. Cache extrai imagens de um ACR privado e é isolado da rede.
--outbound-type none não configura conexões de saída para o cluster, portanto, você pode configurá-las. block (versão prévia) bloqueia todas as conexões de saída.

Crie um cluster isolado de rede baseado em link privado que acesse o 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 à VNet

Para um cluster isolado de rede configurado com a Integração VNet do Servidor de API, primeiro crie uma sub-rede e atribua a função correta 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 a Integração VNet do Servidor de API e acesse o 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 de AKS existente

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

Ao criar o ponto de extremidade privado e a zona DNS privada para o BYO ACR, use a rede virtual e as sub-redes existentes do cluster do AKS existente. Ao atribuir a função de extração do ACR apropriada à identidade do kubelet, use a identidade existente do kubelet do cluster AKS existente.

Para habilitar o recurso isolado de rede em um cluster do 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}

Você precisa refazer manualmente a imagem de 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 exista até que a primeira imagem seja concluída. Para verificar se a imagem nova 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 nova imagem foi concluída e 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 reconfigurar os pools de nós do cluster imediatamente após atualizar a origem do artefato para o cache. Caso contrário, o recurso não terá efeito para o cluster.

Atualizar sua ID do ACR

Você pode atualizar o ACR privado usado com um cluster isolado de rede. Para identificar a ID do recurso do ACR, use o comando az aks show.

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

A atualização da ID do ACR é executada executando o comando az aks update com os parâmetros --bootstrap-artifact-source 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 do ACR em um cluster existente, você precisará recriar a imagem manualmente de todos os nós existentes.

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

Importante

Lembre-se de recriar a 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.

Implantar um cluster isolado de rede com o Terraform

Observação

O código de exemplo deste artigo está no repositório GitHub Azure Terraform. Você pode exibir o log de resultados do teste para versões atuais e anteriores do Terraform.

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

Este exemplo do Terraform implanta um cluster isolado de rede usando a opção ACR gerenciada pelo AKS descrita anteriormente neste artigo. O provedor AzureRM ainda não expõe todas as configurações de bootstrap com isolamento de rede utilizadas por este exemplo; por isso, o exemplo usa o provedor AzAPI para implantar o recurso de cluster gerenciado usando a versão de API necessária. No momento, não há um exemplo de Terraform disponível para a opção BYO (bring your own) do ACR. Para usar o BYO ACR, siga as diretrizes de CLI do Azure anteriormente neste artigo.

O exemplo implanta os seguintes recursos:

  • Um grupo de recursos (Microsoft.Resources/resourceGroups).
  • Um cluster AKS isolado de rede (Microsoft.ContainerService/managedClusters) que usa:
    • Uma identidade gerenciada atribuída pelo sistema.
    • Um único pool de nós do sistema com apenas um nó Standard_D2s_v3 e dimensionamento automático desativado.
    • O plug-in de rede azure, com outboundType definido como none, para que o cluster não tenha dependências de rede de saída para a inicialização.
    • apiServerAccessProfile.enablePrivateCluster configurado como true, o que cria um cluster privado baseado em Private Link.
    • bootstrapProfile.artifactSource definido como Cache, de modo que o AKS cria, gerencia e reconcilia seu próprio cache do ACR para inicializar o cluster, em vez de extrair diretamente do Registro de Artefatos da Microsoft (MAR). Conforme descrito anteriormente neste artigo, você não precisa criar ou gerenciar esse ACR por conta própria e o AKS lida com as regras de cache, o link privado e o ponto de extremidade privado que o cluster isolado de rede usa.

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

  1. Crie um diretório para testar o código terraform de exemplo e torná-lo o diretório atual.

  2. Crie um arquivo nomeado main.tf e copie a seguinte configuração de exemplo testada nele.

    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. Esse comando baixa os provedores random e azapi necessários para gerenciar os recursos neste exemplo.

terraform init -upgrade

Formatar e validar a configuração

Execute terraform fmt para formatar o arquivo de configuração e terraform validate confirmar se 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 assinatura de Azure.

terraform apply main.tfplan

A criação do grupo de recursos e do cluster AKS privado isolado pela rede leva vários minutos para ser concluído.

Verificar a implantação

Este exemplo não define outputs do Terraform, portanto, use terraform show -json com jq para recuperar o grupo de recursos gerado e os nomes do cluster a partir do estado dos recursos após a conclusão de terraform apply. Você gerencia ambos os recursos com o provedor azapi, e o atributo name deles 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 se o cluster foi criado com as configurações isoladas 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 como none, artifactSource definido como Cache e privateCluster definido como true, confirmando que o cluster está isolado da rede e faz o bootstrap a partir do cache do ACR gerenciado pelo AKS.

Conectar-se ao cluster

Como este é um cluster privado, conecte-se a partir de um cliente que tenha visibilidade de rede para o ponto de extremidade privado do cluster, como uma VM na mesma rede virtual ou em uma rede virtual emparelhada, ou o Azure Cloud Shell, se ele estiver conectado à rede virtual do cluster. Obtenha as credenciais do cluster usando o az aks get-credentials comando e verifique a conexão usando o kubectl get nodes comando.

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

Limpar os recursos

Se você não precisar mais dos recursos criados neste artigo, remova-os para evitar incorrer em encargos adicionais.

Warning

A execução terraform destroy remove todos os recursos rastreados no arquivo de estado do Terraform para essa configuração, incluindo o grupo de recursos e o cluster do AKS. Examine o plano cuidadosamente antes de destruir e evite executá-lo na infraestrutura compartilhada ou de produção.

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

terraform plan -destroy -out main.destroy.tfplan

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

terraform apply main.destroy.tfplan

Validar se o cluster isolado de rede está habilitado no AKS

Para validar se o recurso de cluster isolado de rede está habilitado, use o az aks show comando.

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

A saída a seguir mostra um cluster isolado de rede configurado com o tipo de saída none. Confirme se outboundType está definido como none ou block, e isso artifactSource está definido como Cache. O containerRegistryId campo identifica o ACR usado para inicialização.

{
  "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"
    }
  }
}

Desabilitar cluster isolado de rede no AKS

Desabilite o recurso de cluster isolado da 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

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

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

Importante

Lembre-se de recriar a 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.

Resolução de problemas

Se você estiver enfrentando problemas, como falhas ao puxar a imagem, confira Solucionar problemas em clusters isolados de rede do AKS (Serviço de Kubernetes do Azure).

Próximas etapas

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

Se você quiser restringir como os pods se comunicam entre si e as restrições de tráfego Leste-Oeste dentro do cluster, consulte Como proteger o tráfego entre pods usando as políticas de rede no AKS.

  • Última atualização em