Een AKS-cluster (Network isolated Azure Kubernetes Service) maken

• Gebruik de Bash-omgeving in Azure Cloud Shell. Zie Aan de slag met Azure Cloud Shell voor meer informatie.

  

• Installeer de Azure CLI, indien gewenst, om CLI-referentieopdrachten uit te voeren. Als u in Windows of macOS werkt, kunt u Azure CLI uitvoeren in een Docker-container. Zie De Azure CLI uitvoeren in een Docker-container voor meer informatie.

  • Als u een lokale installatie gebruikt, meldt u zich aan bij Azure CLI met behulp van de opdracht az login. Volg de stappen die worden weergegeven in de terminal, om het verificatieproces te voltooien. Zie Verifiëren bij Azure met behulp van Azure CLI voor andere aanmeldingsopties.

  • Installeer de Azure CLI-extensie bij het eerste gebruik, wanneer u hierom wordt gevraagd. Zie Extensies gebruiken en beheren met de Azure CLIvoor meer informatie over extensies.

  • Voer az version uit om de geïnstalleerde versie en afhankelijke bibliotheken te vinden. Voer az upgrade uit om te upgraden naar de nieuwste versie.

• Voor dit artikel is versie 2.73.0 of hoger van de Azure CLI vereist. Als u Azure Cloud Shell gebruikt, is de nieuwste versie daar al geïnstalleerd.
• Installeer de aks-preview Azure CLI-extensie versie 9.0.0b2 of hoger als u uitgaand type block (preview) gebruikt.
  • Als u de aks-preview extensie nog niet hebt, installeert u deze met behulp van de az extension add opdracht.

    az extension add --name aks-preview
    

  • Als u de aks-preview extensie al hebt, werkt u deze bij om ervoor te zorgen dat u de nieuwste versie hebt met behulp van de az extension update opdracht.

    az extension update --name aks-preview
    

Omgevingsvariabelen instellen

Stel de omgevingsvariabelen in die in dit artikel worden gebruikt. De ACR-naam moet globaal uniek zijn en mag alleen alfanumerieke tekens in kleine letters bevatten.

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}

• Een Azure-account met een actief abonnement. Als u nog geen account hebt, maakt u een gratis account voordat u begint.
• Terraform installeren en configureren.
• Azure CLI geïnstalleerd en aangemeld met behulp vanaz login, gebruikt om de implementatie te verifiëren en verbinding te maken met het cluster. Installeer Azure CLI als u deze nog niet hebt.
• kubectl geïnstalleerd om verbinding te maken met het cluster. Als u Azure Cloud Shell gebruikt, is kubectl al geïnstalleerd. Gebruik de az aks install-cli opdracht om deze lokaal te installeren.
• jq geïnstalleerd, gebruikt om de Terraform-status te parseren bij het verifiëren van de implementatie. Azure Cloud Shell heeft jq al geïnstalleerd.

Een netwerkisolatiecluster implementeren met AKS-beheerde ACR

AKS maakt, beheert en verzoent een ACR-resource in deze optie. U hoeft geen machtigingen toe te wijzen of de ACR te beheren. AKS beheert de cacheregels, private link en het privé-eindpunt dat wordt gebruikt in het geïsoleerde netwerkcluster.

Een netwerkisolatiecluster maken

Kies bij het maken van een netwerk geïsoleerd AKS-cluster een van de volgende privéclustermodi: private link- of API Server VNet-integratie.

Stel de artefactbron en het uitgaande type in op basis van de vereisten voor netwerkisolatie.

Gebaseerd op Private Link

Maak een op private link gebaseerde netwerkisolatiecluster door de opdracht az aks create uit te voeren met --bootstrap-artifact-source, --enable-private-clusteren --outbound-type parameters.

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

VNet-integratie van API Server

Maak een netwerkgeïsoleerd cluster dat is geconfigureerd met API Server VNet-integratie door de opdracht az aks create uit te voeren met --bootstrap-artifact-source, --enable-private-cluster, --enable-apiserver-vnet-integration en --outbound-type parameters.

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

Een bestaand AKS-cluster bijwerken naar een geïsoleerd netwerktype

Als u liever netwerkisolatie op een bestaand AKS-cluster inschakelt in plaats van een nieuw cluster te maken, gebruikt u de opdracht az aks update .

Als u de geïsoleerde netwerkfunctie wilt inschakelen op een bestaand AKS-cluster, voert u eerst de volgende opdracht uit om bij te werken bootstrap-artifact-source:

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

Vervolgens moet u handmatig een installatiekopie maken van alle bestaande knooppuntgroepen:

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

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

Wacht en zorg ervoor dat de herinstallatie is voltooid en voer daarna de volgende opdracht uit om outbound-type bij te werken:

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

Een netwerkisolatiecluster implementeren met bring your own ACR

AKS biedt ondersteuning voor bring your own (BYO) ACR. Ter ondersteuning van het BYO ACR-scenario moet u een privé-ACR-eindpunt en een privé-DNS-zone configureren voordat u het AKS-cluster maakt.

De volgende stappen laten zien hoe u deze resources voorbereidt:

• Aangepast virtueel netwerk en subnetten voor AKS en ACR.
• ACR, ACR-cacheregel, privé-eindpunt en privé-DNS-zone.
• Aangepaste identiteit van controlevlak en kubelet-identiteit.

Stap 1: Het virtuele netwerk en subnetten maken

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

Stap 2: Uitgaande connectiviteit van virtueel netwerk uitschakelen (optioneel)

Maak bijvoorbeeld het AKS-subnet privé door de standaard uitgaande toegang in te stellen op false.

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

Zie Uitgaande connectiviteit van virtuele netwerken uitschakelen voor andere ondersteunde methoden en overgangsoverwegingen.

Stap 3: de ACR maken en de artefactcache inschakelen

1. Maak de ACR met openbare netwerktoegang uitgeschakeld.

   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. Maak met de volgende opdracht een ACR-cache-regel zodat gebruikers MAR-containerimages en binaire bestanden in de nieuwe ACR kunnen cachen. De naam van de cacheregel en de namen van opslagplaatsen moeten de richtlijnen in de volgende sectie volgen.

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

Stap 4: Een privé-eindpunt maken voor de 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)

Stap 5: Een privé-DNS-zone maken en records toevoegen

Maak een privé-DNS-zone met de naam privatelink.azurecr.io. Voeg de records voor het register REST-eindpunt {REGISTRY_NAME}.azurecr.ioen het registergegevenseindpunt {REGISTRY_NAME}.{LOCATION}.data.azurecr.iotoe.

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}

Stap 6: besturingsvlak- en kubelet-identiteiten maken

Identiteit van besturingsvlak

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)

Kubelet-identiteit

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)

Als u een bestaand AKS-cluster bijwerkt, slaat u de voorgaande opdrachten voor het maken van identiteiten over en haalt u de bestaande id van het kubelet-identiteitsobject op:

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

ACR-pullmachtigingen verlenen aan de kubelet-identiteit

Controleer de roltoewijzingsmodus van het register en selecteer de bijbehorende pull-rol. Registers waarvoor ABAC is ingeschakeld, gebruiken de rol Container Registry Repository Reader. Registers zonder ABAC gebruiken de AcrPull rol.

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

Nadat u deze resources hebt geconfigureerd, kunt u doorgaan met het maken van het geïsoleerde AKS-netwerkcluster met BYO ACR.

Stap 7: Netwerkisolatiecluster maken met BYO ACR

Wanneer u een geïsoleerd netwerkcluster maakt, kiest u een van de volgende privéclustermodi: private link- of API Server-VNet-integratie.

Stel de artefactbron en het uitgaande type in op basis van de vereisten voor netwerkisolatie.

Gebaseerd op Private Link

Maak een op private link gebaseerd netwerk geïsoleerd cluster dat toegang heeft tot uw ACR door de opdracht az aks create uit te voeren met de vereiste parameters.

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

VNet-integratie van API Server

Voor een netwerk geïsoleerd cluster dat is geconfigureerd met API Server VNet-integratie, maakt u eerst een subnet en wijst u de juiste rol toe met de volgende opdrachten:

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

Maak een geïsoleerd privénetwerkcluster dat is geconfigureerd met API Server VNet-integratie en open uw ACR door de opdracht az aks create uit te voeren met de vereiste parameters.

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}

Een bestaand AKS-cluster bijwerken

Als u liever netwerkisolatie op een bestaand AKS-cluster inschakelt in plaats van een nieuw cluster te maken, gebruikt u de opdracht az aks update .

Wanneer u het privé-eindpunt en de privé-DNS-zone voor de BYO ACR maakt, gebruikt u het bestaande virtuele netwerk en de subnetten van het bestaande AKS-cluster. Wanneer u de juiste ACR-pull-rol toewijst aan de kubelet-identiteit, gebruikt u de bestaande kubelet-identiteit van het bestaande AKS-cluster.

Als u de geïsoleerde netwerkfunctie wilt inschakelen op een bestaand AKS-cluster, voert u eerst de volgende opdracht uit om bij te werken bootstrap-artifact-source:

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

Vervolgens moet u handmatig een installatiekopie maken van alle bestaande knooppuntgroepen:

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

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

Wacht en zorg ervoor dat de herinstallatie is voltooid en voer daarna de volgende opdracht uit om outbound-type bij te werken:

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

Uw ACR-id bijwerken

U kunt de persoonlijke ACR bijwerken die wordt gebruikt met een geïsoleerd netwerkcluster. Gebruik de az aks show opdracht om de ACR-resource-id te identificeren.

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

Het bijwerken van de ACR-id wordt uitgevoerd door de opdracht uit te voeren met de az aks update--bootstrap-artifact-source en --bootstrap-container-registry-resource-id parameters.

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

Wanneer u de ACR-id op een bestaand cluster bijwerkt, moet u alle bestaande knooppunten handmatig opnieuw installeren.

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

Een netwerkisolatiecluster implementeren met Terraform

Met dit Terraform-voorbeeld wordt een netwerkisolatiecluster geïmplementeerd met behulp van de AKS-beheerde ACR-optie die eerder in dit artikel is beschreven. De AzureRM-provider maakt nog niet alle netwerk-geïsoleerde bootstrap-instellingen beschikbaar die in dit voorbeeld worden gebruikt, dus het voorbeeld maakt gebruik van de AzAPI-provider om de beheerde clusterresource te implementeren op basis van de vereiste API-versie. Een Terraform-voorbeeld voor de Bring Your Own (BYO)-ACR-optie is momenteel niet beschikbaar. Als u BYO ACR wilt gebruiken, volgt u de Azure CLI richtlijnen eerder in dit artikel.

In het voorbeeld worden de volgende resources geïmplementeerd:

• Een resourcegroep (Microsoft.Resources/resourceGroups).
• Een AKS-cluster met netwerkisolatie (Microsoft.ContainerService/managedClusters) dat gebruikmaakt van:
  • Een door het systeem toegewezen beheerde identiteit.
  • Eén systeemknooppuntgroep met één Standard_D2s_v3 knooppunt en automatisch schalen is uitgeschakeld.
  • De azure netwerkplug-in, waarbij outboundType is ingesteld op none zodat het cluster geen uitgaande netwerkafhankelijkheden heeft voor het opstarten.
  • apiServerAccessProfile.enablePrivateCluster ingesteld op true, waarmee een privécluster op basis van een privékoppeling wordt gemaakt.
  • bootstrapProfile.artifactSource ingesteld op Cache, zodat AKS zijn eigen ACR-cache maakt, beheert en synchroniseert om de cluster te initialiseren in plaats van deze rechtstreeks uit Microsoft Artifact Registry (MAR) te halen. Zoals eerder in dit artikel is beschreven, hoeft u deze ACR niet zelf te maken of te beheren. AKS verwerkt de cacheregels, private link en het privé-eindpunt dat door het netwerk geïsoleerde cluster wordt gebruikt.

Het cluster wordt gemaakt met de standaard Kubernetes-versie die wordt ondersteund in de implementatieregio. Als u een specifieke versie wilt vastmaken, voegt u dit toe kubernetesVersion aan het clusterblok properties in main.tfen controleert u of de versie beschikbaar is in de regio met behulp van de az aks get-versions opdracht.

1. Maak een map om de terraform-voorbeeldcode te testen en maak deze de huidige map.

2. Maak een bestand met de naam main.tf en kopieer de volgende geteste voorbeeldconfiguratie erin.

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

Terraform initialiseren

Voer deze opdracht uit terraform init om de Terraform-implementatie te initialiseren. Met deze opdracht worden de providers azapi en random gedownload die nodig zijn om de resources in dit voorbeeld te beheren.

terraform init -upgrade

De configuratie opmaken en valideren

Voer deze opdracht uit terraform fmt om het configuratiebestand op te maken en terraform validate om te bevestigen dat de configuratie syntactisch geldig is.

terraform fmt
terraform validate

Een Terraform-uitvoeringsplan maken

Voer terraform plan uit om een uitvoeringsplan te maken.

terraform plan -out main.tfplan

Een Terraform-uitvoeringsplan toepassen

Voer terraform apply uit om het uitvoeringsplan toe te passen op uw Azure-abonnement.

terraform apply main.tfplan

Het aanmaken van de resourcegroep en het privé en van het netwerk geïsoleerde AKS-cluster duurt enkele minuten.

De implementatie controleren

Dit voorbeeld definieert geen Terraform-outputs, dus gebruik terraform show -json met jq om de gegenereerde resourcegroepnamen en clusternamen op te halen uit de resourcestatus nadat terraform apply is voltooid. U beheert beide resources met de azapi provider en het name kenmerk bevat de naam van de opgeloste resource.

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

Controleer of het cluster is gemaakt met de verwachte geïsoleerde netwerkinstellingen met behulp van de az aks show opdracht.

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

De uitvoer laat zien dat outboundType is ingesteld op none, artifactSource is ingesteld op Cache en privateCluster is ingesteld op true, waarmee wordt bevestigd dat het cluster netwerkgeïsoleerd is en wordt opgestart vanaf de door AKS beheerde ACR-cache.

Verbinding maken met het cluster

Omdat dit een privécluster is, maakt u vanaf een client die netwerktoegang heeft tot het privéeindpunt van het cluster verbinding met het cluster, zoals een VM in hetzelfde virtuele netwerk of een gekoppeld virtueel netwerk, of Azure Cloud Shell als die is verbonden met het virtuele netwerk van het cluster. Haal de clusterreferenties op met behulp van de az aks get-credentials opdracht en controleer vervolgens de verbinding met behulp van de kubectl get nodes opdracht.

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

De hulpbronnen opschonen

Als u de resources die in dit artikel zijn gemaakt niet meer nodig hebt, verwijdert u deze om verdere kosten te voorkomen.

Voer terraform plan uit met de -destroy vlag om te controleren wat Terraform verwijdert.

terraform plan -destroy -out main.destroy.tfplan

Voer terraform apply uit om het vernietigingsplan toe te passen en verwijder alle resources die door dit voorbeeld zijn gemaakt.

terraform apply main.destroy.tfplan