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

Gäller för: ✔️ AKS Automatic

Azure Kubernetes Service (AKS) Automatic ger den enklaste hanterade Kubernetes-upplevelsen för utvecklare, DevOps-tekniker och plattformstekniker. Idealisk för moderna och AI-användningar, automatiserar AKS Automatic uppstart och drift av AKS-kluster och integrerar konfigurationer enligt bästa praxis. Användare av valfri kompetensnivå kan dra nytta av säkerhet, prestanda och pålitlighet för AKS Automatic för sina program. AKS Automatic innehåller även ett serviceavtal för poddberedskap som garanterar att 99,9 % av kvalificerande poddberedskapsåtgärder slutförs inom 5 minuter, vilket säkerställer tillförlitlig, självhelande infrastruktur för dina applikationer. Den här snabbstarten förutsätter grundläggande kunskaper om Kubernetes-begrepp. Mer information finns i Kubernetes grundläggande begrepp för Azure Kubernetes Service (AKS).

I den här snabbstarten lär du dig att:

Skapa ett virtuellt nätverk.
Skapa en hanterad identitet med behörigheter över det virtuella nätverket.
Distribuera ett AKS-automatiskt kluster i det virtuella nätverket.
Kör ett exempelprogram med flera containrar med en grupp mikrotjänster och webbklientdelar som simulerar ett detaljhandelsscenario.

Om du inte har ett Azure konto skapar du ett free-konto.

Förutsättningar

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.

Anmärkning

Det här exemplet skapar AKS Automatic-klustret med AzureRM-providerns azurerm_kubernetes_automatic_cluster resurs, vilket kräver AzureRM-providerversion v4.81 eller senare. Ett motsvarande exempel som använder AzAPI-providern finns i exemplet 101-aks-automatic-custom-network-azapi .

Klusteridentitet med en Network Contributor inbyggd rolltilldelning i API-serverundernätet.
Klusteridentitet med en Network Contributor inbyggd rolltilldelning på det virtuella nätverket för att stödja automatisk etablering av nod.
Användaridentitet som kommer åt klustret med Azure Kubernetes Service Cluster User Role och Azure Kubernetes Service RBAC Writer.
Ett virtuellt nätverk med ett dedikerat API-serverundernät med minst */28 storlek som delegeras till Microsoft.ContainerService/managedClusters.
- Om det finns en nätverkssäkerhetsgrupp (NSG) kopplad till undernät kontrollerar du att NSG-säkerhetsreglerna tillåter de typer av kommunikation som krävs mellan klusterkomponenter. Detaljerade krav finns i Krav för anpassat virtuellt nätverk.
- Om det finns en Azure Firewall eller annan metod eller installation för utgående begränsning kontrollerar du att krävda utgående nätverksregler och FQDN tillåtna.
AKS Automatic kommer att aktivera Azure Policy i ditt AKS-kluster, men du bör förregistrera resursprovidern Microsoft.PolicyInsights i din prenumeration för en bättre upplevelse. Mer information finns i Azure-resursleverantörer och typer.
Avinstallera tillägget AKS-preview med hjälp av az extension remove -n aks-preview.

Viktigt!

Från och med AKS 1.36 aktiverar nya AKS Automatic-kluster som standard Kubernetes Gateway API via tillägget för programroutning i stället för Managed NGINX ingress via tillägget för programroutning på grund av den upstreama avvecklingen av Ingress NGINX.

Befintliga automatiska kluster påverkas inte men bör påbörja migreringen till Kubernetes Gateway-API:et via tillägget för programdirigering.

Begränsningar

Följande begränsningar gäller för AKS automatiska kluster:

AKS Automatic är allmänt tillgängligt i följande regioner: australiaeast, austriaeast, belgiumcentral, brazilsouth, canadacentral, centralindia, centralus, chilecentral, denmarkeast, eastasia, eastus, eastus2, francecentral, germanywestcentral, indonesiacentral, israelcentral, italynorth, japaneast, japanwest, koreacentral, malaysiawest, mexicocentral, newzealandnorth, northeurope, norwayeast, polandcentral, southafricanorth, southcentralus, southeastasia, spaincentral, swedencentral, switzerlandnorth, uaenorth, uksouth, westeurope, westus2, westus3.
- Nya AUTOMATISKA AKS-kluster aktiverar som standard hanterade systemnodpooler och LocalDNS. Du kan inte skapa AKS Automatic-kluster utan hanterade systemnodpooler i någon region.
Det automatiska AKS-klustret har nodnedlåsning av resursgrupper förkonfigurerat, vilket inte tillåter ändringar i resursgruppen MC_, vilket förhindrar virtuella nätverkslänkar i standardzonen Private DNS. För scenarier mellan virtuella nätverk eller anpassade DNS-scenarier använder du anpassat nätverk och privat DNS genom att följa Skapa ett privat Azure Kubernetes Service (AKS) Automatiskt kluster i ett anpassat virtuellt nätverk.
Azure CLI version 2.86.0 eller senare krävs. Kör kommandot för att hitta versionen az --version . Om du behöver installera eller uppgradera kan du läsa Installera Azure CLI.
Följande tillägg stöds inte:
- Dapr
- Azure Machine Learning
Windows-noder stöds inte.
Migrering från AKS-bas-SKU till automatisk SKU stöds inte.
Migreringar mellan AKS-automatiska kluster utan hanterade systemnodpooler och AKS Automatiska kluster med hanterade systemnodpooler stöds inte.

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.

Varning

Ett AKS-kluster reserverar minst nio (9) IP-adresser i undernätets adressutrymme. Slut på IP-adresser kan förhindra API-serverskalning och orsaka ett API-serverstopp.

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

Skapa ett virtuellt nätverk

Den här Bicep-filen definierar ett virtuellt nätverk.

@description('The location of the managed cluster resource.')
param location string = resourceGroup().location

@description('The name of the virtual network.')
param vnetName string = 'aksAutomaticVnet'

@description('The address prefix of the virtual network.')
param addressPrefix string = '172.19.0.0/16'

@description('The name of the API server subnet.')
param apiServerSubnetName string = 'apiServerSubnet'

@description('The subnet prefix of the API server subnet.')
param apiServerSubnetPrefix string = '172.19.0.0/28'

@description('The name of the user node subnet.')
param userNodeSubnetName string = 'userNodeSubnet'

@description('The subnet prefix of the user node subnet.')
param userNodeSubnetPrefix string = '172.19.1.0/24'

@description('The name of the system node subnet.')
param systemNodeSubnetName string = 'systemNodeSubnet'

@description('The subnet prefix of the system node subnet.')
param systemNodeSubnetPrefix string = '172.19.0.64/26'

// Virtual network with an API server subnet, a user node subnet, and a system node subnet
resource virtualNetwork 'Microsoft.Network/virtualNetworks@2023-09-01' = {
    name: vnetName
    location: location
    properties: {
        addressSpace: {
            addressPrefixes: [ addressPrefix ]
        }
        subnets: [
            {
                name: apiServerSubnetName
                properties: {
                    addressPrefix: apiServerSubnetPrefix
                }
            }
            {
                name: userNodeSubnetName
                properties: {
                    addressPrefix: userNodeSubnetPrefix
                }
            }
            {
                name: systemNodeSubnetName
                properties: {
                    addressPrefix: systemNodeSubnetPrefix
                }
            }
        ]
    }
}

output apiServerSubnetId string = resourceId('Microsoft.Network/virtualNetworks/subnets', vnetName, apiServerSubnetName)
output userNodeSubnetId string = resourceId('Microsoft.Network/virtualNetworks/subnets', vnetName, userNodeSubnetName)
output systemNodeSubnetId string = resourceId('Microsoft.Network/virtualNetworks/subnets', vnetName, systemNodeSubnetName)

Spara filen Bicep virtualNetwork.bicep till den lokala datorn.

Viktigt!

Filen Bicep anger param vnetName till aksAutomaticVnet, addressPrefix param till 172.19.0.0/16, param apiServerSubnetPrefix till 172.19.0.0/28 och apiServerSubnetPrefix param till 172.19.1.0/24. Om du vill använda olika värden måste du uppdatera strängarna till önskade värden.

Distribuera Bicep-filen med hjälp av Azure CLI.

az deployment group create --resource-group <resource-group> --template-file virtualNetwork.bicep

All trafik inom det virtuella nätverket tillåts som standard. 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

Den här Bicep-filen definierar en användartilldelad hanterad identitet.

param location string = resourceGroup().location
param uamiName string = 'aksAutomaticUAMI'

resource userAssignedManagedIdentity 'Microsoft.ManagedIdentity/userAssignedIdentities@2023-01-31' = {
  name: uamiName
  location: location
}

output uamiId string = userAssignedManagedIdentity.id
output uamiPrincipalId string = userAssignedManagedIdentity.properties.principalId
output uamiClientId string = userAssignedManagedIdentity.properties.clientId

Spara filen Bicep uami.bicep till den lokala datorn.

Viktigt!

Bicep-filen sätter uamiName parametern till aksAutomaticUAMI. Om du vill använda ett annat identitetsnamn måste du uppdatera strängen till önskat namn.

Distribuera Bicep-filen med hjälp av Azure CLI.

az deployment group create --resource-group <resource-group> --template-file uami.bicep

Tilldela rollen Nätverksmedarbetare på det virtuella nätverket

Den här Bicep-filen definierar rolltilldelningar över det virtuella nätverket.

@description('The name of the virtual network.')
param vnetName string = 'aksAutomaticVnet'

@description('The principal ID of the user assigned managed identity.')
param uamiPrincipalId string

// Get a reference to the virtual network
resource virtualNetwork 'Microsoft.Network/virtualNetworks@2023-09-01' existing ={
  name: vnetName
}

// Assign the Network Contributor role to the user assigned managed identity on the virtual network
// '4d97b98b-1d4f-4787-a291-c67834d212e7' is the built-in Network Contributor role definition
// See: https://learn.microsoft.com/en-us/azure/role-based-access-control/built-in-roles/networking#network-contributor
resource networkContributorRoleAssignmentToVirtualNetwork 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(uamiPrincipalId, '4d97b98b-1d4f-4787-a291-c67834d212e7', resourceGroup().id, virtualNetwork.name)
  scope: virtualNetwork
  properties: {
      roleDefinitionId: resourceId('Microsoft.Authorization/roleDefinitions', '4d97b98b-1d4f-4787-a291-c67834d212e7')
      principalId: uamiPrincipalId
  }
}

Spara filen Bicep roleAssignments.bicep till den lokala datorn.

Viktigt!

Bicep-filen ställer in parametern vnetName på aksAutomaticVnet. Om du använde ett annat namn på det virtuella nätverket måste du uppdatera strängen till önskat namn på det virtuella nätverket.

Distribuera Bicep-filen med hjälp av Azure CLI. Du måste ange det användartilldelade identitetshuvudnamns-ID:t.

az deployment group create --resource-group <resource-group> --template-file roleAssignments.bicep \
--parameters uamiPrincipalId=<user assigned identity prinicipal id>

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

Den här Bicep-filen definierar AKS Automatic-klustret.

@description('The name of the managed cluster resource.')
param clusterName string = 'aksAutomaticCluster'

@description('The location of the managed cluster resource.')
param location string = resourceGroup().location

@description('The resource ID of the API server subnet.')
param apiServerSubnetId string

@description('The resource ID of the user node subnet.')
param userNodeSubnetId string

@description('The resource ID of the system node subnet.')
param systemNodeSubnetId string

@description('The resource ID of the user assigned managed identity.')
param uamiId string

/// Create the AKS Automatic cluster using the custom virtual network and user assigned managed identity
resource aks 'Microsoft.ContainerService/managedClusters@2024-03-02-preview' = {
  name: clusterName
  location: location  
  sku: {
    name: 'Automatic'
  }
  properties: {
    apiServerAccessProfile: {
      subnetId: apiServerSubnetId
    }
    networkProfile: {
      outboundType: 'loadBalancer'
    }
    hostedSystemProfile: {
      systemNodeSubnetID: systemNodeSubnetId
      nodeSubnetID: userNodeSubnetId
    }
  }
  identity: {
    type: 'UserAssigned'
    userAssignedIdentities: {
      '${uamiId}': {}
    }
  }
}

Spara filen Bicep aks.bicep till den lokala datorn.

Viktigt!

I Bicep-filen ställs parametern clusterName in till aksAutomaticCluster. Om du vill ha ett annat klusternamn måste du uppdatera strängen till önskat klusternamn.

Distribuera Bicep-filen med hjälp av Azure CLI. Du måste ange resurs-ID:t för API-serverns undernät, resurs-ID för användarnodens undernät, resurs-ID för systemnoden och användartilldelat resurs-ID för hanterad identitet.

az deployment group create --resource-group <resource-group> --template-file aks.bicep \
--parameters apiServerSubnetId=<API server subnet resource id> \
--parameters nodeSubnetId=<user node subnet resource id> \
--parameters systemNodeSubnetId=<system node subnet resource id> \
--parameters uamiId=<user assigned identity id>

Ansluta till klustret

Viktigt!

När du skapar ett kluster med Bicep måste du tilldela en av de inbyggda rollerna till exempel Azure Kubernetes Service RBAC Reader, Azure Kubernetes Service RBAC Writer, Azure Kubernetes Service RBAC Admin eller Azure Kubernetes Service RBAC Cluster Admin till dina användare, som är begränsade till klustret eller ett specifikt namnområde, till exempel med hjälp av az role assignment create --role "Azure Kubernetes Service RBAC Cluster Admin" --scope <AKS cluster resource id> --assignee user@contoso.com. Kontrollera också att användarna har den Azure Kubernetes Service Cluster User inbyggda rollen för att kunna köra az aks get-credentials och sedan hämta kubeconfig för ditt AKS-kluster med hjälp av kommandot az aks get-credentials.

az aks get-credentials --resource-group <resource-group> --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

Anmärkning

Exempelkoden för den här artikeln finns på Azure Terraform GitHub-lagringsplatsen. Du kan visa loggfilen som innehåller testresultaten från aktuella och tidigare versioner av Terraform.

Se fler artiklar och exempelkod som visar hur du använder Terraform för att hantera Azure-resurser.

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

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

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

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

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

Hämta Azure resursgruppsnamn och klusternamn.

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

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

Distribuera programmet

Om du vill distribuera programmet använder du en manifestfil för att skapa alla objekt som krävs för att köra AKS Store-programmet. En Kubernetes-manifestfil definierar ett klusters önskade tillstånd, till exempel vilka containeravbildningar som ska köras. Manifestet innehåller följande Kubernetes-distributioner och -tjänster:

Butiksfront: Webbprogram där kunder kan visa produkter och göra beställningar.
Produkttjänst: Visar produktinformation.
Ordertjänst: Gör beställningar.
Rabbit MQ: Meddelandekö för en beställningskö.

Anmärkning

Vi rekommenderar inte att du kör tillståndskänsliga containrar, till exempel RabbitMQ, utan beständig lagring för produktion. Dessa containrar används här för enkelhetens skull, men vi rekommenderar att du använder hanterade tjänster, till exempel Azure Cosmos DB eller Azure Service Bus.

Skapa ett namnområde aks-store-demo som Kubernetes-resurserna ska distribueras till.
```
kubectl create ns aks-store-demo
```

Distribuera programmet med hjälp av kommandot kubectl apply i aks-store-demo namnområdet. YAML-filen som definierar distributionen finns på GitHub.

kubectl apply -n aks-store-demo -f https://raw.githubusercontent.com/Azure-Samples/aks-store-demo/main/aks-store-ingress-quickstart.yaml

Följande exempelutdata visar distributioner och tjänster:

statefulset.apps/rabbitmq created
configmap/rabbitmq-enabled-plugins created
service/rabbitmq created
deployment.apps/order-service created
service/order-service created
deployment.apps/product-service created
service/product-service created
deployment.apps/store-front created
service/store-front created
ingress/store-front created

Testa programmet

När programmet körs så exponerar en Kubernetes-tjänst programmets klientdel mot Internet. Den här processen kan ta ett par minuter att slutföra.

Kontrollera statusen för de distribuerade poddarna med kommandot kubectl get pods . Kontrollera att alla poddar är Running innan du fortsätter. Om det här är den första arbetsbelastningen som du driftsätter, kan det ta några minuter innan automatisk nodetablering skapar en nodpool där poddarna kan köras.
```
kubectl get pods -n aks-store-demo
```

Sök efter en offentlig IP-adress för programmet store-front. Övervaka förloppet med hjälp av kommandot kubectl get service med --watch argumentet .

kubectl get ingress store-front -n aks-store-demo --watch

ADDRESS-utgången för tjänsten visar ursprungligen tom:

NAME          CLASS                                HOSTS   ADDRESS        PORTS   AGE
store-front   webapprouting.kubernetes.azure.com   *                      80      12m

När ADRESSEN ändras från tom till en faktisk offentlig IP-adress använder du CTRL-C för att stoppa kubectl klockprocessen.

Följande exempelutdata visar en giltig offentlig IP-adress som tilldelats tjänsten:
```
NAME          CLASS                                HOSTS   ADDRESS        PORTS   AGE
store-front   webapprouting.kubernetes.azure.com   *       4.255.22.196   80      12m
```
Öppna en webbläsare till den externa IP-adressen för din ingress för att se Azure Store-appen i funktion.

Ta bort klustret

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

Anmärkning

AKS-klustret skapades med en användartilldelad hanterad identitet. Om du inte längre behöver den identiteten kan du ta bort den manuellt.

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

Nästa steg

I den här snabbstarten distribuerade du ett Kubernetes-kluster med AKS Automatic i ett anpassat virtuellt nätverk och distribuerade sedan en enkel multicontainer-applikation till det. Det här exempelprogrammet är endast i demosyfte och representerar inte alla metodtips för Kubernetes-program. Vägledning om hur du skapar fullständiga lösningar med AKS för produktion finns i AKS-lösningsvägledning.

Om du vill veta mer om AKS Automatic fortsätter du till introduktionen.

Introduktion till Azure Kubernetes Service (AKS) automatisk

Feedback

Var den här sidan till hjälp?

Last updated on 2026-08-31

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

Förutsättningar

Begränsningar

Definiera variabler

Skapa en resursgrupp

Skapa ett virtuellt nätverk

Krav för nätverkssäkerhetsgrupp

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

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

Ansluta till klustret

Skapa ett virtuellt nätverk

Skapa en hanterad identitet

Tilldela rollen Nätverksmedarbetare på det virtuella nätverket

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

Ansluta till klustret

Granska Terraform-koden

Initiera Terraform

Skapa en Terraform-utförandeplan

Tillämpa en Terraform-utförandeplan

Kontrollera klustret

Ansluta till klustret

Distribuera programmet

Testa programmet

Ta bort klustret

Nästa steg

Feedback

Ytterligare resurser