Schnellstart: Erstellen eines Azure Kubernetes Service (AKS) automatischen Clusters

• Verwenden Sie die Bash-Umgebung in Azure Cloud Shell. Weitere Informationen finden Sie unter Get started with Azure Cloud Shell.

  

• Wenn Sie CLI-Referenzbefehle lieber lokal ausführen möchten, install die Azure CLI. Wenn Sie Windows oder macOS verwenden, ziehen Sie in Betracht, Azure CLI in einem Docker-Container auszuführen. Weitere Informationen finden Sie unter How to run the Azure CLI in a Docker container.

  • Wenn Sie eine lokale Installation verwenden, melden Sie sich mit dem Befehl az login beim Azure CLI an. Um den Authentifizierungsprozess abzuschließen, führen Sie die schritte aus, die in Ihrem Terminal angezeigt werden. Weitere Anmeldeoptionen finden Sie unter Authentifizieren bei Azure mithilfe von Azure CLI.

  • Wenn Sie dazu aufgefordert werden, installieren Sie die Azure CLI Erweiterung bei der ersten Verwendung. Weitere Informationen zu Erweiterungen finden Sie unter Use and manage extensions with the Azure CLI.

  • Führen Sie az version aus, um die installierte Version und die abhängigen Bibliotheken zu ermitteln. Führen Sie az upgrade aus, um auf die neueste Version zu aktualisieren.

• Azure CLI Version 2.86.0 oder höher. Um die Version zu finden, führen Sie den Befehl aus az --version . Wenn Sie eine Installation oder ein Upgrade durchführen müssen, finden Sie weitere Informationen unter Azure CLI installieren.
• Wenn Sie mehrere Azure-Abonnements haben, wählen Sie mit dem Befehl az account set die entsprechende Abonnement-ID für die Abrechnung von Ressourcen aus.

• Zum Bereitstellen einer Bicep-Datei benötigen Sie Schreibzugriff auf die Ressourcen, die Sie erstellen, sowie Zugriff auf alle Vorgänge des Ressourcentyps Microsoft.Resources/deployments. Um beispielsweise einen virtuellen Computer (VM) zu erstellen, benötigen Sie Microsoft.Compute/virtualMachines/write und Microsoft.Resources/deployments/* Berechtigungen. Eine Liste der Rollen und Berechtigungen finden Sie unter Azure integrierte Rollen.

• Installieren und konfigurieren Sie Terraform.

Erstellen einer Ressourcengruppe

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

Erstellen Sie eine Ressourcengruppe mit dem Befehl az group create. Im folgenden Beispiel wird eine Ressourcengruppe mit dem Namen myResourceGroup am Standort canadacentral erstellt:

az group create --name myResourceGroup --location canadacentral

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

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

Erstellen eines AKS Automatic-Clusters

Erstellen Sie einen automatischen AKS-Cluster mit dem az aks create-Befehl, wobei der --sku-Parameter auf automatic festgelegt wird. Im folgenden Beispiel wird ein Cluster mit dem Namen myAKSAutomaticCluster mit verwaltetem Prometheus und aktivierter Container Insights-Integration erstellt:

az aks create \
    --resource-group myResourceGroup \
    --name myAKSAutomaticCluster \
    --sku automatic
    --enable-hosted-system

Wenn die Bereitstellung abgeschlossen ist, zeigt die Ausgabe ein hostedSystemProfile-Eigenschaftsset mit einem enabled-Eigenschaftsset, das auf true festgelegt ist. Sie können auch den folgenden Befehl ausführen, um die hostedSystemProfile Eigenschaften anzuzeigen:

az aks show \
  --resource-group myResourceGroup \
  --name myAKSAutomaticCluster \
  --query hostedSystemProfile

{
  "enabled": true,
  "nodeSubnetId": null,
  "systemNodeSubnetId": null
}

Erstellen eines Automatic Kubernetes-Clusters

1. Um einen automatischen AKS-Cluster zu erstellen, suchen und wählen Sie Kubernetes-Dienste aus. Dadurch gelangen Sie zur Kubernetes Center -Seite (Vorschau ).

2. Wählen Sie auf der Kubernetes Center-Seite (Vorschau) die Option"Automatische Kubernetes-Cluster>" aus.

   

3. Füllen Sie auf der Registerkarte " Grundlagen " alle erforderlichen Felder aus (Abonnement, Ressourcengruppe, Kubernetes-Clustername und Region), und wählen Sie dann "Weiter" aus.

   

4. Wählen Sie auf der Registerkarte Monitoring Ihre gewünschten Überwachungskonfigurationen aus Azure Monitor (Containereinblicke), verwaltete Prometheus- und Grafana-Dashboards und Benachrichtigungen aus, und wählen Sie dann Next aus.

   

5. Wählen Sie auf der Registerkarte Advanced Ihre gewünschten erweiterten Konfigurationen für den privaten Zugriff aus, Azure Virtual Networking, Managed Identity, Container Network Security (ACNS) und Verwaltete Kubernetes-Namespaces, und wählen Sie dann Review + create aus.

   

6. Überprüfen Sie die Konfigurationen auf der Registerkarte " Überprüfen+ Erstellen ", und wählen Sie dann "Erstellen" aus, um den automatischen AKS-Cluster bereitzustellen.

7. Starten Sie mit der Konfiguration Ihrer ersten Anwendung aus GitHub und mit dem Einrichten einer automatisierten Deployment-Pipeline.

   

Überprüfen Sie die Bicep-Datei

Die folgende Bicep Datei definiert einen automatischen AKS-Cluster:

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

@description('The location of the managed cluster resource.')
param location string = resourceGroup().location

resource aks 'Microsoft.ContainerService/managedClusters@2026-02-01' ' = {
  name: clusterName
  location: location
  sku: {
    name: 'Automatic'
  }
  identity: {
    type: 'SystemAssigned'
  }
}

Weitere Informationen zur in der datei Bicep definierten Ressource finden Sie im Microsoft. ContainerService/managedClusters Reference.

Bereitstellen der Bicep Datei

1. Speichern Sie die Bicep Datei als main.bicep auf Ihren lokalen Computer.

   Von Bedeutung

   Die Bicep-Datei legt den clusterName Parameter auf die Zeichenfolge myAKSAutomaticCluster fest. Wenn Sie einen anderen Clusternamen wünschen, ändern Sie die Zeichenfolge in den gewünschten Clusternamen, ehe Sie die Datei auf Ihrem Computer speichern.

2. Stellen Sie die Bicep Datei mithilfe des Befehls [az deployment group create][az-deployment-group-create] bereit.

   az deployment group create --resource-group myResourceGroup --template-file main.bicep
   

   Die Erstellung des AKS-Clusters dauert einige Minuten. Warten Sie, bis der Cluster erfolgreich bereitgestellt wurde, bevor Sie mit dem nächsten Schritt fortfahren.

Überprüfen Sie den Terraform-Code

1. Erstellen Sie ein Verzeichnis, um den Terraform-Beispielcode zu testen und als aktuelles Verzeichnis festzulegen.

2. Erstellen Sie eine Datei mit dem Namen providers.tf, und fügen Sie den folgenden Code ein:

   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. Erstellen Sie eine Datei mit dem Namen main.tf und fügen Sie folgenden Code hinzu:

   # 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 a random name for the AKS Automatic cluster
   resource "random_pet" "cluster_name" {
     prefix = var.cluster_name_prefix
   }
   
   # Create the AKS Automatic cluster
   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 = "SystemAssigned"
     }
   }
   

4. Erstellen Sie eine Datei mit dem Namen variables.tf und fügen Sie folgenden Code hinzu:

   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."
   }
   

5. Erstellen Sie eine Datei mit dem Namen outputs.tf, und fügen Sie den folgenden Code ein:

   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 "fully_qualified_domain_name" {
     value = azurerm_kubernetes_automatic_cluster.aks_automatic.fully_qualified_domain_name
   }
   

Terraform initialisieren

Führen Sie terraform init aus, um die Terraform-Bereitstellung zu initialisieren. Mit diesem Befehl werden die Azure Anbieter heruntergeladen, die zum Verwalten Ihrer Azure Ressourcen erforderlich sind.

terraform init -upgrade

Terraform-Ausführungsplan erstellen

Führen Sie terraform plan aus, um einen Ausführungsplan zu erstellen.

terraform plan -out main.tfplan

Wenden Sie einen Terraform-Ausführungsplan an

Führen Sie terraform apply aus, um den Ausführungsplan auf Ihre Cloudinfrastruktur anzuwenden.

terraform apply main.tfplan

Das Erstellen eines automatischen AKS-Clusters dauert mehrere Minuten, bis der Vorgang abgeschlossen ist.

Überprüfen des Clusters

1. Rufen Sie den Azure Ressourcengruppennamen und den Clusternamen ab.

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

2. Führen Sie az aks show aus, um den Cluster anzuzeigen und zu bestätigen, dass der Cluster die Automatic SKU verwendet.

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

1. Mit dem Befehl kubectl können Sie az aks get-credentials für die Verbindungsherstellung mit Ihrem Kubernetes-Cluster konfigurieren. Mit diesem Befehl werden die Anmeldeinformationen heruntergeladen, und die Kubernetes-Befehlszeilenschnittstelle wird für deren Verwendung konfiguriert.

   az aks get-credentials --resource-group myResourceGroup --name myAKSAutomaticCluster
   

1. Konfigurieren Sie kubectl, um mit dem Befehl az aks get-credentials eine Verbindung mit Ihrem Kubernetes-Cluster herzustellen. Mit diesem Befehl werden die Anmeldeinformationen heruntergeladen, und die Kubernetes-Befehlszeilenschnittstelle wird für deren Verwendung konfiguriert.

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

Entfernen Sie die Ressourcengruppe, den Containerdienst und alle zugehörigen Ressourcen mithilfe des Befehls az group delete.

az group delete --name myResourceGroup --yes --no-wait

Wenn Sie die ressourcen, die Sie mit Terraform erstellt haben, nicht mehr benötigen, führen Sie den Terraform-Plan aus, und geben Sie die destroy Kennzeichnung an.

terraform plan -destroy -out main.destroy.tfplan

Führen Sie den Befehl terraform apply aus, um den Ausführungsplan anzuwenden.

terraform apply main.destroy.tfplan