Schnellstart: Erstellen eines Azure Kubernetes Service (AKS) automatischen Clusters in einem benutzerdefinierten virtuellen Netzwerk

Gilt für: ✔️ AKS Automatic

Azure Kubernetes Service (AKS) Automatic bietet die einfachste verwaltete Kubernetes-Erfahrung für Entwickler, DevOps-Ingenieure und Plattformtechniker. AKS Automatic automatisiert die Einrichtung von AKS-Clustern sowie Clustervorgänge und bettet Konfigurationen mit bewährten Methoden ein, wodurch es sich ideal für moderne Anwendungen und KI-Anwendungen (künstliche Intelligenz) eignet. Unabhängig von ihren Kenntnissen und Qualifikationen können alle Benutzer von der Sicherheit, Leistung und Zuverlässigkeit profitieren, die AKS Automatic für ihre Anwendungen bietet. AKS Automatic umfasst auch eine Vereinbarung zur Betriebsbereitschaft der Pods, die garantiert, dass 99,9 % der qualifizierenden Pod-Bereitschaftsvorgänge innerhalb von 5 Minuten abgeschlossen werden, wodurch eine zuverlässige, selbstheilende Infrastruktur für Ihre Anwendungen sichergestellt wird. Für diese Schnellstartanleitung werden Grundkenntnisse in Bezug auf die Kubernetes-Konzepte vorausgesetzt. Weitere Informationen finden Sie unter Kubernetes Kernkonzepte für Azure Kubernetes Service (AKS).

In dieser Schnellstartanleitung lernen Sie Folgendes:

• Erstellen Sie ein virtuelles Netzwerk.
• Erstellen Sie eine verwaltete Identität mit Berechtigungen für das virtuelle Netzwerk.
• Stellen Sie einen automatischen AKS-Cluster im virtuellen Netzwerk bereit.
• Führen Sie eine Beispielanwendung mit mehreren Containern mit einer Gruppe von Microservices und Web-Front-Ends aus, die ein Einzelhandelsszenario simulieren.

Wenn Sie kein Azure Konto haben, erstellen Sie ein free-Konto.

Voraussetzungen

• Clusteridentität mit einer Network Contributor integrierten Rollenzuweisung im API-Server-Subnetz.
• Clusteridentität mit einer Network Contributor integrierten Rollenzuweisung im virtuellen Netzwerk zur Unterstützung der automatischen Bereitstellung vonKnoten.
• Auf den Cluster wird mit der Benutzeridentität Azure Kubernetes Service Cluster User Role und Azure Kubernetes Service RBAC Writer zugegriffen.
• Ein virtuelles Netzwerk mit einem dedizierten API-Server-Subnetz mit mindestens */28 Größe, das an Microsoft.ContainerService/managedClusters delegiert wird.
  • Wenn eine Netzwerksicherheitsgruppe (Network Security Group, NSG) an Subnetze angefügt ist, stellen Sie sicher, dass die NSG-Sicherheitsregeln die erforderlichen Kommunikationstypen zwischen Clusterkomponenten zulassen. Detaillierte Anforderungen finden Sie unter "Anforderungen für benutzerdefinierte virtuelle Netzwerke".
  • Wenn eine Azure Firewall oder eine andere ausgehende Einschränkungsmethode oder Appliance vorhanden ist, stellen Sie sicher, dass die angeforderten ausgehenden Netzwerkregeln und FQDNs zulässig sind.
• AKS Automatic wird Azure Policy auf Ihrem AKS-Cluster aktivieren, Sie sollten jedoch den Microsoft.PolicyInsights-Ressourcenanbieter in Ihrem Abonnement vorab registrieren, um eine reibungslosere Erfahrung zu erzielen. Weitere Informationen finden Sie unter Azure Ressourcenanbieter und -typen.
• Deinstallieren Sie die AKS-Preview-Erweiterung mit az extension remove -n aks-preview.

Einschränkungen

Die folgenden Einschränkungen gelten für automatische AKS-Cluster:

• AKS Automatic ist in den folgenden Regionen allgemein verfügbar: australiaeast, austriaeast, belgiumcentral, brazilsouth, canadacentral, centralindia, centralus, chilecentral, denmarkeast, eastasia, eastus, eastus2, francecentral, germanywestcentral, indonesiacentral, israelcentral, italynorth, japaneast, japanwest, koreacentral, malaysiawest, mexicocentral, newzealandnorth, northeurope, norwayeast, polandcentral, southafricanorth, southcentralus, southeastasia, spaincentral, swedencentral, switzerlandnorth, uaenorth, uksouth, westeurope, westus2, westus3.
  • Neue automatische AKS-Cluster aktivieren standardmäßig verwaltete Systemknotenpools und LocalDNS. Sie können keine automatischen AKS-Cluster ohne verwaltete Systemknotenpools in einer beliebigen Region erstellen.
• AKS Automatic ist mit node resource group lockdown vorkonfiguriert, wodurch keine Änderungen an der Ressourcengruppe MC_ zulässig sind und virtuelle Netzwerkverknüpfungen in der standardmäßigen privaten DNS-Zone verhindert werden. Für VNet-übergreifende oder benutzerdefinierte DNS-Szenarien verwenden Sie ein benutzerdefiniertes Netzwerk und einen privaten DNS gemäß den Anweisungen unter Erstellen eines privaten Azure Kubernetes Service (AKS) automatischen Clusters in einem benutzerdefinierten virtuellen Netzwerk.
• Azure CLI Version 2.86.0 oder höher ist erforderlich. Um die Version zu finden, führen Sie den Befehl aus az --version . Informationen zum Installieren oder Aktualisieren finden Sie unter Install Azure CLI.
• Die folgenden Erweiterungen werden nicht unterstützt:
  • Dapr
  • Azure Machine Learning
• Windows-Knoten werden nicht unterstützt.
• Das Istio-basierte Dienstgitter-Add-On für AKS wird nicht unterstützt.
• Die Migration zwischen AKS-Basis-SKU und automatischer SKU wird nicht unterstützt.
• Migrationen zwischen automatischen AKS-Clustern ohne verwaltete Systemknotenpools und AKS Automatische Cluster mit verwalteten Systemknotenpools werden nicht unterstützt.
• Die Konfiguration von benutzerdefiniertem Scraping von Prometheus-Metriken und Protokollerfassung wird nicht unterstützt.
• Das Aktivieren von ACNS observability während der automatischen Clustererstellung wird nicht unterstützt. Sie können ACNS-Observability aktivieren, nachdem der Cluster erstellt wurde.

Definieren von Variablen

Definieren Sie die folgenden Variablen, die in den folgenden Schritten verwendet werden.

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)

Erstellen einer Ressourcengruppe

Eine Azure-Ressourcengruppe ist eine logische Gruppe, in der Azure Ressourcen bereitgestellt und verwaltet werden.

Erstellen Sie mit dem Befehl az group create eine Ressourcengruppe.

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

Die folgende Beispielausgabe ähnelt der Ausgabe bei der erfolgreichen Erstellung der Ressourcengruppe:

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

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

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

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

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

kubectl get nodes

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

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

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

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

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

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

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

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

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

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>

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

kubectl get nodes

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

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

Bereitstellen der Anwendung

Zum Bereitstellen der Anwendung verwenden Sie eine Manifestdatei, um alle Objekte zu erstellen, die zum Ausführen der AKS Store-Anwendung erforderlich sind. Eine Kubernetes-Manifestdatei definiert den gewünschten Zustand (Desired State) eines Clusters – also beispielsweise, welche Containerimages ausgeführt werden sollen. Das Manifest umfasst die folgenden Kubernetes-Bereitstellungen und -Dienste:

• Store Front: Webanwendung für Kund*innen zum Anzeigen von Produkten und Aufgeben von Bestellungen
• Product Service: zeigt Produktinformationen an.
• Order Service: Gibt Bestellungen auf.
• Rabbit MQ: Nachrichtenwarteschlange für eine Auftragswarteschlange.

1. Erstellen Sie einen Namespace aks-store-demo, in dem die Kubernetes-Ressourcen bereitgestellt werden.

   kubectl create ns aks-store-demo
   

2. Stellen Sie die Anwendung mit dem Befehl kubectl apply im Namespace aks-store-demo bereit. Die YAML-Datei, die die Bereitstellung definiert, befindet sich auf GitHub.

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

   Die folgende Beispielausgabe zeigt die Bereitstellungen und Dienste:

   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
   

Testen der Anwendung

Wenn die Anwendung ausgeführt wird, macht ein Kubernetes-Dienst das Anwendungs-Front-End im Internet verfügbar. Dieser Vorgang kann einige Minuten dauern.

1. Sehen Sie sich den Status der bereitgestellten Pods mithilfe des Befehls kubectl get pods an. Stellen Sie sicher, dass alle Pods den Status Running haben, bevor Sie fortfahren. Wenn Sie diese Workload zum ersten Mal bereitstellen, kann es einige Minuten dauern, bis die automatische Knotenbereitstellung einen Knotenpool erstellt, auf dem die Pods ausgeführt werden können.

   kubectl get pods -n aks-store-demo
   

2. Suchen Sie nach einer öffentlichen IP-Adresse für die Store-Front-Anwendung. Verwenden Sie zum Überwachen des Fortschritts den Befehl kubectl get service mit dem Argument --watch:

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

   Die Ausgabe von ADDRESS für den store-front-Dienst ist anfangs leer:

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

3. Sobald ADDRESS von einem leeren in eine tatsächliche öffentliche IP-Adresse geändert wird, verwenden Sie CTRL-C, um den kubectl-Beobachtungsprozess zu beenden.

   Die folgende Beispielausgabe zeigt eine gültige öffentliche IP-Adresse, die dem Dienst zugewiesen ist:

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

4. Öffnen Sie einen Webbrowser mit der externen IP-Adresse Ihres Eingangs, um die Azure Store-App in Aktion zu sehen.

   

Löschen des Clusters

Wenn Sie nicht planen, das Lernprogramm AKS zu durchlaufen, bereinigen Sie unnötige Ressourcen, um Azure Gebühren zu vermeiden. Führen Sie den Befehl az group delete aus, um die Ressourcengruppe, den Containerdienst und alle dazugehörigen Ressourcen zu entfernen.

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

Nächste Schritte

In dieser Schnellstartanleitung haben Sie einen Kubernetes-Cluster mit AKS Automatic in einem benutzerdefinierten virtuellen Netzwerk bereitgestellt und anschließend eine einfache Multicontaineranwendung dafür bereitgestellt. Diese Beispielanwendung dient nur zu Demozwecken und stellt nicht alle bewährten Methoden für Kubernetes-Anwendungen dar. Anleitungen zum Erstellen vollständiger Lösungen mit AKS für die Produktion finden Sie unter AKS-Lösungsleitfaden.

Weitere Informationen zu AKS Automatic finden Sie in der Einführung.