Rychlý start: Vytvoření privátního 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íť.
  • Nasaďte privátní cluster AKS Automatic cluster ve virtuální síti.
  • Připojte se k privátnímu clusteru.
  • Spusťte ukázkovou vícekontenerovou aplikaci se skupinou mikroslužeb a webových front-endů simulujících scénář maloobchodního prodeje.

Požadavky

  • Pokud účet Azure nemáte, vytvořte si účet free.
  • 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á zprostředkovatele AzAPI, najdete v ukázce 101-aks-automatic-private-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ě k dispozici 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žijí 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 a podsíť clusteru az network vnet subnet create .

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

Pravidla skupiny zabezpečení sítě

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

Cíl Zdroj Protokol Přístav Používání
CIDR pro podsíť serveru API podsíť uživatelského uzlu a podsíť systémového uzlu protokol TCP 443 a 4443 Vyžaduje se k povolení komunikace mezi uzly a serverem rozhraní API.
CIDR pro podsíť serveru API Azure Load Balancer protokol TCP 9988 Vyžaduje se k povolení komunikace mezi Azure Load Balancer a serverem rozhraní API. Můžete také povolit veškerou komunikaci mezi Azure Load Balancerem a podsítí CIDR serveru API.
CIDR uzlu CIDR uzlu Všechny protokoly Všechny porty Vyžaduje se k povolení komunikace mezi uzly.
CIDR uzlu CIDR podu Všechny protokoly Všechny porty Vyžaduje se pro směrování provozu služby.
CIDR podu CIDR podu Všechny protokoly Všechny porty Vyžadováno pro komunikaci mezi pody a mezi pody a službami, včetně DNS.

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í privátního automatického clusteru AKS ve vlastní virtuální síti

Pokud chcete vytvořit privátní cluster AKS Automatic, použijte příkaz az aks create . Poznamenejte si použití příznaku --enable-private-cluster .

Poznámka:

Informace o konfiguraci dalších možností, jako je zakázání veřejného plně kvalifikovaného názvu domény clusteru a konfigurace privátní zóny DNS, najdete v dokumentaci k privátnímu clusteru .

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 \
--enable-private-cluster \
--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

Když se automatický cluster AKS vytvoří jako privátní cluster, serverové rozhraní API nemá žádnou veřejnou IP adresu. Pokud chcete spravovat server rozhraní API, například přes kubectl, musíte se připojit přes počítač, který má přístup ke Azure virtuální síti clusteru. Existuje několik možností, jak zajistit síťovou konektivitu k privátnímu clusteru.

Nejjednodušší možností je vytvoření virtuálního počítače ve stejné virtuální síti jako cluster AKS. ExpressRoute a sítě VPN přidávají náklady a vyžadují další složitost sítí. Párování virtuálních sítí vyžaduje plánování rozsahů CIDR vaší sítě, abyste zajistili, že se rozsahy nepřekrývají. Další informace najdete v tématu Možnosti připojení k privátnímu 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 ale přidali pravidla skupiny zabezpečení sítě (NSG), která omezují provoz mezi různými podsítěmi, ujistěte se, že pravidla zabezpečení NSG povolují následující typy komunikace:

Cíl Zdroj Protokol Přístav Používání
CIDR pro podsíť serveru API podsíť uživatelského uzlu a podsíť systémového uzlu protokol TCP 443 a 4443 Vyžaduje se k povolení komunikace mezi uzly a serverem rozhraní API.
CIDR pro podsíť serveru API Azure Load Balancer protokol TCP 9988 Vyžaduje se k povolení komunikace mezi Azure Load Balancer a serverem rozhraní API. Můžete také povolit veškerou komunikaci mezi Azure Load Balancerem a podsítí CIDR serveru API.
CIDR uzlu CIDR uzlu Všechny protokoly Všechny porty Vyžaduje se k povolení komunikace mezi uzly.
CIDR uzlu CIDR podu Všechny protokoly Všechny porty Vyžaduje se pro směrování provozu služby.
CIDR podu CIDR podu Všechny protokoly Všechny porty Vyžadováno pro komunikaci mezi pody a mezi pody a službami, včetně DNS.

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í privátního automatického clusteru AKS ve vlastní virtuální síti

Tento Bicep soubor definuje automatický cluster AKS.

Poznámka:

Informace o konfiguraci dalších možností, jako je zakázání veřejného plně kvalifikovaného názvu domény clusterů a konfigurace zóny privátního DNS, najdete v dokumentaci k privátnímu clusteru .

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

@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 private 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
        enablePrivateCluster: true
    }
    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 aksPrivateAutomaticCluster. 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 uamiPrincipalId=<user assigned identity prinicipal id>

Připojení ke clusteru

Když se automatický cluster AKS vytvoří jako privátní cluster, serverové rozhraní API nemá žádnou veřejnou IP adresu. Pokud chcete spravovat server rozhraní API, například přes kubectl, musíte se připojit přes počítač, který má přístup ke Azure virtuální síti clusteru. Existuje několik možností, jak zajistit síťovou konektivitu k privátnímu clusteru.

Nejjednodušší možností je vytvoření virtuálního počítače ve stejné virtuální síti jako cluster AKS. ExpressRoute a sítě VPN přidávají náklady a vyžadují větší složitost sítě. Párování virtuálních sítí vyžaduje plánování rozsahů CIDR vaší sítě, abyste zajistili, že se rozsahy nepřekrývají. Další informace najdete v tématu Možnosti připojení k privátnímu 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ář pro testování ukázkového kódu Terraformu a nastavte 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 přidejte 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 private 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
  }

  # The private_cluster block gives the API server a private IP address in the
  # virtual network. Reaching it requires private connectivity and DNS
  # resolution of the private FQDN, which peering, a VPN, or ExpressRoute can
  # provide from outside this virtual network.
  private_cluster {
    public_fully_qualified_domain_name_enabled = var.public_fully_qualified_domain_name_enabled
  }

  depends_on = [azurerm_role_assignment.network_contributor]
}

  4. Vytvořte soubor s názvem variables.tf a přidejte 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 "public_fully_qualified_domain_name_enabled" {
  type        = bool
  default     = false
  description = "Whether to provision a public FQDN for the private cluster."
}

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 "private_fully_qualified_domain_name" {
  value = azurerm_kubernetes_automatic_cluster.aks_automatic.private_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 az aks show, aby se zobrazil cluster, a potvrďte, že je privátní a používá Automatic SKU.

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

Připojení ke clusteru

Server rozhraní API privátního clusteru nemá žádnou veřejnou IP adresu, takže ji spravujete z počítače, který má síťový přístup k virtuální síti clusteru. Máte několik možností pro navázání připojení:

Další informace najdete v tématu Možnosti připojení k privátnímu clusteru.

Na počítači s připojením k virtuální síti nakonfigurujte kubectl připojení ke clusteru Kubernetes pomocí příkazu az aks get-credentials . Automatické clustery AKS jsou nakonfigurované s Microsoft Entra ID pro řízení přístupu na základě role Kubernetes (RBAC) .

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 objednávek: Vyřizuje objednávky.
  • Rabbit MQ: Systém zpráv pro správu fronty objednávek.

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 se umístí 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 privátní cluster Kubernetes pomocí služby AKS Automatic v rámci vlastní virtuální sítě a pak jste do ní nasadili jednoduchou aplikaci s více kontejnery. 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.

Vzhledem k tomu, že je tento cluster privátní, nemá jeho server rozhraní API žádnou veřejnou IP adresu. Informace o připojení ke clusteru a jeho správě najdete v tématu Možnosti připojení k privátnímu clusteru. Další možnosti konfigurace privátního clusteru najdete v dokumentaci k privátnímu clusteru .

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

Úvod do Azure Kubernetes Service (AKS) Automatic

  • Poslední aktualizace v