Rychlý start: Vytvoření Azure Kubernetes Service (AKS) automatického clusteru ve vlastní virtuální síti

Platí pro: ✔️ AKS Automatic

Azure Kubernetes Service (AKS) Automatic poskytuje nejjednodušší spravované prostředí Kubernetes pro vývojáře, techniky DevOps a techniky platformy. Ideální pro moderní aplikace a aplikace AI, AKS Automatic automatizuje nastavení a operace clusteru AKS a vkládá osvědčené postupy konfigurace. Uživatelé jakékoli úrovně dovedností můžou těžit z zabezpečení, výkonu a spolehlivosti AKS Automaticky pro své aplikace. AKS Automatic také zahrnuje SLA pro připravenost podů, která zaručuje, že 99,9% způsobilých operací připravenosti podů bude dokončeno do 5 minut, což zajišťuje spolehlivou a samoopravující infrastrukturu pro vaše aplikace. Tento rychlý start předpokládá základní znalosti konceptů Kubernetes. Další informace najdete v základních konceptech Kubernetes pro Azure Kubernetes Service (AKS).

V tomto rychlém startu se naučíte:

  • Vytvořte virtuální síť.
  • Vytvořte spravovanou identitu s oprávněními pro virtuální síť.
  • Nasazení automatického clusteru AKS ve virtuální síti
  • Spusťte ukázkovou vícekontenerovou aplikaci se skupinou mikroslužeb a webových front-endů simulujících scénář maloobchodního prodeje.

Pokud účet Azure nemáte, vytvořte si účet free.

Požadavky

  • Azure CLI verze 2.86.0 nebo novější. Verzi najdete spuštěním az --version příkazu. Pokud potřebujete nainstalovat nebo upgradovat, přečtěte si téma Instalace Azure CLI.

Poznámka:

Tato ukázka vytvoří cluster AKS Automatic pomocí prostředku v4.81 poskytovatele AzureRM, který vyžaduje verzi azurerm_kubernetes_automatic_cluster poskytovatele AzureRM nebo novější. Ekvivalentní ukázku, která používá poskytovatele AzAPI, najdete v ukázce 101-aks-automatic-custom-network-azapi .

Důležité

Počínaje AKS 1.36 budou mít nové clustery AKS Automatic ve výchozím nastavení povolené rozhraní Kubernetes Gateway API pomocí doplňku směrování aplikací místo spravovaného ingressu NGINX pomocí doplňku směrování aplikací kvůli ukončení Ingress NGINX.

Stávající automatické clustery nejsou ovlivněné, ale měly by začít s migrací do rozhraní API brány Kubernetes prostřednictvím doplňku pro směrování aplikací.

Omezení

Pro automatické clustery AKS platí následující omezení:

  • AKS Automatic je obecně dostupná v následujících oblastech: australiacentral, australiaeast, australiasoutheast, belgiumcentral, austriaeast, brazilsouth, canadacentral, canadaeast, centralindia, centralus, chilecentral, denmarkeast, eastasia, eastus, eastus2, francecentral, germanywestcentral, indonesiacentral, israelcentral, italynorth, japaneast, japanwest, koreacentral, koreasouth, malaysiawest, mexicocentral, newzealandnorth, northcentralus, northeurope, norwayeast, polandcentral, southafricanorth, southcentralus, southeastasia, southindia, spaincentral, swedencentral, switzerlandnorth, uaenorth, uksouth, ukwest, westcentralus, westeurope, westus, westus2, westus3.
  • Nové automatické clustery AKS mají ve výchozím nastavení povolené spravované fondy systémových uzlů a LocalDNS. Clustery AKS Automatic nemůžete v žádné oblasti vytvářet bez spravovaných systémových fondů uzlů.
  • Cluster AKS Automatic má předkonfigurované uzamčení skupiny prostředků uzlu, které neumožňuje provádět změny ve skupině prostředků MC_, a tím zabraňuje vytváření propojení virtuální sítě ve výchozí privátní zóně DNS. V případě scénářů pro různé virtuální sítě nebo vlastní DNS použijte vlastní síť a privátní DNS podle Vytvoření privátního Azure Kubernetes Service (AKS) automatického clusteru ve vlastní virtuální síti.
  • Azure CLI je vyžadována verze 2.86.0 nebo novější. Verzi najdete spuštěním az --version příkazu. Pokud potřebujete nainstalovat nebo upgradovat, přečtěte si téma Instalace Azure CLI.
  • Následující rozšíření nejsou podporovaná:
  • Uzly Windows nejsou podporované.
  • Migrace ze základní skladové položky AKS na automatickou skladovou položku není podporovaná.
  • Migrace z existujícího automatického clusteru AKS bez fondů uzlů spravovaného systému do AKS Automaticky s fondy uzlů spravovaného systému je podporována ve verzi Preview v oblastech, kde jsou obecně dostupné fondy spravovaných systémových uzlů. Migrace z AKS Automatic se spravovanými fondy systémových uzlů zpět na AKS Automatic bez spravovaných fondů systémových uzlů není podporována.

Definování proměnných

Definujte následující proměnné, které se používají v následujících krocích.

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)

Vytvoření skupiny zdrojů

Skupina prostředků Azure je logická skupina, ve které se nasazují a spravují Azure prostředky.

Vytvořte skupinu prostředků pomocí příkazu az group create .

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

Následující ukázkový výstup se podobá úspěšnému vytvoření skupiny prostředků:

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

Vytvoření virtuální sítě

Vytvořte virtuální síť pomocí az network vnet create příkazu. Pomocí příkazu vytvořte podsíť serveru API, podsíť uživatelského uzlu a podsíť systémového az network vnet subnet create uzlu.

Pokud používáte vlastní virtuální síť s AKS Automatic, musíte vytvořit podsíť serveru API. AKS deleguje podsíť Microsoft.ContainerService/managedClusters vaším jménem, která uděluje službě AKS oprávnění k vložení podů serveru API a interního nástroje pro vyrovnávání zatížení do této podsítě. Podsíť nemůžete použít pro žádné jiné úlohy, ale můžete ji použít pro podsíť serveru API pro více clusterů AKS umístěných ve stejné virtuální síti. Minimální podporovaná velikost podsítě serveru API pro podporu jednoho clusteru je /28.

Výstraha

Cluster AKS si v adresní prostoru podsítě vyhrazuje alespoň devět (9) IP adres. Nedostatek IP adres může bránit škálování serveru API a způsobit výpadek serveru API.

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

Požadavky na skupinu zabezpečení sítě

Pokud jste přidali pravidla skupiny zabezpečení sítě (NSG), která omezují provoz mezi různými podsítěmi ve vaší vlastní virtuální síti, ujistěte se, že pravidla zabezpečení NSG povolují požadované typy komunikace mezi komponentami clusteru.

Podrobné požadavky na skupiny zabezpečení sítě (NSG) při používání vlastních virtuálních sítí s clustery AKS naleznete v části Požadavky na vlastní virtuální síť.

Vytvoření spravované identity a udělení oprávnění k virtuální síti

Vytvořte spravovanou identitu pomocí az identity create příkazu a načtěte ID objektu zabezpečení. Pomocí příkazu přiřaďte roli Přispěvatel sítě ve virtuální síti spravované identitě 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

Vytvoření automatického clusteru AKS ve vlastní virtuální síti

Pokud chcete vytvořit automatický cluster AKS, použijte příkaz 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

Po několika minutách se příkaz dokončí a vrátí informace o clusteru ve formátu JSON.

Připojení ke clusteru

Ke správě clusteru Kubernetes použijte klienta příkazového řádku Kubernetes kubectl. kubectl je již nainstalován, pokud používáte Azure Cloud Shell. Pokud chcete nainstalovat kubectl místně, spusťte příkaz az aks install-cli . Automatické clustery AKS jsou nakonfigurované s Microsoft Entra ID pro řízení přístupu na základě role Kubernetes (RBAC) .

Při vytváření clusteru pomocí Azure CLI je vašemu uživateli přiřazena vestavěné role pro .

Nakonfigurujte kubectl připojení ke clusteru Kubernetes pomocí příkazu az aks get-credentials . Tento příkaz stáhne přihlašovací údaje a nakonfiguruje rozhraní příkazového řádku Kubernetes tak, aby je používalo.

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

Pomocí příkazu kubectl get ověřte připojení ke clusteru. Tento příkaz vrátí seznam uzlů clusteru.

kubectl get nodes

Následující ukázkový výstup ukazuje, jak se zobrazí výzva k přihlášení.

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

Po přihlášení následující ukázkový výstup zobrazuje spravované fondy systémových uzlů. Ujistěte se, že je stav uzlu Připravený.

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

Vytvoření virtuální sítě

Tento Bicep soubor definuje virtuální síť.

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

Uložte soubor Bicep virtualNetwork.bicep do místního počítače.

Důležité

Soubor Bicep nastaví parametr vnetName na aksAutomaticVnet, parametr addressPrefix na 172.19.0.0/16, parametr apiServerSubnetPrefix na 172.19.0.0/28 a parametr apiServerSubnetPrefix na 172.19.1.0/24. Pokud chcete použít jiné hodnoty, nezapomeňte aktualizovat řetězce na preferované hodnoty.

Nasaďte soubor Bicep pomocí Azure CLI.

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

Ve výchozím nastavení je povolený veškerý provoz ve virtuální síti. Pokud jste přidali pravidla skupiny zabezpečení sítě (NSG), která omezují provoz mezi různými podsítěmi ve vaší vlastní virtuální síti, ujistěte se, že pravidla zabezpečení NSG povolují požadované typy komunikace mezi komponentami clusteru.

Podrobné požadavky na skupiny zabezpečení sítě (NSG) při používání vlastních virtuálních sítí s clustery AKS naleznete v části Požadavky na vlastní virtuální síť.

Vytvoření spravované identity

Tento soubor Bicep definuje spravovanou uživatelsky přiřazenou identitu.

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

Uložte soubor Bicep uami.bicep do místního počítače.

Důležité

Soubor Bicep nastaví parametr uamiName na aksAutomaticUAMI. Pokud chcete použít jiný název identity, nezapomeňte řetězec aktualizovat na preferovaný název.

Nasaďte soubor Bicep pomocí Azure CLI.

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

Přiřaďte roli Přispěvatele sítě ke virtuální síti.

Tento Bicep soubor definuje přiřazení rolí ve virtuální síti.

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

Uložte soubor Bicep roleAssignments.bicep do místního počítače.

Důležité

Soubor Bicep nastaví parametr vnetName na aksAutomaticVnet. Pokud jste použili jiný název virtuální sítě, nezapomeňte řetězec aktualizovat na upřednostňovaný název virtuální sítě.

Nasaďte soubor Bicep pomocí Azure CLI. Musíte poskytnout ID hlavní identity přiřazené uživateli.

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

Vytvoření automatického clusteru AKS ve vlastní virtuální síti

Tento Bicep soubor definuje automatický cluster AKS.

@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}': {}
    }
  }
}

Uložte soubor Bicep aks.bicep do místního počítače.

Důležité

Soubor Bicep nastaví parametr clusterName na aksAutomaticCluster. Pokud chcete jiný název clusteru, nezapomeňte řetězec aktualizovat na upřednostňovaný název clusteru.

Nasaďte soubor Bicep pomocí Azure CLI. Musíte zadat ID prostředku podsítě serveru API, ID prostředku podsítě uzlu uživatele, ID prostředku podsítě systémového uzlu a ID prostředku spravované identity přiřazené uživatelem.

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>

Připojení ke clusteru

Ke správě clusteru Kubernetes použijte klienta příkazového řádku Kubernetes kubectl. kubectl je již nainstalován, pokud používáte Azure Cloud Shell. Pokud chcete nainstalovat kubectl místně, spusťte příkaz az aks install-cli . Automatické clustery AKS jsou nakonfigurované s Microsoft Entra ID pro řízení přístupu na základě role Kubernetes (RBAC) .

Důležité

Když vytváříte cluster pomocí Bicep, musíte přiřadit jednu z předdefinovaných rolí, například Azure Kubernetes Service RBAC Reader, Azure Kubernetes Service RBAC Writer, Azure Kubernetes Service RBAC Admin nebo Azure Kubernetes Service RBAC Cluster Admin, pro uživatele, s vymezením na cluster nebo konkrétní obor názvů, například pomocí az role assignment create --role "Azure Kubernetes Service RBAC Cluster Admin" --scope <AKS cluster resource id> --assignee user@contoso.com. Také se ujistěte, že vaši uživatelé mají předdefinované role Azure Kubernetes Service Cluster User, aby mohli spouštět az aks get-credentials, a pak pomocí příkazu az aks get-credentials získat kubeconfig vašeho clusteru AKS.

Nakonfigurujte kubectl připojení ke clusteru Kubernetes pomocí příkazu az aks get-credentials . Tento příkaz stáhne přihlašovací údaje a nakonfiguruje rozhraní příkazového řádku Kubernetes tak, aby je používalo.

az aks get-credentials --resource-group <resource-group> --name <cluster-name>

Pomocí příkazu kubectl get ověřte připojení ke clusteru. Tento příkaz vrátí seznam uzlů clusteru.

kubectl get nodes

Následující ukázkový výstup ukazuje, jak se zobrazí výzva k přihlášení.

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

Po přihlášení následující ukázkový výstup zobrazuje spravované fondy systémových uzlů. Ujistěte se, že je stav uzlu Připravený.

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

Kontrola kódu Terraformu

Poznámka:

Vzorový kód pro tento článek se nachází v úložišti GitHubu Azure Terraformu. Můžete zobrazit soubor protokolu obsahující výsledky testu z aktuálních a předchozích verzí Terraformu.

Podívejte se na další články a ukázkový kód ukazující, jak používat Terraform ke správě prostředků Azure.

  1. Vytvořte adresář, ve kterém otestujete ukázkový kód Terraformu a nastavíte ho jako aktuální adresář.

  2. Vytvořte soubor s názvem providers.tf a vložte následující kód:

    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. Vytvořte soubor s názvem main.tf a vložte následující kód:

    # 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. Vytvořte soubor s názvem variables.tf a vložte následující kód:

    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. Vytvořte soubor s názvem outputs.tf a vložte následující kód:

    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
}

Inicializujte Terraform

Spusťte terraform init a inicializujte nasazení Terraformu. Tento příkaz stáhne poskytovatele Azure potřebné ke správě vašich Azure prostředků.

terraform init -upgrade

Vytvoření plánu provádění Terraformu

Spusťte terraform plan a vytvořte plán provedení.

terraform plan -out main.tfplan

Použijte prováděcí plán Terraformu

Spusťte terraform apply pro aplikaci prováděcího plánu na vaši cloudovou infrastrukturu.

terraform apply main.tfplan

Vytvoření automatického clusteru AKS trvá několik minut.

Ověření clusteru

  1. Získejte název skupiny prostředků Azure a název clusteru.

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

  2. Spusťte příkaz az aks show, aby se zobrazil cluster a potvrdilo se, že používá Automatic SKU a vaše vlastní podsítě.

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

Připojení ke clusteru

Ke správě clusteru Kubernetes použijte klienta příkazového řádku Kubernetes kubectl. kubectl můžete nainstalovat lokálně pomocí příkazu az aks install-cli. Automatické clustery AKS jsou nakonfigurované s Microsoft Entra ID pro řízení přístupu na základě role Kubernetes (RBAC) .

Nakonfigurujte kubectl připojení ke clusteru Kubernetes pomocí příkazu az aks get-credentials .

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

Pomocí příkazu kubectl get ověřte připojení ke clusteru.

kubectl get nodes

Nasazení aplikace

K nasazení aplikace použijete soubor manifestu k vytvoření všech objektů potřebných ke spuštění aplikace AKS Store. Soubor manifestu Kubernetes definuje požadovaný stav clusteru, například které image kontejneru se mají spustit. Manifest zahrnuje následující nasazení a služby Kubernetes:

Screenshot ukázkové architektury Azure Store.

  • Store front: Webová aplikace pro zákazníky k zobrazení produktů a objednávání.
  • Produktová služba: Zobrazuje informace o produktu.
  • Služba pro objednávání: Realizuje objednávky.
  • Rabbit MQ: Fronta zpráv pro objednávkovou frontu.

Poznámka:

Nedoporučujeme spouštět stavové kontejnery, jako je Rabbit MQ, bez trvalého úložiště pro produkční prostředí. Tyto kontejnery se zde používají pro zjednodušení, ale doporučujeme používat spravované služby, jako jsou Azure Cosmos DB nebo Azure Service Bus.

  1. Vytvořte obor názvů aks-store-demo, kam budou nasazeny prostředky Kubernetes.

    kubectl create ns aks-store-demo

  2. Nasaďte aplikaci pomocí příkazu kubectl apply do aks-store-demo namespace. Soubor YAML definující nasazení je na GitHub.

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

    Následující ukázkový výstup ukazuje nasazení a služby:

    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

Otestování aplikace

Když se aplikace spustí, služba Kubernetes zveřejní front-end aplikace na internetu. Dokončení tohoto procesu může trvat několik minut.

  1. Pomocí příkazu kubectl get pods zkontrolujte stav nasazených podů. Ujistěte se, že jsou všechny pody Running, než budete pokračovat. Pokud se jedná o první úlohu, kterou nasadíte, může trvat několik minut, než automatické zřizování uzlu vytvoří fond uzlů pro spuštění podů.

    kubectl get pods -n aks-store-demo

  2. Zkontrolujte veřejnou IP adresu pro aplikaci store-front. Sledujte průběh pomocí příkazu kubectl get service s argumentem --watch .

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

    Výstup ADDRESS pro store-front službu zpočátku zobrazuje prázdný:

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

  3. Jakmile se adresa změní z prázdné na skutečnou CTRL-C veřejnou IP adresu, použijte kubectl k zastavení procesu sledování.

    Následující ukázkový výstup ukazuje platnou veřejnou IP adresu přiřazenou službě:

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

  4. Otevřete webový prohlížeč k externí IP adrese vašeho vstupního bodu, abyste si mohli prohlédnout aplikaci Azure Store v akci.

    Snímek obrazovky ukázkové aplikace AKS Store

Odstranění clusteru

Pokud nemáte v plánu projít kurz AKS, vyčistěte nepotřebné prostředky, abyste se vyhnuli poplatkům za Azure. Spuštěním příkazu az group delete odeberte skupinu prostředků, službu kontejneru a všechny související prostředky.

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

Poznámka:

Cluster AKS byl vytvořen se spravovanou identitou přiřazenou uživatelem. Pokud už tuto identitu nepotřebujete, můžete ji odebrat ručně.

Pokud už nepotřebujete prostředky vytvořené pomocí nástroje Terraform, spusťte terraform plan a zadejte příznak destroy.

terraform plan -destroy -out main.destroy.tfplan

Spusťte terraform apply pro aplikaci prováděcího plánu.

terraform apply main.destroy.tfplan

Další kroky

V tomto rychlém startu jste nasadili cluster Kubernetes pomocí služby AKS Automatic v rámci vlastní virtuální sítě a pak jste do ní nasadili jednoduchou vícekontenerovou aplikaci. Tato ukázková aplikace slouží jenom pro ukázkové účely a nepředstavuje všechny osvědčené postupy pro aplikace Kubernetes. Pokyny k vytváření úplných řešení pomocí AKS pro produkční prostředí najdete v pokynech k řešení AKS.

Další informace o službě AKS Automatic najdete v úvodu.

Úvod do Azure Kubernetes Service (AKS) Automatic

  • Last updated on