Rövid útmutató: Azure Kubernetes Service (AKS) automatikus fürt létrehozása egyéni virtuális hálózaton

A következőkre vonatkozik: ✔️ AKS Automatic

Azure Kubernetes Service (AKS) Automatikus a legegyszerűbben felügyelt Kubernetes-élményt nyújt fejlesztőknek, DevOps-mérnököknek és platformmérnököknek. A modern és AI-alkalmazásokhoz ideális AKS Automatic automatizálja az AKS-fürtcsoportok beállításait és működését, valamint beágyazza a legjobb gyakorlatokon alapuló konfigurációkat. Az AKS Automatic alkalmazásainak biztonságát, teljesítményét és megbízhatóságát bármely képzettségi szint felhasználói élvezhetik. Az AKS Automatic tartalmaz egy pod-készültségi SLA-t is, amely garantálja, hogy a podok alkalmassági műveleteinek 99,9%-a 5 percen belül befejeződik, így biztosítva megbízható, öngyógyító infrastruktúrát az alkalmazások számára. A rövid útmutató feltételezi, hogy rendelkezik a Kubernetes használatára vonatkozó alapvető ismeretekkel. További információ: Kubernetes alapfogalmak Azure Kubernetes Service (AKS).

Ebben a rövid útmutatóban a következőkkel ismerkedhet meg:

  • Hozzon létre egy virtuális hálózatot.
  • Felügyelt identitás létrehozása a virtuális hálózaton keresztüli engedélyekkel.
  • Egy AKS Automatikus fürt üzembe helyezése a virtuális hálózatban.
  • Többtárolós mintaalkalmazás futtatása mikroszolgáltatások és webes kezelőfelületek egy kiskereskedelmi forgatókönyvet szimuláló csoportjával.

Ha nincs Azure fiókja, hozzon létre egy felszabadító fiókot.

Előfeltételek

  • Azure CLI 2.86.0-s vagy újabb verziót. A verzió megkereséséhez futtassa az --version a parancsot. Ha telepítenie vagy frissítenie kell, tekintse meg a Install Azure CLI című témakört.

Megjegyzés

Ez a minta az AzureRM-szolgáltató azurerm_kubernetes_automatic_cluster erőforrásával hozza létre az AKS Automatic-fürtöt, amelyhez az AzureRM-szolgáltató v4.81 vagy újabb verziója szükséges. Az AzAPI-szolgáltatót használó egyenértékű minta esetében lásd a 101-aks-automatic-custom-network-azapi mintát.

  • A Network Contributor klaszterazonosság, amely beépített szerepkör-hozzárendeléssel rendelkezik az API-kiszolgáló alhálózatán.
  • A fürt identitása, amelyhez beépített szerepkör van hozzárendelve a virtuális hálózaton, a Network Contributor.
  • A fürthöz Azure Kubernetes Service Cluster User Role és Azure Kubernetes Service RBAC Writer felhasználói identitás fér hozzá.
  • Legalább */28 méretű dedikált API-kiszolgálóalhálózattal rendelkező virtuális hálózat, amely Microsoft.ContainerService/managedClusters delegálva van.
  • Az AKS Automatic engedélyezi az Azure Policy-t az AKS-fürtön, de a zökkenőmentesebb működés érdekében elő kell regisztrálnia az Microsoft.PolicyInsights erőforrás-szolgáltatót az előfizetésben. További információ: Azure erőforrás-szolgáltatók és -típusok.
  • Távolítsa el az AKS-preview bővítményt a következővel az extension remove -n aks-preview: .

Fontos

Az AKS 1.36-os verziójától kezdve az új AKS Automatic-fürtökben alapértelmezés szerint a Kubernetes Gateway API az alkalmazásútválasztási bővítményen keresztül lesz engedélyezve a Managed NGINX ingress helyett az alkalmazásútválasztási bővítménnyel, az upstream Ingress NGINX kivezetése miatt.

A meglévő automatikus fürtöket ez nem érinti, de meg kell kezdeniük az alkalmazásútválasztási bővítményen keresztül a Kubernetes Gateway API-ra való migrálást.

Korlátozások

Az AKS Automatikus fürtökre a következő korlátozások vonatkoznak:

  • Az AKS Automatic az alábbi régiókban érhető el általánosan: australiacentral, australiaeast, australiasoutheast, austriaeast, belgiumcentral, canadacentral, centralus, southeastasia, chilecentral, southindia, denmarkeast, spaincentral, eastasia, swedencentral, eastus, westus3, germanywestcentral, westus2, francecentral, westus, indonesiacentral, westeurope, eastus2, westcentralus, israelcentral, centralindia, polandcentral, italynorth, southafricanorth, japaneast, southcentralus, uksouth, norwayeast, ukwest, uaenorth, switzerlandnorth, northeurope, northcentralus, newzealandnorth, mexicocentral, koreasouth, japanwest, malaysiawest, brazilsouth, canadaeast, koreacentral.
  • Az új AKS Automatikus fürtök alapértelmezés szerint engedélyezik a felügyelt rendszercsomópontok készleteit és a LocalDNS-t. AKS Automatikus fürtök nem hozhatók létre felügyelt rendszercsomópontkészletek nélkül egyetlen régióban sem.
  • Az AKS Automatikus klaszterben a csomópont-erőforráscsoport zárolása előre be van állítva, ami nem teszi lehetővé a MC_ erőforráscsoport módosítását, így megakadályozza a virtuális hálózati hivatkozások létrehozását az alapértelmezett privát DNS-zónában. Virtuális hálózatok közötti vagy egyéni DNS-forgatókönyvek esetén használja az egyéni hálózati és privát DNS-t A privát Azure Kubernetes Service (AKS) Automatikus fürt létrehozása egyéni virtuális hálózaton.
  • Azure CLI 2.86.0-s vagy újabb verzió szükséges. A verzió megkereséséhez futtassa az --version a parancsot. Ha telepítenie vagy frissítenie kell, tekintse meg a Install Azure CLI című témakört.
  • A következő bővítmények nem támogatottak:
  • A Windows-csomópontok nem támogatottak.
  • Az AKS alap termékváltozatáról az automatikus termékváltozatra való migrálás nem támogatott.
  • A felügyelt rendszercsomópont-készletek nélküli meglévő AKS Automatic-fürtről a felügyelt rendszercsomópont-készletekkel rendelkező AKS Automaticra történő migrálás előzetes verzióban támogatott azokban a régiókban, ahol a felügyelt rendszercsomópont-készletek általánosan elérhetők. A felügyelt rendszercsomópontkészletekkel rendelkező AKS Automatic-ból a felügyelt rendszercsomópontkészletek nélküli AKS Automatic-ba való migrálás nem támogatott.

Változók meghatározása

Adja meg az alábbi lépésekben használt változókat.

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)

Erőforráscsoport létrehozása

A Azure erőforráscsoport egy logikai csoport, amelyben Azure erőforrásokat helyeznek üzembe és kezelnek.

Hozzon létre egy erőforráscsoportot az az group create paranccsal.

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

Az alábbi mintakimenet hasonlít az erőforráscsoport sikeres létrehozására:

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

Virtuális hálózat létrehozása

Hozzon létre egy virtuális hálózatot a az network vnet create paranccsal. Hozzon létre egy API-kiszolgáló alhálózatát, a felhasználói csomópont alhálózatát és a rendszercsomópont alhálózatát a az network vnet subnet create parancs használatával.

Ha egyéni virtuális hálózatot használ az AKS Automatic szolgáltatással, létre kell hoznia egy API-kiszolgálói alhálózatot. Az AKS az ön nevében delegálja az alhálózatot Microsoft.ContainerService/managedClusters , így az AKS-szolgáltatás engedélyt kap az API-kiszolgáló podjainak és a belső terheléselosztónak az alhálózatba való injektálásához. Az alhálózatot más számítási feladatokhoz nem használhatja, de az API-kiszolgáló alhálózatához használhatja több, ugyanazon a virtuális hálózaton található AKS-fürthöz. Az API-kiszolgáló alhálózatának egyetlen fürt támogatásához szükséges minimálisan támogatott mérete /28-as.

Figyelmeztetés

Egy AKS-fürt legalább kilenc (9) IP-címet foglal le az alhálózat címterületén. Az IP-címek elfogyása megakadályozhatja az API-kiszolgálók skálázását, és az API-kiszolgáló leállását okozhatja.

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

A hálózati biztonsági csoport követelményei

Ha hálózati biztonsági csoport (NSG) szabályokat adott hozzá az egyéni virtuális hálózat különböző alhálózatai közötti forgalom korlátozásához, győződjön meg arról, hogy az NSG biztonsági szabályai lehetővé teszik a fürtösszetevők közötti szükséges típusú kommunikációt.

Az egyéni virtuális hálózatok AKS-fürtökkel való használatakor az NSG részletes követelményeit az Egyéni virtuális hálózati követelmények című témakörben találja.

Felügyelt identitás létrehozása és engedélyek megadása a virtuális hálózaton

Hozzon létre egy felügyelt identitást a az identity create paranccsal, és kérje le a fő azonosítót. Rendelje hozzá a Hálózati Közreműködői szerepkört a virtuális hálózaton a felügyelt identitáshoz a az role assignment create paranccsal.

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

Automatikus AKS-fürt létrehozása egyedi virtuális hálózatban

AKS-fürt automatikus létrehozásához használja az az aks create parancsot.

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

Néhány perc múlva a parancs befejeződik, és JSON formátumú információkat ad vissza a klaszterről.

Csatlakozzon a klaszterhez

A Kubernetes-fürt kezeléséhez használja a Kubernetes parancssori klienst, a kubectl-t. kubectl már telepítve van, ha Azure Cloud Shell használ. A helyi telepítéshez kubectl futtassa a következő parancsot: az aks install-cli. Az AKS automatikus fürtök Microsoft Entra ID-vel Kubernetes szerepköralapú hozzáférés-vezérléshez (RBAC) vannak konfigurálva.

Amikor az Azure CLI használatával hoz létre fürtöt, a felhasználó számára hozzá vannak rendelve a beépített szerepkörök .

Konfigurálja kubectl a Kubernetes-klaszterhez való csatlakozást az az aks get-credentials paranccsal. Ez a parancs letölti a hitelesítő adatokat, és konfigurálja a Kubernetes parancssori felületét a használatukhoz.

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

Ellenőrizze a fürthöz való kapcsolatot a kubectl get paranccsal. Ez a parancs a fürtcsomópontok listáját adja vissza.

kubectl get nodes

Az alábbi mintakimenet bemutatja, hogyan kell bejelentkeznie.

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

A bejelentkezés után az alábbi mintakimenet a felügyelt rendszercsomópontkészleteket jeleníti meg. Győződjön meg arról, hogy a csomópont állapota kész.

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

Virtuális hálózat létrehozása

Ez a Bicep fájl definiál egy virtuális hálózatot.

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

Mentse a Bicep fájlt virtualNetwork.bicep a helyi számítógépre.

Fontos

A Bicep fájl a vnetName paramétert aksAutomaticVnet értékre állítja, a addressPrefix param pedig 172.19.0.0/16, a apiServerSubnetPrefix param to 172.19.0/28, és a apiServerSubnetPrefix param to 172.19.1.0/24. Ha különböző értékeket szeretne használni, frissítse a sztringeket az előnyben részesített értékekre.

Helyezze üzembe a Bicep fájlt a Azure CLI használatával.

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

A virtuális hálózaton belüli összes forgalom alapértelmezés szerint engedélyezett. Ha hálózati biztonsági csoport (NSG) szabályokat adott hozzá az egyéni virtuális hálózat különböző alhálózatai közötti forgalom korlátozásához, győződjön meg arról, hogy az NSG biztonsági szabályai lehetővé teszik a fürtösszetevők közötti szükséges típusú kommunikációt.

Az egyéni virtuális hálózatok AKS-fürtökkel való használatakor az NSG részletes követelményeit az Egyéni virtuális hálózati követelmények című témakörben találja.

Felügyelt identitás létrehozása

Ez a Bicep fájl egy felhasználó által hozzárendelt felügyelt identitást határoz meg.

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

Mentse a Bicep fájlt uami.bicep a helyi számítógépre.

Fontos

A Bicep fájl a uamiName paramétert a aksAutomaticUAMI értékre állítja. Ha más identitásnevet szeretne használni, frissítse a sztringet az előnyben részesített névre.

Helyezze üzembe a Bicep fájlt a Azure CLI használatával.

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

A hálózati közreműködői szerepkör hozzárendelése a virtuális hálózaton keresztül

Ez a Bicep fájl szerepkör-hozzárendeléseket határoz meg a virtuális hálózaton.

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

Mentse a Bicep fájlt roleAssignments.bicep a helyi számítógépre.

Fontos

A Bicep fájl a vnetName paramétert aksAutomaticVnet értékre állítja. Ha más virtuális hálózatnevet használt, frissítse a sztringet az előnyben részesített virtuális hálózat nevére.

Helyezze üzembe a Bicep fájlt a Azure CLI használatával. Meg kell adnia a felhasználó által hozzárendelt identitási főazonosítót.

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

Automatikus AKS-fürt létrehozása egyedi virtuális hálózatban

Ez a Bicep fájl határozza meg az AKS Automatikus fürtöt.

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

Mentse a Bicep fájlt aks.bicep a helyi számítógépre.

Fontos

A Bicep fájl a clusterName paramétert aksAutomaticCluster értékre állítja. Ha másik fürtnevet szeretne, frissítse a karakterláncot az Ön által preferált fürtnévre.

Helyezze üzembe a Bicep fájlt a Azure CLI használatával. Meg kell adnia az API-kiszolgáló alhálózati erőforrás-azonosítóját, a felhasználói csomópont alhálózati erőforrás-azonosítóját, a rendszercsomópont alhálózati erőforrás-azonosítóját és a felhasználó által hozzárendelt felügyelt identitás erőforrás-azonosítóját.

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>

Csatlakozzon a klaszterhez

A Kubernetes-fürt kezeléséhez használja a Kubernetes parancssori klienst, a kubectl-t. kubectl már telepítve van, ha Azure Cloud Shell használ. A helyi telepítéshez kubectl futtassa a következő parancsot: az aks install-cli. Az AKS automatikus fürtök Microsoft Entra ID-vel Kubernetes szerepköralapú hozzáférés-vezérléshez (RBAC) vannak konfigurálva.

Fontos

Amikor Bicep használatával hoz létre fürtöt, hozzárendelnie kell az egyik beépített szerepkört például Azure Kubernetes Service RBAC Reader, Azure Kubernetes Service RBAC Writer, Azure Kubernetes Service RBAC Admin vagy Azure Kubernetes Service RBAC Cluster Admin a felhasználók számára, hatóköre a fürtre vagy egy adott névtérre terjed ki, például a az role assignment create --role "Azure Kubernetes Service RBAC Cluster Admin" --scope <AKS cluster resource id> --assignee user@contoso.com használatával. Győződjön meg arról is, hogy a felhasználók rendelkeznek a Azure Kubernetes Service Cluster User beépített szerepkörrel, hogy képesek legyenek végrehajtani a az aks get-credentials futtatását, majd az AKS-fürt kubeconfigját lekérhetik a az aks get-credentials parancs segítségével.

Konfigurálja kubectl a Kubernetes-klaszterhez való csatlakozást az az aks get-credentials paranccsal. Ez a parancs letölti a hitelesítő adatokat, és konfigurálja a Kubernetes parancssori felületét a használatukhoz.

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

Ellenőrizze a fürthöz való kapcsolatot a kubectl get paranccsal. Ez a parancs a fürtcsomópontok listáját adja vissza.

kubectl get nodes

Az alábbi mintakimenet bemutatja, hogyan kell bejelentkeznie.

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

A bejelentkezés után az alábbi mintakimenet a felügyelt rendszercsomópontkészleteket jeleníti meg. Győződjön meg arról, hogy a csomópont állapota kész.

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

A Terraform-kód áttekintése

Megjegyzés

A cikk mintakódja az Azure Terraform GitHub-adattárban található. Megtekintheti a Terraform aktuális és korábbi verzióinak teszteredményeit tartalmazó naplófájlt.

További cikkek és mintakódok, amelyek bemutatják, hogyan használható a Terraform az Azure erőforrások kezelésére.

  1. Hozzon létre egy könyvtárat, amelyben tesztelheti a Terraform-mintakódot, és az aktuális könyvtárá teheti.

  2. Hozzon létre egy providers.tf nevű fájlt, és szúrja be a következő kódot:

    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. Hozzon létre egy main.tf nevű fájlt, és szúrja be a következő kódot:

    # 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. Hozzon létre egy variables.tf nevű fájlt, és szúrja be a következő kódot:

    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. Hozzon létre egy outputs.tf nevű fájlt, és szúrja be a következő kódot:

    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
}

Terraform inicializálása

Futtassa a Terraform init parancsot a Terraform üzembe helyezésének inicializálásához. Ez a parancs letölti a Azure-erőforrások kezeléséhez szükséges Azure szolgáltatókat.

terraform init -upgrade

Terraform végrehajtási terv létrehozása

Végrehajtási terv létrehozásához futtassa a Terraform-tervet .

terraform plan -out main.tfplan

A Terraform végrehajtási terv alkalmazása

Használja a terraform apply parancsot a végrehajtási terv felhőinfrastruktúrára való alkalmazásához.

terraform apply main.tfplan

Egy automatikus AKS-klaszter létrehozása több percet vesz igénybe.

Ellenőrizze a klasztert

  1. Az Azure-erőforráscsoport neve és a fürt neve lekérése.

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

  2. Futtassa a(z) az aks show parancsot a fürt megjelenítéséhez, és ellenőrizze, hogy a fürt a(z) Automatic SKU-t és az egyéni alhálózatait használja-e.

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

Csatlakozzon a klaszterhez

A Kubernetes-fürt kezeléséhez használja a Kubernetes parancssori klienst, a kubectl-t. A(z) kubectl helyileg telepíthető a(z) az aks install-cli paranccsal. Az AKS automatikus fürtök Microsoft Entra ID-vel Kubernetes szerepköralapú hozzáférés-vezérléshez (RBAC) vannak konfigurálva.

Konfigurálja kubectl a Kubernetes-klaszterhez való csatlakozást az az aks get-credentials paranccsal.

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

Ellenőrizze a fürthöz való kapcsolatot a kubectl get paranccsal.

kubectl get nodes

Az alkalmazás üzembe helyezése

Az alkalmazás üzembe helyezéséhez egy jegyzékfájl használatával hozza létre a AKS Store-alkalmazás futtatásához szükséges összes objektumot. A Kubernetes-jegyzékfájl meghatározza a klaszter kívánt állapotát, például hogy mely konténerképeket kell futtatni. A manifest a következő Kubernetes üzembe helyezéseket és szolgáltatásokat tartalmazza:

Az Azure Store mintaarchitektúra képernyőképe.

  • Áruházi előtér: Webalkalmazás az ügyfelek számára termékek megtekintésére és megrendelések leadására.
  • Termékszolgáltatás: A termékinformációkat jeleníti meg.
  • Rendelési szolgáltatás: Rendeléseket rendel.
  • RabbitMQ: Üzenetsor rendelési rendszerhez.

Megjegyzés

Nem javasoljuk az állapotalapú konténerek (például a Rabbit MQ) futtatását éles környezetben tartós tároló nélkül. Ezek a tárolók az egyszerűség kedvéért használatosak, de ajánlott felügyelt szolgáltatásokat használni, például Azure Cosmos DB vagy Azure Service Bus.

  1. Hozzon létre egy névteret aks-store-demo a Kubernetes-erőforrások üzembe helyezéséhez.

    kubectl create ns aks-store-demo

  2. Helyezze üzembe az alkalmazást a kubectl apply paranccsal a aks-store-demo névtérben. Az üzembe helyezést meghatározó YAML-fájl GitHub.

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

    Az alábbi mintakimenet a telepítéseket és szolgáltatásokat mutatja meg.

    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

Az alkalmazás tesztelése

Az alkalmazás futtatásakor egy Kubernetes-szolgáltatás elérhetővé teszi az alkalmazás előtérét az interneten. A folyamat eltarthat pár percig.

  1. Ellenőrizze az üzembe helyezett podok állapotát a kubectl get pods paranccsal. Győződjön meg arról, hogy az összes pod Running, mielőtt folytatja. Ha ez az első üzembe helyezendő számítási feladat, a csomópontok automatikus kiépítése eltarthat néhány percig, amíg létrejön egy csomópontkészlet a podok futtatásához.

    kubectl get pods -n aks-store-demo

  2. Ellenőrizze, hogy van-e nyilvános IP-cím az áruházi előtéralkalmazáshoz. Figyelje a folyamatot a kubectl get service paranccsal az --watch argumentummal.

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

    A szolgáltatás CÍM kimenete store-front kezdetben üres:

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

  3. Ha a CÍM üresről tényleges nyilvános IP-címre változik, állítsa le a CTRL-C figyelési folyamatot kubectl használva.

    Az alábbi mintakimenet a szolgáltatáshoz rendelt érvényes nyilvános IP-címet jeleníti meg:

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

  4. Nyisson meg egy webböngészőt a bejövő forgalom külső IP-címére a Azure Store-alkalmazás működés közbeni megtekintéséhez.

    Képernyőkép az AKS Store mintaalkalmazásról.

Fürt törlése

Ha nem tervezi végigjárni a AKS oktatóanyagot, törölje a felesleges erőforrásokat a Azure költségek elkerülése érdekében. Futtassa az az group delete parancsot az erőforráscsoport, a tárolószolgáltatás és az összes kapcsolódó erőforrás eltávolításához.

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

Megjegyzés

Az AKS-fürt egy felhasználó által hozzárendelt felügyelt identitással lett létrehozva. Ha már nincs szüksége erre az identitásra, manuálisan is eltávolíthatja.

Ha már nincs szüksége a Terraformon keresztül létrehozott erőforrásokra, futtassa a Terraform-tervet , és adja meg a jelölőt destroy .

terraform plan -destroy -out main.destroy.tfplan

A végrehajtási terv alkalmazásához futtassa a terraform apply parancsot.

terraform apply main.destroy.tfplan

Következő lépések

Ebben a gyors kezdésben egy Kubernetes-fürtöt helyezett üzembe egy egyéni virtuális hálózaton belül az AKS Automatic segítségével, majd egy egyszerű, többtárolós alkalmazást telepített rá. Ez a mintaalkalmazás csak bemutató célokra készült, és nem képviseli a Kubernetes-alkalmazások ajánlott eljárásait. Az AKS éles környezetben történő alkalmazásával kapcsolatos teljes megoldások létrehozásának útmutatásáért lásd az AKS-megoldások útmutatóját.

Ha többet szeretne megtudni az AKS Automaticról, folytassa a bevezetéssel.

Az Azure Kubernetes Service (AKS) automatikus bemutatása

  • Last updated on