Szybki start: tworzenie klastra automatycznego Azure Kubernetes Service (AKS) w niestandardowej sieci wirtualnej

Dotyczy: ✔️ AKS Automatic

Azure Kubernetes Service (AKS) Automatic zapewnia najłatwiejsze zarządzane środowisko kubernetes dla deweloperów, inżynierów DevOps i inżynierów platformy. Idealne rozwiązanie dla nowoczesnych aplikacji sztucznej inteligencji, usługa AKS Automatic automatyzuje konfigurację i operacje klastra usługi AKS oraz osadza konfiguracje najlepszych rozwiązań. Użytkownicy dowolnego poziomu umiejętności mogą korzystać z bezpieczeństwa, wydajności i niezawodności Automatyki AKS dla swoich aplikacji. Usługa AKS Automatic obejmuje również umowę SLA dotyczącą gotowości zasobników , która gwarantuje 99,9% ukończenia kwalifikujących się operacji gotowości zasobnika w ciągu 5 minut, zapewniając niezawodną infrastrukturę samonaprawiania dla aplikacji. Ten szybki start zakłada, że masz podstawową wiedzę na temat pojęć związanych z platformą Kubernetes. Aby uzyskać więcej informacji, zobacz Podstawowe pojęcia Kubernetes dla Azure Kubernetes Service (AKS).

Z tego przewodnika Szybki start dowiesz się, jak wykonywać następujące zadania:

  • Utwórz sieć prywatną.
  • Utwórz tożsamość zarządzaną z uprawnieniami za pośrednictwem sieci wirtualnej.
  • Wdróż zautomatyzowany klaster AKS w sieci wirtualnej.
  • Uruchom przykładową aplikację z wieloma kontenerami z grupą mikrousług i frontonów internetowych symulujących scenariusz sprzedaży detalicznej.

Jeśli nie masz konta Azure, utwórz konto free.

Wymagania wstępne

  • Azure CLI w wersji 2.86.0 lub nowszej. Aby znaleźć wersję, uruchom az --version polecenie . Jeśli musisz zainstalować lub uaktualnić, zobacz Install Azure CLI.

Uwaga

Ten przykład tworzy automatyczny klaster AKS przy użyciu zasobu azurerm_kubernetes_automatic_cluster dostawcy AzureRM, co wymaga dostawcy AzureRM w wersji v4.81 lub nowszej. Aby zapoznać się z równoważnym przykładem korzystającym z dostawcy AzAPI, zobacz przykład 101-aks-automatic-custom-network-azapi .

Ważne

Począwszy od wersji AKS 1.36 nowe klastry AKS Automatic będą domyślnie włączać Kubernetes Gateway API za pośrednictwem dodatku routingu aplikacji zamiast Managed NGINX Ingress z dodatkiem routingu aplikacji ze względu na wycofanie upstreamowego Ingress NGINX.

Nie ma to wpływu na istniejące klastry automatyczne, ale należy rozpocząć migrację do interfejsu API usługi Kubernetes Gateway za pośrednictwem dodatku routingu aplikacji.

Ograniczenia

Następujące ograniczenia dotyczą klastrów automatycznych usługi AKS:

  • Usługa AKS Automatic jest powszechnie dostępna w następujących regionach: australiacentral, australiaeast, australiasoutheast, westus3, austriaeast, belgiumcentral, 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.
  • Nowe klastry AKS Automatic mają domyślnie włączone zarządzane pule węzłów systemowych i LocalDNS. W żadnym regionie nie można utworzyć klastrów AKS Automatic bez zarządzanych pul węzłów systemowych.
  • Klaster automatyczny AKS ma wstępnie skonfigurowaną blokadę grupy zasobów węzłów, która nie pozwala na wprowadzanie zmian w grupie zasobów MC_, uniemożliwiając tworzenie łączy sieci wirtualnej w domyślnej prywatnej strefie DNS. W przypadku scenariuszy między sieciami wirtualnymi lub niestandardowymi systemami DNS użyj niestandardowej sieci i prywatnego systemu DNS, postępując zgodnie z instrukcjami Utwórz prywatny klaster Azure Kubernetes Service (AKS) automatyczny w niestandardowej sieci wirtualnej.
  • Azure CLI wymagana jest wersja 2.86.0 lub nowsza. Aby znaleźć wersję, uruchom az --version polecenie . Jeśli musisz zainstalować lub uaktualnić, zobacz Install Azure CLI.
  • Następujące rozszerzenia nie są obsługiwane:
  • Węzły systemu Windows nie są obsługiwane.
  • Migracja z podstawowego poziomu SKU usługi AKS do automatycznego poziomu SKU nie jest obsługiwana.
  • Migracja z istniejącego klastra automatycznego usługi AKS bez zarządzanych pul węzłów systemu do usługi AKS Automatic z zarządzanymi pulami węzłów systemu jest obsługiwana w wersji zapoznawczej w regionach, w których zarządzane pule węzłów systemu są ogólnie dostępne. Migracja z usługi AKS Automatic z zarządzanymi pulami węzłów systemu z powrotem do usługi AKS Automatic bez zarządzanych pul węzłów systemu nie jest obsługiwana.

Definiowanie zmiennych

Zdefiniuj następujące zmienne, które są używane w poniższych krokach.

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)

Tworzenie grupy zasobów

Grupa zasobów Azure to grupa logiczna, w której Azure zasoby są wdrażane i zarządzane.

Utwórz grupę zasobów przy użyciu polecenia az group create.

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

Następujące przykładowe dane wyjściowe przypominają pomyślne utworzenie grupy zasobów:

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

Tworzenie sieci wirtualnej

Utwórz sieć wirtualną przy użyciu az network vnet create polecenia . Utwórz podsieć serwera interfejsu API, podsieć węzła użytkownika i podsieć węzła systemowego az network vnet subnet create przy użyciu polecenia .

Jeśli używasz niestandardowej sieci wirtualnej z usługą AKS Automatic, musisz utworzyć podsieć serwera interfejsu API. Usługa AKS deleguje w Twoim imieniu podsieć do usługi Microsoft.ContainerService/managedClusters, co nadaje usłudze AKS uprawnienia do wdrażania zasobników serwera API i wewnętrznego modułu równoważenia obciążenia w tej podsieci. Nie można używać podsieci dla innych obciążeń, ale można jej użyć dla podsieci serwera interfejsu API dla wielu klastrów usługi AKS znajdujących się w tej samej sieci wirtualnej. Minimalny obsługiwany rozmiar podsieci serwera interfejsu API do obsługi pojedynczego klastra to /28.

Ostrzeżenie

Klaster AKS rezerwuje co najmniej dziewięć (9) adresów IP w przestrzeni adresowej podsieci. Brak adresów IP może uniemożliwić skalowanie serwera interfejsu API i spowodować awarię serwera interfejsu 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

Wymagania dotyczące sieciowej grupy zabezpieczeń

Jeśli dodano reguły sieciowej grupy zabezpieczeń (NSG) w celu ograniczenia ruchu między różnymi podsieciami w niestandardowej sieci wirtualnej, upewnij się, że reguły zabezpieczeń NSG zezwalają na wymagane typy komunikacji między składnikami klastra.

Aby zapoznać się ze szczegółowymi wymaganiami dotyczącymi NSG przy używaniu niestandardowych sieci wirtualnych z klastrami AKS, zobacz Niestandardowe wymagania dotyczące sieci wirtualnej.

Tworzenie tożsamości zarządzanej i nadawanie jej uprawnień w sieci wirtualnej

Utwórz tożsamość zarządzaną za pomocą polecenia az identity create i pobierz identyfikator podmiotu zabezpieczeń. Przypisz rolę Współautor sieci do tożsamości zarządzanej w sieci wirtualnej przy użyciu polecenia 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

Utwórz automatyczny klaster AKS w niestandardowej sieci wirtualnej

Aby utworzyć automatyczny klaster AKS, użyj polecenia 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 kilku minutach polecenie zostanie wykonane i zwróci informacje o klastrze w formacie JSON.

Łączenie z klastrem

Aby zarządzać klastrem Kubernetes, użyj klienta wiersza polecenia kubernetes kubectl. kubectl jest już zainstalowany, jeśli używasz Azure Cloud Shell. Aby zainstalować kubectl lokalnie, uruchom polecenie az aks install-cli . Klastry automatyczne AKS są konfigurowane przy użyciu Microsoft Entra ID dla kontroli dostępu opartej na rolach (RBAC) platformy Kubernetes.

Podczas tworzenia klastra przy użyciu Azure CLI użytkownikowi są przypisane role wbudowane dla .

Skonfiguruj kubectl, aby połączyć się z klastrem Kubernetes przy użyciu polecenia az aks get-credentials. To polecenie pobiera poświadczenia i konfiguruje Kubernetes CLI do ich użycia.

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

Sprawdź połączenie z klastrem przy użyciu polecenia kubectl get . To polecenie zwraca listę węzłów klastra.

kubectl get nodes

Poniższe przykładowe dane wyjściowe pokazują, jak poproszono Cię o zalogowanie.

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

Po zalogowaniu poniższy przykładowy wynik pokazuje zarządzane pule węzłów systemowych. Upewnij się, że stan węzła to Gotowe.

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

Tworzenie sieci wirtualnej

Ten plik Bicep definiuje sieć wirtualną.

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

Zapisz plik Bicep virtualNetwork.bicep na komputer lokalny.

Ważne

Plik Bicep ustawia parametr vnetName na aksAutomaticVnet, parametr addressPrefix na 172.19.0.0/16, parametr apiServerSubnetPrefix na 172.19.0.0/28 oraz parametr apiServerSubnetPrefix na 172.19.1.0/24. Jeśli chcesz użyć różnych wartości, pamiętaj, aby zaktualizować ciągi do preferowanych wartości.

Wdróż plik Bicep przy użyciu Azure CLI.

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

Cały ruch w sieci wirtualnej jest domyślnie dozwolony. Jeśli dodano reguły sieciowej grupy zabezpieczeń (NSG) w celu ograniczenia ruchu między różnymi podsieciami w niestandardowej sieci wirtualnej, upewnij się, że reguły zabezpieczeń NSG zezwalają na wymagane typy komunikacji między składnikami klastra.

Aby zapoznać się ze szczegółowymi wymaganiami dotyczącymi NSG przy używaniu niestandardowych sieci wirtualnych z klastrami AKS, zobacz Niestandardowe wymagania dotyczące sieci wirtualnej.

Tworzenie tożsamości zarządzanej

Ten plik Bicep definiuje tożsamość zarządzaną przypisaną przez użytkownika.

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

Zapisz plik Bicep uami.bicep na komputer lokalny.

Ważne

Plik Bicep ustawia parametr uamiName na aksAutomaticUAMI. Jeśli chcesz użyć innej nazwy tożsamości, pamiętaj o zaktualizowaniu ciągu do preferowanej nazwy.

Wdróż plik Bicep przy użyciu Azure CLI.

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

Przypisz rolę współpracownika sieci dla sieci wirtualnej

Ten plik Bicep definiuje przypisania ról w sieci wirtualnej.

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

Zapisz plik Bicep roleAssignments.bicep na komputer lokalny.

Ważne

Plik Bicep ustawia parametr vnetName na aksAutomaticVnet. Jeśli użyto innej nazwy sieci wirtualnej, pamiętaj o zaktualizowaniu ciągu do preferowanej nazwy sieci wirtualnej.

Wdróż plik Bicep przy użyciu Azure CLI. Musisz podać główny identyfikator tożsamości przypisanej przez użytkownika.

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

Utwórz automatyczny klaster AKS w niestandardowej sieci wirtualnej

Ten plik Bicep definiuje klaster automatyczny usługi 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}': {}
    }
  }
}

Zapisz plik Bicep aks.bicep na komputer lokalny.

Ważne

Plik Bicep ustawia parametr clusterName na aksAutomaticCluster. Jeśli chcesz mieć inną nazwę klastra, pamiętaj, aby zaktualizować ciąg do preferowanej nazwy klastra.

Wdróż plik Bicep przy użyciu Azure CLI. Musisz podać identyfikator zasobu podsieci serwera interfejsu API, identyfikator zasobu podsieci węzła użytkownika, identyfikator zasobu podsieci węzła systemowego i identyfikator zasobu tożsamości zarządzanej przypisanej przez użytkownika.

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>

Łączenie z klastrem

Aby zarządzać klastrem Kubernetes, użyj klienta wiersza polecenia kubernetes kubectl. kubectl jest już zainstalowany, jeśli używasz Azure Cloud Shell. Aby zainstalować kubectl lokalnie, uruchom polecenie az aks install-cli . Klastry automatyczne AKS są konfigurowane przy użyciu Microsoft Entra ID dla kontroli dostępu opartej na rolach (RBAC) platformy Kubernetes.

Ważne

Podczas tworzenia klastra przy użyciu Bicep należy przypisać jedną z wbudowanych ról, takich jak , Azure Kubernetes Service RBAC Reader, Azure Kubernetes Service RBAC Writer lub Azure Kubernetes Service RBAC Admin, do użytkowników, w zakresie klastra lub określonej przestrzeni nazw, na przykład przy użyciu Azure Kubernetes Service RBAC Cluster Admin. Upewnij się również, że użytkownicy mają wbudowaną rolę Azure Kubernetes Service Cluster User, aby móc uruchomić az aks get-credentials, a następnie uzyskać kubeconfig klastra AKS, używając polecenia az aks get-credentials.

Skonfiguruj kubectl, aby połączyć się z klastrem Kubernetes przy użyciu polecenia az aks get-credentials. To polecenie pobiera poświadczenia i konfiguruje Kubernetes CLI do ich użycia.

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

Sprawdź połączenie z klastrem przy użyciu polecenia kubectl get . To polecenie zwraca listę węzłów klastra.

kubectl get nodes

Poniższe przykładowe dane wyjściowe pokazują, jak poproszono Cię o zalogowanie.

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

Po zalogowaniu poniższy przykładowy wynik pokazuje zarządzane pule węzłów systemowych. Upewnij się, że stan węzła to Gotowe.

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

Przejrzyj kod narzędzia Terraform

Uwaga

Przykładowy kod dla tego artykułu znajduje się w repozytorium Azure Terraform na GitHubie. Możesz wyświetlić plik dziennika zawierający wyniki testu z bieżących i poprzednich wersji programu Terraform.

Zobacz więcej artykułów i przykładowego kodu pokazującego, jak zarządzać zasobami platformy Azure przy użyciu narzędzia Terraform.

  1. Utwórz katalog, w którym chcesz przetestować przykładowy kod narzędzia Terraform i ustawić go jako bieżący katalog.

  2. Utwórz plik o nazwie providers.tf i wstaw następujący kod:

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

provider "azurerm" {
  features {}
}

  3. Utwórz plik o nazwie main.tf i wstaw następujący kod:

    # Create a random name for the resource group using random_pet
resource "random_pet" "rg_name" {
  prefix = var.resource_group_name_prefix
}

# Create a resource group using the generated random name
resource "azurerm_resource_group" "rg" {
  location = var.resource_group_location
  name     = random_pet.rg_name.id
}

# Create the custom virtual network that hosts the cluster
resource "azurerm_virtual_network" "vnet" {
  name                = var.virtual_network_name
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name
  address_space       = var.virtual_network_address_space
}

# Create the subnet delegated to AKS for API Server VNet Integration
resource "azurerm_subnet" "api_server" {
  name                 = "apiServerSubnet"
  resource_group_name  = azurerm_resource_group.rg.name
  virtual_network_name = azurerm_virtual_network.vnet.name
  address_prefixes     = var.api_server_subnet_address_prefixes

  delegation {
    name = "aks-delegation"

    service_delegation {
      name    = "Microsoft.ContainerService/managedClusters"
      actions = ["Microsoft.Network/virtualNetworks/subnets/join/action"]
    }
  }
}

# Create the subnet that hosts the user node pools
resource "azurerm_subnet" "user_nodes" {
  name                 = "userNodeSubnet"
  resource_group_name  = azurerm_resource_group.rg.name
  virtual_network_name = azurerm_virtual_network.vnet.name
  address_prefixes     = var.user_node_subnet_address_prefixes
}

# Create the subnet that hosts the managed system node pool
resource "azurerm_subnet" "system_nodes" {
  name                 = "managedSystemNodeSubnet"
  resource_group_name  = azurerm_resource_group.rg.name
  virtual_network_name = azurerm_virtual_network.vnet.name
  address_prefixes     = var.system_node_subnet_address_prefixes

  lifecycle {
    # AKS adds its own managed cluster delegation to this subnet after the
    # cluster is created.
    ignore_changes = [delegation]
  }
}

# Create the user-assigned managed identity used by the cluster
resource "azurerm_user_assigned_identity" "aks" {
  name                = var.identity_name
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name
}

# Grant the cluster identity Network Contributor on the virtual network
resource "azurerm_role_assignment" "network_contributor" {
  scope                = azurerm_virtual_network.vnet.id
  role_definition_name = "Network Contributor"
  principal_id         = azurerm_user_assigned_identity.aks.principal_id
  principal_type       = "ServicePrincipal"
}

# Create a random name for the AKS Automatic cluster
resource "random_pet" "cluster_name" {
  prefix = var.cluster_name_prefix
}

# Create the AKS Automatic cluster in the custom virtual network
resource "azurerm_kubernetes_automatic_cluster" "aks_automatic" {
  name                = random_pet.cluster_name.id
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name

  identity {
    type         = "UserAssigned"
    identity_ids = [azurerm_user_assigned_identity.aks.id]
  }

  api_server_access {
    subnet_id = azurerm_subnet.api_server.id
  }

  hosted_system {
    node_subnet_id        = azurerm_subnet.user_nodes.id
    system_node_subnet_id = azurerm_subnet.system_nodes.id
  }

  depends_on = [azurerm_role_assignment.network_contributor]
}

  4. Utwórz plik o nazwie variables.tf i wstaw następujący kod:

    variable "resource_group_location" {
  type        = string
  default     = "westus2"
  description = "Location of the resource group."
}

variable "resource_group_name_prefix" {
  type        = string
  default     = "rg"
  description = "Prefix of the resource group name that's combined with a random ID so name is unique in your Azure subscription."
}

variable "cluster_name_prefix" {
  type        = string
  default     = "aks-automatic"
  description = "Prefix of the AKS Automatic cluster name that's combined with a random ID so the name is unique in your Azure subscription."
}

variable "virtual_network_name" {
  type        = string
  default     = "aks-automatic-vnet"
  description = "Name of the custom virtual network that hosts the cluster."
}

variable "identity_name" {
  type        = string
  default     = "aks-automatic-identity"
  description = "Name of the user-assigned managed identity that the cluster uses."
}

variable "virtual_network_address_space" {
  type        = list(string)
  default     = ["172.19.0.0/16"]
  description = "Address space of the custom virtual network."
}

variable "api_server_subnet_address_prefixes" {
  type        = list(string)
  default     = ["172.19.0.0/28"]
  description = "Address prefixes of the subnet delegated to the cluster API server."
}

variable "user_node_subnet_address_prefixes" {
  type        = list(string)
  default     = ["172.19.1.0/24"]
  description = "Address prefixes of the subnet that hosts the user node pools."
}

variable "system_node_subnet_address_prefixes" {
  type        = list(string)
  default     = ["172.19.0.64/26"]
  description = "Address prefixes of the subnet that hosts the managed system node pool."
}

  5. Utwórz plik o nazwie outputs.tf i wstaw następujący 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
}

Inicjowanie narzędzia Terraform

Uruchom terraform init, aby zainicjalizować wdrożenie Terraform. To polecenie pobiera dostawców Azure wymaganych do zarządzania zasobami Azure.

terraform init -upgrade

Tworzenie planu wykonania programu Terraform

Uruchom terraform plan, aby utworzyć plan realizacji.

terraform plan -out main.tfplan

Zastosuj plan wykonawczy Terraform

Uruchom terraform apply, aby zastosować plan wykonawczy do infrastruktury chmury.

terraform apply main.tfplan

Utworzenie klastra AKS Automatic zajmuje kilka minut.

Weryfikowanie klastra

  1. Pobierz nazwę grupy zasobów Azure i nazwę klastra.

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

  2. Uruchom polecenie az aks show, aby wyświetlić klaster i potwierdzić, że korzysta z warstwy SKU Automatic oraz z niestandardowych podsieci.

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

Łączenie z klastrem

Aby zarządzać klastrem Kubernetes, użyj klienta wiersza polecenia kubernetes kubectl. Możesz zainstalować lokalnie kubectl za pomocą polecenia az aks install-cli. Klastry automatyczne AKS są konfigurowane przy użyciu Microsoft Entra ID dla kontroli dostępu opartej na rolach (RBAC) platformy Kubernetes.

Skonfiguruj kubectl, aby połączyć się z klastrem Kubernetes przy użyciu polecenia az aks get-credentials.

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

Sprawdź połączenie z klastrem przy użyciu polecenia kubectl get .

kubectl get nodes

Wdrażanie aplikacji

Aby wdrożyć aplikację, należy użyć pliku manifestu, aby utworzyć wszystkie obiekty wymagane do uruchomienia aplikacji AKS Store. Plik manifestu Kubernetes definiuje żądany stan klastra, taki jak obrazy kontenerów, które mają być uruchomione. Manifest obejmuje następujące wdrożenia i usługi Kubernetes:

Zrzut ekranu przedstawiający przykładową architekturę Azure Store.

  • Front sklepu: aplikacja internetowa dla klientów do wyświetlania produktów i składania zamówień.
  • Usługa produktu: wyświetla informacje o produkcie.
  • Usługa zamówień: realizuje zamówienia.
  • Rabbit MQ: kolejka komunikatów dla kolejki zamówień.

Uwaga

Nie zalecamy uruchamiania kontenerów stanowych, takich jak przykładowo Rabbit MQ, bez trwałego miejsca do przechowywania w środowisku produkcyjnym. Te kontenery są używane tutaj dla uproszczenia, ale zalecamy używanie usług zarządzanych, takich jak Azure Cosmos DB lub Azure Service Bus.

  1. Utwórz przestrzeń nazw aks-store-demo w celu wdrożenia zasobów platformy Kubernetes.

    kubectl create ns aks-store-demo

  2. Wdróż aplikację przy użyciu polecenia kubectl apply w aks-store-demo przestrzeni nazw. Plik YAML definiujący wdrożenie znajduje się na GitHub.

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

    Następujące przykładowe dane wyjściowe przedstawiają wdrożenia i usługi:

    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

Testowanie aplikacji

Podczas uruchamiania aplikacji usługa Kubernetes uwidacznia fronton aplikacji w Internecie. Ten proces może potrwać kilka minut.

  1. Sprawdź stan wdrożonych zasobników używając polecenia kubectl get pods. Przed kontynuowaniem upewnij się, że wszystkie zasobniki są gotowe Running. Jeśli jest to pierwsze wdrażane obciążenie robocze, utworzenie przez automatyczne aprowizowanie węzłów puli węzłów do uruchamiania zasobników może potrwać kilka minut.

    kubectl get pods -n aks-store-demo

  2. Sprawdź publiczny adres IP aplikacji frontonu sklepu. Monitoruj postęp przy użyciu polecenia kubectl get service z argumentem --watch.

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

    Dane wyjściowe ADRESU dla store-front usługi początkowo są puste:

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

  3. Gdy adres zmieni się z pustego na rzeczywisty publiczny adres IP, użyj polecenia CTRL-C , aby zatrzymać kubectl proces oglądania.

    Następujące przykładowe dane wyjściowe pokazują prawidłowy publiczny adres IP przypisany do usługi:

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

  4. Otwórz przeglądarkę internetową i przejdź do zewnętrznego adresu IP twojego ruchu przychodzącego, aby zobaczyć aplikację Azure Store w działaniu.

    Zrzut ekranu przedstawiający przykładową aplikację sklepu AKS Store.

Usuwanie klastra

Jeśli nie planujesz przechodzenia przez samouczek AKS, wyczyść niepotrzebne zasoby, aby uniknąć opłat Azure. Uruchom polecenie az group delete , aby usunąć grupę zasobów, usługę kontenera i wszystkie powiązane zasoby.

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

Uwaga

Klaster usługi AKS został utworzony przy użyciu tożsamości zarządzanej przypisanej przez użytkownika. Jeśli nie potrzebujesz już tej tożsamości, możesz ją usunąć ręcznie.

Jeśli nie potrzebujesz już zasobów utworzonych za pomocą narzędzia Terraform, uruchom plan terraform i określ flagę destroy .

terraform plan -destroy -out main.destroy.tfplan

Uruchom terraform apply, aby zastosować plan wykonania.

terraform apply main.destroy.tfplan

Następne kroki

W tym przewodniku szybkiego startu wdrożyłeś klaster Kubernetes korzystając z AKS Automatic w niestandardowej sieci wirtualnej, a następnie wdrożyłeś prostą aplikację wielokontenerową. Ta przykładowa aplikacja służy tylko do celów demonstracyjnych i nie reprezentuje wszystkich najlepszych rozwiązań dla aplikacji Kubernetes. Aby uzyskać wskazówki dotyczące tworzenia pełnych rozwiązań za pomocą usługi AKS dla środowiska produkcyjnego, zobacz Wskazówki dotyczące rozwiązania AKS.

Aby dowiedzieć się więcej o usłudze AKS Automatic, przejdź do wprowadzenia.

Wprowadzenie do Azure Kubernetes Service (AKS) Automatic

  • Last updated on