Snabbstart: Skapa ett Azure Kubernetes Service (AKS) automatiskt kluster i ett anpassat virtuellt nätverk

• Azure CLI version 2.86.0 eller senare. Kör kommandot för att hitta versionen az --version . Om du behöver installera eller uppgradera kan du läsa Installera Azure CLI.

• Installera och konfigurera Terraform.

Definiera variabler

Definiera följande variabler som används i följande steg.

RG_NAME=automatic-rg
VNET_NAME=automatic-vnet
CLUSTER_NAME=automatic
IDENTITY_NAME=automatic-uami
LOCATION=eastus
SUBSCRIPTION_ID=$(az account show --query id -o tsv)

Skapa en resursgrupp

En Azure resursgrupp är en logisk grupp där Azure resurser distribueras och hanteras.

Skapa en resursgrupp med hjälp av kommandot az group create.

az group create -n ${RG_NAME} -l ${LOCATION}

Följande exempelutdata visar det framgångsrika skapandet av resursgruppen:

{
  "id": "/subscriptions/<guid>/resourceGroups/automatic-rg",
  "location": "canadacentral",
  "managedBy": null,
  "name": "automatic-rg",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "tags": null
}

Skapa ett virtuellt nätverk

Skapa ett virtuellt nätverk med kommandot az network vnet create . Skapa ett API-serverundernät, undernät för användarnoder och systemnodundernät med kommandot az network vnet subnet create .

När du använder ett anpassat virtuellt nätverk med AKS Automatic måste du skapa ett API-serverundernät. AKS delegerar undernätet till Microsoft.ContainerService/managedClusters åt dig, vilket ger AKS-tjänsten behörighet att mata in API-serverpoddarna och den interna lastbalanseraren i undernätet. Du kan inte använda undernätet för andra arbetsbelastningar, men du kan använda det för flera AKS-kluster som finns i samma virtuella nätverk. Den minsta api-serverundernätsstorlek som stöds är / 28.

az network vnet create --name ${VNET_NAME} \
--resource-group ${RG_NAME} \
--location ${LOCATION} \
--address-prefixes 172.19.0.0/16

az network vnet subnet create --resource-group ${RG_NAME} \
--vnet-name ${VNET_NAME} \
--name apiServerSubnet \
--delegations Microsoft.ContainerService/managedClusters \
--address-prefixes 172.19.0.0/28

az network vnet subnet create --resource-group ${RG_NAME} \
--vnet-name ${VNET_NAME} \
--name userNodeSubnet \
--address-prefixes 172.19.1.0/24

az network vnet subnet create --resource-group ${RG_NAME} \
--vnet-name ${VNET_NAME} \
--name managedSystemNodeSubnet \
--address-prefixes 172.19.0.64/26

Krav för nätverkssäkerhetsgrupp

Om du har lagt till NSG-regler (Network Security Group) för att begränsa trafiken mellan olika undernät i ditt anpassade virtuella nätverk kontrollerar du att NSG-säkerhetsreglerna tillåter de typer av kommunikation som krävs mellan klusterkomponenter.

Detaljerade NSG-krav när du använder anpassade virtuella nätverk med AKS-kluster finns i Krav för anpassat virtuellt nätverk.

Skapa en hanterad identitet och ge den behörighet i det virtuella nätverket

Skapa en hanterad identitet med kommandot az identity create och hämta huvudnamns-ID:t. Tilldela rollen Nätverksdeltagare på det virtuella nätverket till den hanterade identiteten med kommandot az role assignment create.

az identity create \
--resource-group ${RG_NAME} \
 --name ${IDENTITY_NAME} \
 --location ${LOCATION}

IDENTITY_PRINCIPAL_ID=$(az identity show --resource-group ${RG_NAME} --name ${IDENTITY_NAME} --query principalId -o tsv)

az role assignment create \
--scope "/subscriptions/${SUBSCRIPTION_ID}/resourceGroups/${RG_NAME}/providers/Microsoft.Network/virtualNetworks/${VNET_NAME}" \
--role "Network Contributor" \
--assignee-object-id "${IDENTITY_PRINCIPAL_ID}" \
--assignee-principal-type ServicePrincipal

Skapa ett AKS-automatiskt kluster i ett anpassat virtuellt nätverk

Om du vill skapa ett AKS-automatiskt kluster använder du kommandot az aks create .

az aks create \
--resource-group ${RG_NAME} \
--name ${CLUSTER_NAME} \
--location ${LOCATION} \
--apiserver-subnet-id "/subscriptions/${SUBSCRIPTION_ID}/resourceGroups/${RG_NAME}/providers/Microsoft.Network/virtualNetworks/${VNET_NAME}/subnets/apiServerSubnet" \
--node-subnet-id "/subscriptions/${SUBSCRIPTION_ID}/resourceGroups/${RG_NAME}/providers/Microsoft.Network/virtualNetworks/${VNET_NAME}/subnets/userNodeSubnet" \
--system-node-subnet-id "/subscriptions/${SUBSCRIPTION_ID}/resourceGroups/${RG_NAME}/providers/Microsoft.Network/virtualNetworks/${VNET_NAME}/subnets/managedSystemNodeSubnet" 
--assign-identity "/subscriptions/${SUBSCRIPTION_ID}/resourcegroups/${RG_NAME}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/${IDENTITY_NAME}" \
--sku automatic \
--no-ssh-key

Efter några minuter slutförs kommandot och returnerar JSON-formaterad information om klustret.

Ansluta till klustret

Om du vill hantera ett Kubernetes-kluster använder du Kubernetes-kommandoradsklienten kubectl. kubectl är redan installerat om du använder Azure Cloud Shell. kubectl Installera lokalt genom att köra kommandot az aks install-cli. AUTOMATISKA AKS-kluster konfigureras med Microsoft Entra ID för rollbaserad åtkomstkontroll för Kubernetes (RBAC).

När du skapar ett kluster med hjälp av Azure CLI tilldelas din användare inbyggda roller för .

Konfigurera kubectl för att ansluta till kubernetes-klustret med kommandot az aks get-credentials . Det här kommandot laddar ned autentiseringsuppgifter och konfigurerar Kubernetes CLI för att använda dem.

az aks get-credentials --resource-group ${RG_NAME} --name ${CLUSTER_NAME}

Kontrollera anslutningen till klustret med kommandot kubectl get . Det här kommandot returnerar en lista över klusternoderna.

kubectl get nodes

Följande exempelutdata visar hur du uppmanas att logga in.

To sign in, use a web browser to open the page https://microsoft.com/devicelogin and enter the code AAAAAAAAA to authenticate.

När du har loggat in visar följande exempelutdata de hanterade systemnodpoolerna. Kontrollera att nodstatusen är Klar.

NAME                           STATUS   ROLES    AGE   VERSION
aks-hostedpool-16652789-vms1   Ready    <none>   19m   v1.34.7
aks-hostedpool-16652789-vms2   Ready    <none>   19m   v1.34.7
aks-hostedpool-16652789-vms3   Ready    <none>   19m   v1.34.7
aks-system-surge-zq4d2         Ready    <none>   19m   v1.34.7

Granska Terraform-koden

1. Skapa en katalog där du kan testa Terraform-exempelkoden och göra den till den aktuella katalogen.

2. Skapa en fil med namnet providers.tf och infoga följande kod:

   terraform {
     required_version = ">= 1.0"
     required_providers {
       azurerm = {
         source  = "hashicorp/azurerm"
         version = "~>5.0"
       }
       random = {
         source  = "hashicorp/random"
         version = "~>3.0"
       }
     }
   }
   
   provider "azurerm" {
     features {}
   }
   

3. Skapa en fil med namnet main.tf och infoga följande kod:

   # Create a random name for the resource group using random_pet
   resource "random_pet" "rg_name" {
     prefix = var.resource_group_name_prefix
   }
   
   # Create a resource group using the generated random name
   resource "azurerm_resource_group" "rg" {
     location = var.resource_group_location
     name     = random_pet.rg_name.id
   }
   
   # Create the custom virtual network that hosts the cluster
   resource "azurerm_virtual_network" "vnet" {
     name                = var.virtual_network_name
     location            = azurerm_resource_group.rg.location
     resource_group_name = azurerm_resource_group.rg.name
     address_space       = var.virtual_network_address_space
   }
   
   # Create the subnet delegated to AKS for API Server VNet Integration
   resource "azurerm_subnet" "api_server" {
     name                 = "apiServerSubnet"
     resource_group_name  = azurerm_resource_group.rg.name
     virtual_network_name = azurerm_virtual_network.vnet.name
     address_prefixes     = var.api_server_subnet_address_prefixes
   
     delegation {
       name = "aks-delegation"
   
       service_delegation {
         name    = "Microsoft.ContainerService/managedClusters"
         actions = ["Microsoft.Network/virtualNetworks/subnets/join/action"]
       }
     }
   }
   
   # Create the subnet that hosts the user node pools
   resource "azurerm_subnet" "user_nodes" {
     name                 = "userNodeSubnet"
     resource_group_name  = azurerm_resource_group.rg.name
     virtual_network_name = azurerm_virtual_network.vnet.name
     address_prefixes     = var.user_node_subnet_address_prefixes
   }
   
   # Create the subnet that hosts the managed system node pool
   resource "azurerm_subnet" "system_nodes" {
     name                 = "managedSystemNodeSubnet"
     resource_group_name  = azurerm_resource_group.rg.name
     virtual_network_name = azurerm_virtual_network.vnet.name
     address_prefixes     = var.system_node_subnet_address_prefixes
   
     lifecycle {
       # AKS adds its own managed cluster delegation to this subnet after the
       # cluster is created.
       ignore_changes = [delegation]
     }
   }
   
   # Create the user-assigned managed identity used by the cluster
   resource "azurerm_user_assigned_identity" "aks" {
     name                = var.identity_name
     location            = azurerm_resource_group.rg.location
     resource_group_name = azurerm_resource_group.rg.name
   }
   
   # Grant the cluster identity Network Contributor on the virtual network
   resource "azurerm_role_assignment" "network_contributor" {
     scope                = azurerm_virtual_network.vnet.id
     role_definition_name = "Network Contributor"
     principal_id         = azurerm_user_assigned_identity.aks.principal_id
     principal_type       = "ServicePrincipal"
   }
   
   # Create a random name for the AKS Automatic cluster
   resource "random_pet" "cluster_name" {
     prefix = var.cluster_name_prefix
   }
   
   # Create the AKS Automatic cluster in the custom virtual network
   resource "azurerm_kubernetes_automatic_cluster" "aks_automatic" {
     name                = random_pet.cluster_name.id
     location            = azurerm_resource_group.rg.location
     resource_group_name = azurerm_resource_group.rg.name
   
     identity {
       type         = "UserAssigned"
       identity_ids = [azurerm_user_assigned_identity.aks.id]
     }
   
     api_server_access {
       subnet_id = azurerm_subnet.api_server.id
     }
   
     hosted_system {
       node_subnet_id        = azurerm_subnet.user_nodes.id
       system_node_subnet_id = azurerm_subnet.system_nodes.id
     }
   
     depends_on = [azurerm_role_assignment.network_contributor]
   }
   

4. Skapa en fil med namnet variables.tf och infoga följande kod:

   variable "resource_group_location" {
     type        = string
     default     = "westus2"
     description = "Location of the resource group."
   }
   
   variable "resource_group_name_prefix" {
     type        = string
     default     = "rg"
     description = "Prefix of the resource group name that's combined with a random ID so name is unique in your Azure subscription."
   }
   
   variable "cluster_name_prefix" {
     type        = string
     default     = "aks-automatic"
     description = "Prefix of the AKS Automatic cluster name that's combined with a random ID so the name is unique in your Azure subscription."
   }
   
   variable "virtual_network_name" {
     type        = string
     default     = "aks-automatic-vnet"
     description = "Name of the custom virtual network that hosts the cluster."
   }
   
   variable "identity_name" {
     type        = string
     default     = "aks-automatic-identity"
     description = "Name of the user-assigned managed identity that the cluster uses."
   }
   
   variable "virtual_network_address_space" {
     type        = list(string)
     default     = ["172.19.0.0/16"]
     description = "Address space of the custom virtual network."
   }
   
   variable "api_server_subnet_address_prefixes" {
     type        = list(string)
     default     = ["172.19.0.0/28"]
     description = "Address prefixes of the subnet delegated to the cluster API server."
   }
   
   variable "user_node_subnet_address_prefixes" {
     type        = list(string)
     default     = ["172.19.1.0/24"]
     description = "Address prefixes of the subnet that hosts the user node pools."
   }
   
   variable "system_node_subnet_address_prefixes" {
     type        = list(string)
     default     = ["172.19.0.64/26"]
     description = "Address prefixes of the subnet that hosts the managed system node pool."
   }
   

5. Skapa en fil med namnet outputs.tf och infoga följande kod:

   output "resource_group_name" {
     value = azurerm_resource_group.rg.name
   }
   
   output "cluster_name" {
     value = azurerm_kubernetes_automatic_cluster.aks_automatic.name
   }
   
   output "cluster_id" {
     value = azurerm_kubernetes_automatic_cluster.aks_automatic.id
   }
   
   output "node_resource_group_id" {
     value = azurerm_kubernetes_automatic_cluster.aks_automatic.node_resource_group_id
   }
   
   output "virtual_network_name" {
     value = azurerm_virtual_network.vnet.name
   }
   
   output "fully_qualified_domain_name" {
     value = azurerm_kubernetes_automatic_cluster.aks_automatic.fully_qualified_domain_name
   }
   

Initiera Terraform

Kör terraform init för att initiera Terraform-distributionen. Det här kommandot laddar ned de Azure providers som krävs för att hantera dina Azure resurser.

terraform init -upgrade

Skapa en Terraform-utförandeplan

Kör terraform plan för att skapa en utförandeplan.

terraform plan -out main.tfplan

Tillämpa en Terraform-utförandeplan

Kör terraform apply för att applicera genomförandeplanen på din molninfrastruktur.

terraform apply main.tfplan

Det tar flera minuter att skapa ett AKS-automatiskt kluster.

Kontrollera klustret

1. Hämta Azure resursgruppsnamn och klusternamn.

   resource_group_name=$(terraform output -raw resource_group_name)
   cluster_name=$(terraform output -raw cluster_name)
   

2. Kör az aks show för att visa klustret och bekräfta att det använder Automatic SKU:n och dina anpassade undernät.

   az aks show --resource-group $resource_group_name --name $cluster_name --query "{name:name, sku:sku, provisioningState:provisioningState, apiServerSubnet:apiServerAccessProfile.subnetId}"
   

Ansluta till klustret

Om du vill hantera ett Kubernetes-kluster använder du Kubernetes-kommandoradsklienten kubectl. Du kan installera kubectl lokalt med kommandot az aks install-cli . AUTOMATISKA AKS-kluster konfigureras med Microsoft Entra ID för rollbaserad åtkomstkontroll för Kubernetes (RBAC).

Konfigurera kubectl för att ansluta till kubernetes-klustret med kommandot az aks get-credentials .

az aks get-credentials --resource-group $resource_group_name --name $cluster_name

Kontrollera anslutningen till klustret med kommandot kubectl get .

kubectl get nodes

Om du inte planerar att gå igenom AKS-självstudien, rensar du onödiga resurser för att undvika Azure-avgifter. Kör kommandot az group delete för att ta bort resursgruppen, containertjänsten och alla relaterade resurser.

az group delete --name <resource-group> --yes --no-wait

När du inte längre behöver de resurser som skapats via Terraform kör du terraform-planen och anger destroy flaggan.

terraform plan -destroy -out main.destroy.tfplan

Kör terraform apply för att tillämpa genomförandeplanen.

terraform apply main.destroy.tfplan