Creare un cluster del servizio Azure Kubernetes isolato di rete

Le organizzazioni in genere hanno rigidi requisiti di sicurezza e conformità per regolare il traffico di rete in uscita da un cluster per eliminare i rischi di esfiltrazione dei dati. Per impostazione predefinita, i cluster del servizio Azure Kubernetes con SKU standard hanno accesso a Internet in uscita senza restrizioni. Questo livello di accesso alla rete consente a nodi e servizi in esecuzione di accedere alle risorse esterne in base alle esigenze. Se si vuole limitare il traffico in uscita, è necessario rendere accessibile un numero limitato di porte e indirizzi per mantenere l'integrità delle attività di manutenzione del cluster. Il documento concettuale sulle regole di rete e FQDN in uscita per i cluster del servizio Azure Kubernetes fornisce un elenco degli endpoint necessari per il cluster del servizio Azure Kubernetes e dei relativi componenti aggiuntivi e funzionalità facoltativi.

Una soluzione comune per limitare il traffico in uscita dal cluster consiste nell'usare un dispositivo firewall per limitare il traffico in base alle regole del firewall. Il firewall è applicabile quando l'applicazione richiede l'accesso in uscita, ma quando le richieste in uscita devono essere esaminate e protette. Configurare manualmente un firewall con le necessarie regole di egress e FQDN è un processo complesso, soprattutto se l'unico requisito è creare un cluster AKS isolato senza dipendenze in uscita per l'avvio del cluster.

Per ridurre il rischio di esfiltrazione dei dati, un cluster isolato di rete consente di eseguire il bootstrap del cluster di Azure Kubernetes Service (AKS) senza alcuna dipendenza di rete in uscita, nemmeno per il recupero di componenti/immagini del cluster dal registro Microsoft Artifact Registry (MAR). L'operatore del cluster potrebbe configurare in modo incrementale il traffico in uscita consentito per ogni scenario che vuole abilitare. Questo articolo illustra la procedura di creazione di un cluster isolato di rete.

Prima di iniziare

Nota

Il tipo in uscita none è disponibile a livello generale. Il tipo in uscita block è in anteprima.

Importante

Le funzionalità di anteprima del servizio Azure Kubernetes sono disponibili in modalità self-service e con consenso esplicito. Le anteprime vengono fornite "così come sono" e "come disponibili" e sono escluse dai contratti di servizio e dalla garanzia limitata. Le anteprime del servizio Azure Kubernetes sono parzialmente coperte dal supporto clienti con la massima diligenza possibile. Di conseguenza, queste funzionalità non sono destinate all'uso in ambienti di produzione. Per altre informazioni, vedere gli articoli di supporto seguenti:

  • Questo articolo richiede la versione 2.73.0 o successiva dell'interfaccia della riga di comando di Azure. Se si sta usando Azure Cloud Shell, la versione più recente è già installata.
  • È necessario installare l'estensione CLI di Azure versione aks-preview o successiva se si utilizza il tipo di traffico in uscita (anteprima).
    • Se l'estensione aks-preview non è ancora disponibile, installarla usando il comando az extension add. 
      az extension add --name aks-preview
    • Se l'estensione aks-preview è già disponibile, aggiornarla per assicurarsi di avere la versione più recente usando il comando az extension update. 
      az extension update --name aks-preview

Impostare le variabili di ambiente

Impostare le variabili di ambiente usate in questo articolo. Il nome dell'ACR deve essere univoco a livello globale e contenere solo caratteri alfanumerici minuscoli.

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}
  • Un account Azure con una sottoscrizione attiva. Se non ne hai uno, crea un account gratuito prima di iniziare.
  • Installare e configurare Terraform.
  • Interfaccia della riga di comando di Azure installata e accesso effettuato tramite az login, usato per verificare la distribuzione e connettersi al cluster. Installare interfaccia della riga di comando di Azure se non è già disponibile.
  • kubectl installato per connettersi al cluster. Se si usa Azure Cloud Shell, kubectl è già installato. Per installarlo in locale, usare il az aks install-cli comando .
  • jq installato, utilizzato per analizzare lo stato di Terraform durante la verifica della distribuzione. Azure Cloud Shell ha già jq installato.

Distribuire un cluster isolato dalla rete con ACR gestito dal servizio Azure Kubernetes

Il servizio Azure Kubernetes crea, gestisce e riconcilia una risorsa ACR in questa opzione. Non è necessario assegnare autorizzazioni o gestire ACR. Il servizio Azure Kubernetes gestisce le regole della cache, il collegamento privato e l'endpoint privato usati nel cluster isolato dalla rete.

Creare un cluster isolato dalla rete

Quando si crea un cluster AKS isolato dalla rete, scegliere una delle seguenti modalità di cluster privato: basata su Private Link o Integrazione della rete virtuale del server API.

Impostare l'origine dell'artefatto e il tipo in uscita in base ai requisiti di isolamento della rete.

Parametro Valori/effetto accettati
--bootstrap-artifact-source Direct estrae le immagini direttamente da Microsoft Artifact Registry (MAR) e non è isolato dalla rete. Cache estrae immagini da un Registro Azure Container (ACR) privato ed è isolato a livello di rete.
--outbound-type none non configura le connessioni in uscita per il cluster, quindi è possibile configurarle. block (anteprima) blocca tutte le connessioni in uscita.

Creare un cluster isolato basato su rete con collegamento privato eseguendo il comando az aks create con i parametri --bootstrap-artifact-source, --enable-private-cluster 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

Integrazione rete virtuale del server API

Creare un cluster isolato di rete configurato con integrazione VNet del Server API eseguendo il comando az aks create con i parametri --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

Aggiornare un cluster del servizio Azure Kubernetes esistente al tipo isolato dalla rete

Se si preferisce abilitare l'isolamento rete in un cluster del servizio Azure Kubernetes esistente anziché creare un nuovo cluster, usare il comando az aks update.

Per abilitare la funzionalità di isolamento della rete in un cluster del servizio Azure Kubernetes esistente, eseguire prima di tutto il comando seguente per aggiornare bootstrap-artifact-source:

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

È quindi necessario creare manualmente l'immagine di tutti i pool di nodi esistenti:

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

Nota

È necessario assicurarsi che la connessione esterna esista fino al completamento della prima creazione della nuova immagine. Per verificare se l'operazione di reinstallazione dell'immagine è stata completata, eseguire:

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

Attendere e assicurarsi che il ripristino dell'immagine sia completato, quindi eseguire il seguente comando per aggiornare outbound-type:

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

Importante

Ricordarsi di reimpostare istantaneamente i pool di nodi del cluster dopo aver aggiornato la sorgente degli artefatti a Cache. In caso contrario, la funzionalità non avrà effetto per il cluster.

Distribuire un cluster isolato dalla rete con ACR Bring Your Own

AKS supporta l'uso del proprio ACR (BYO). Per supportare lo scenario ACR BYO, è necessario configurare un endpoint privato ACR e una zona DNS privato prima di creare il cluster del servizio Azure Kubernetes.

La procedura seguente illustra come preparare queste risorse:

  • Rete virtuale e subnet personalizzate per servizio Azure Kubernetes e ACR.
  • ACR, regola della cache ACR, endpoint privato e zona DNS privato.
  • Identità del piano di controllo personalizzato e identità kubelet.

Passaggio 1: Creare la rete virtuale e le subnet

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

Passaggio 2: Disabilitare la connettività in uscita della rete virtuale (facoltativo)

Ad esempio, rendere privata la subnet di AKS impostando l'accesso predefinito in uscita su false.

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

Per altri metodi supportati e considerazioni sulla transizione, vedere Disabilitare la connettività in uscita della rete virtuale.

Passaggio 3: Creare l'ACR e abilitare la cache degli artefatti

  1. Creare l'ACR con accesso alla rete pubblica disabilitato.

    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. Creare una regola della cache del Registro Azure Container usando il comando seguente per consentire agli utenti di memorizzare nella cache immagini e file binari del contenitore MAR nel nuovo Registro Azure Container. Il nome della regola della cache e i nomi dei repository devono seguire le indicazioni riportate nella sezione successiva.

    az acr cache create -n aks-managed-mcr -r ${REGISTRY_NAME} -g ${RESOURCE_GROUP} --source-repo "mcr.microsoft.com/*" --target-repo "aks-managed-repository/*"

Nota

Con BYO ACR, è responsabilità dell'utente assicurarsi che la regola della cache dell'Azure Container Registry venga creata e mantenuta correttamente come sopra indicato. Questo passaggio è fondamentale per la creazione, il funzionamento e l'aggiornamento del cluster. Questa regola della cache non deve essere modificata.

Passaggio 4: Creare un endpoint privato per Azure Container Registry

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)

Passaggio 5: Creare una zona DNS privata e aggiungere record

Creare una zona DNS privato denominata privatelink.azurecr.io. Aggiungere i record per l'endpoint REST del registro {REGISTRY_NAME}.azurecr.io e l'endpoint dati del registro {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}

Passaggio 6: Creare il piano di controllo e le identità kubelet

Identità del piano di controllo

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)

Identità 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 si sta aggiornando un cluster AKS esistente, ignorare i comandi precedenti per la creazione dell'identità e recuperare l'ID oggetto dell'identità kubelet esistente:

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

Concedere le autorizzazioni per il pull di Registro Azure Container all'identità kubelet

Controllare la modalità delle autorizzazioni per l'assegnazione dei ruoli del registro e selezionare il ruolo di pull corrispondente. I registri basati su ABAC usano il ruolo Container Registry Repository Reader. I registri non abilitati per ABAC usano il ruolo 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

Dopo aver configurato queste risorse, è possibile procedere con la creazione del cluster del servizio Azure Kubernetes isolato dalla rete con ACR BYO.

Passaggio 7: Creare un cluster isolato dalla rete usando ACR BYO

Quando si crea un cluster isolato dalla rete, scegliere una delle seguenti modalità di cluster privato: basata su Private Link o Integrazione della rete virtuale del server API.

Impostare l'origine dell'artefatto e il tipo in uscita in base ai requisiti di isolamento della rete.

Parametro Valori/effetto accettati
--bootstrap-artifact-source Direct estrae le immagini direttamente da Microsoft Artifact Registry (MAR) e non è isolato dalla rete. Cache estrae immagini da un Registro Azure Container (ACR) privato ed è isolato a livello di rete.
--outbound-type none non configura le connessioni in uscita per il cluster, quindi è possibile configurarle. block (anteprima) blocca tutte le connessioni in uscita.

Creare un cluster isolato dalla rete basato su collegamento privato che accede all'ACR eseguendo il comando az aks create con i parametri necessari.

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

Integrazione rete virtuale del server API

Per un cluster isolato di rete configurato con Integrazione rete virtuale del server API, creare prima una subnet e assegnare il ruolo corretto con i comandi seguenti:

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

Crea un cluster isolato in rete privata configurato con l'Integrazione della rete virtuale del server API e accedi al tuo ACR eseguendo il comando az aks create con i parametri necessari.

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}

Aggiornare un cluster del servizio Azure Kubernetes esistente

Se si preferisce abilitare l'isolamento rete in un cluster del servizio Azure Kubernetes esistente anziché creare un nuovo cluster, usare il comando az aks update.

Quando si creano l'endpoint privato e la zona DNS privato per ACR BYO, usare la rete virtuale e le subnet esistenti del cluster del servizio Azure Kubernetes esistente. Quando assegni il ruolo AcrPull appropriato all'identità kubelet, usa l'identità kubelet esistente del cluster AKS esistente.

Per abilitare la funzionalità di isolamento della rete in un cluster del servizio Azure Kubernetes esistente, eseguire prima di tutto il comando seguente per aggiornare bootstrap-artifact-source:

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

È quindi necessario creare manualmente l'immagine di tutti i pool di nodi esistenti:

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

Nota

È necessario assicurarsi che la connessione esterna esista fino al completamento della prima creazione della nuova immagine. Per verificare se l'operazione di reinstallazione dell'immagine è stata completata, eseguire:

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

Attendere e assicurarsi che il ripristino dell'immagine sia completato, quindi eseguire il seguente comando per aggiornare outbound-type:

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

Importante

Ricordarsi di reimpostare istantaneamente i pool di nodi del cluster dopo aver aggiornato la sorgente degli artefatti a Cache. In caso contrario, la funzionalità non avrà effetto per il cluster.

Aggiornare l'ID ACR

È possibile aggiornare l'ACR privato utilizzato con un cluster con isolamento di rete. Per identificare l'ID risorsa ACR, usare il comando az aks show.

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

L'aggiornamento dell'ID ACR viene eseguito eseguendo il comando az aks update con i parametri --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>

Quando si aggiorna l'ID ACR in un cluster esistente, è necessario ricreare manualmente l'immagine di tutti i nodi esistenti.

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

Importante

Ricordarsi di creare nuovamente l'immagine dei pool di nodi del cluster dopo aver abilitato la funzionalità del cluster isolato dalla rete. In caso contrario, la funzionalità non avrà effetto per il cluster.

Distribuire un cluster isolato dalla rete con Terraform

Nota

Il codice di esempio per questo articolo si trova nel repository GitHub Azure Terraform. È possibile visualizzare il log dei risultati del test per le versioni correnti e precedenti di Terraform.

Vedere altri articoli e codice di esempio che illustrano come usare Terraform per gestire le risorse di Azure.

Questo esempio di Terraform distribuisce un cluster con isolamento di rete tramite l'opzione ACR gestito da AKS descritta in precedenza in questo articolo. Il provider AzureRM non espone ancora tutte le impostazioni di bootstrap isolate dalla rete usate da questo esempio, quindi l'esempio usa il provider AzAPI per distribuire la risorsa cluster gestita nella versione dell'API richiesta. Un esempio Terraform per l'opzione ACR Bring Your Own (BYO) non è attualmente disponibile. Per usare un ACR personalizzato, segui le istruzioni di interfaccia della riga di comando di Azure fornite in precedenza in questo articolo.

L'esempio distribuisce le risorse seguenti:

  • Gruppo di risorse (Microsoft.Resources/resourceGroups).
  • Un cluster AKS isolato dalla rete (Microsoft.ContainerService/managedClusters) che utilizza:
    • Identità gestita assegnata dal sistema.
    • Un singolo pool di nodi di sistema con un Standard_D2s_v3 nodo e la scalabilità automatica disabilitata.
    • Il plugin di rete azure, con outboundType impostato su none in modo che il cluster non abbia dipendenze dalla rete in uscita per il bootstrap.
    • apiServerAccessProfile.enablePrivateCluster impostato su true, che crea un cluster privato basato su Private Link.
    • bootstrapProfile.artifactSource impostato su Cache, in modo che AKS crei, gestisca e riconcili la propria cache ACR per avviare il cluster anziché eseguire il pull direttamente da Microsoft Artifact Registry (MAR). Come descritto in precedenza in questo articolo, non è necessario creare o gestire questo ACR e AKS gestisce le regole della cache, il collegamento privato e l'endpoint privato usati dal cluster con isolamento di rete.

Il cluster viene creato con la versione predefinita di Kubernetes supportata nell'area di distribuzione. Per bloccare una versione specifica, aggiungi kubernetesVersion al blocco properties del cluster in main.tf e verifica che la versione sia disponibile nella regione utilizzando il comando az aks get-versions.

  1. Creare una directory per testare il codice Terraform di esempio e impostarla come directory corrente.

  2. Creare un file denominato main.tf e copiarne la configurazione di esempio testata seguente.

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

Inizializza Terraform

Eseguire terraform init per inizializzare l'implementazione di Terraform. Questo comando scarica i provider azapi e random necessari per gestire le risorse di questo esempio.

terraform init -upgrade

Formattare e convalidare la configurazione

Eseguire terraform fmt per formattare il file di configurazione e terraform validate per verificare che la configurazione sia sintatticamente valida.

terraform fmt
terraform validate

Crea un piano di esecuzione di Terraform

Eseguire terraform plan per creare un piano di esecuzione.

terraform plan -out main.tfplan

Applicare un piano di esecuzione Terraform

Eseguire terraform apply per applicare il piano di esecuzione alla sottoscrizione Azure.

terraform apply main.tfplan

La creazione del gruppo di risorse e del cluster AKS privato e isolato dalla rete richiedono diversi minuti per essere completati.

Verificare la distribuzione

Questo esempio non definisce gli output Terraform, quindi usa terraform show -json con jq per recuperare dallo stato delle risorse i nomi generati del gruppo di risorse e del cluster dopo il completamento di terraform apply. È possibile gestire entrambe le risorse con il azapi provider e il relativo name attributo contiene il nome della risorsa risolta.

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')

Verificare che il cluster sia stato creato con le impostazioni di isolamento della rete previste usando il az aks show comando .

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

L'output mostra outboundType impostato su none, artifactSource impostato su Cache e privateCluster impostato su true, confermando che il cluster è isolato a livello di rete e viene inizializzato dalla cache ACR gestita da AKS.

Connettersi al cluster

Poiché si tratta di un cluster privato, connettiti da un client che abbia visibilità di rete verso l'endpoint privato del cluster, ad esempio una VM nella stessa rete virtuale o in una rete virtuale con peering, oppure Azure Cloud Shell, se connesso alla rete virtuale del cluster. Ottenere le credenziali del cluster usando il az aks get-credentials comando e quindi verificare la connessione usando il kubectl get nodes comando .

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

Pulire le risorse

Se le risorse create in questo articolo non sono più necessarie, rimuoverle per evitare di incorrere in ulteriori addebiti.

Avvertimento

L'esecuzione del comando terraform destroy rimuove tutte le risorse gestite nel file di stato di Terraform per questa configurazione, inclusi il gruppo di risorse e il cluster AKS. Esamina attentamente il piano prima di distruggerlo ed evita di eseguirlo su un'infrastruttura condivisa o di produzione.

Esegui terraform plan con il flag -destroy per verificare cosa rimuove Terraform.

terraform plan -destroy -out main.destroy.tfplan

Eseguire terraform apply per applicare il piano di eliminazione definitiva e rimuovere tutte le risorse create da questo esempio.

terraform apply main.destroy.tfplan

Verificare che il cluster con isolamento di rete sia abilitato in AKS

Per verificare che la funzionalità cluster isolato di rete sia abilitata, usare il az aks show comando .

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

L'output seguente mostra un cluster isolato dalla rete configurato con il tipo di traffico in uscita none. Verificare che outboundType sia impostato su none o blocke che artifactSource sia impostato su Cache. Il campo containerRegistryId identifica il Registro Azure Container usato per il bootstrap.

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

Disabilitare il cluster con isolamento di rete in AKS

Disabilitare la funzionalità del cluster isolato dalla rete eseguendo il comando az aks update con i parametri --bootstrap-artifact-source e --outbound-type.

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

Quando si disabilita la funzionalità in un cluster esistente, è necessario creare manualmente l'immagine di tutti i nodi esistenti.

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

Importante

Ricordarsi di creare nuovamente l'immagine dei pool di nodi del cluster dopo aver disabilitato la funzionalità del cluster isolato dalla rete. In caso contrario, la funzionalità non avrà effetto per il cluster.

Risoluzione dei problemi

Se si verificano problemi, ad esempio se il pull dell'immagine non riesce, consultare Risolvere i problemi dei cluster Servizio Azure Kubernetes (AKS) isolati dalla rete.

Passaggi successivi

Per definire la configurazione delle restrizioni in uscita usando Firewall di Azure, vedere Controllare il traffico in uscita usando Firewall di Azure nel servizio Azure Kubernetes.

Per limitare il modo in cui i pod comunicano tra loro e le restrizioni del traffico est-ovest all'interno del cluster, vedere Proteggere il traffico tra i pod usando i criteri di rete nel servizio Azure Kubernetes.

  • Last updated on