Schnellstart: Bereitstellen eines Azure Kubernetes Service-Clusters (AKS) mithilfe von Terraform

  • Artikel

Azure Kubernetes Service (AKS) ist ein verwalteter Kubernetes-Dienst, mit dem Sie schnell Cluster bereitstellen und verwalten können. In dieser Schnellstartanleitung führen Sie die folgenden Schritte aus:

  • Erstellen Sie einen AKS-Cluster mithilfe von Terraform.
  • Führen Sie eine Beispielanwendung mit mehreren Containern mit einer Gruppe von Microservices und Web-Front-Ends aus, die ein Einzelhandelsszenario simulieren.

Hinweis

Um schnell mit der Bereitstellung eines AKS-Clusters zu beginnen, enthält dieser Artikel Schritte zum Bereitstellen eines Clusters mit Standardeinstellungen nur zu Evaluierungszwecken. Bevor Sie einen produktionsbereiten Cluster bereitstellen, empfehlen wir Ihnen, sich mit unserer Baselinereferenzarchitektur vertraut zu machen, um zu prüfen, inwiefern sie Ihren Geschäftsanforderungen entspricht.

Voraussetzungen

Hinweis

Der Azure Linux-Knotenpool ist jetzt allgemein verfügbar (GA). Informationen zu den Vorteilen und Bereitstellungsschritten finden Sie in der Einführung in den Azure-Linux-Containerhost für AKS.

Anmelden bei Ihrem Azure-Konto

Melden Sie sich zunächst bei Ihrem Azure-Konto an, und authentifizieren Sie sich mit einer der im folgenden Abschnitt beschriebenen Methoden.

Terraform- und Azure-Authentifizierungsszenarien

Terraform unterstützt für die Authentifizierung bei Azure nur die Azure-Befehlszeilenschnittstelle (Azure CLI). Die Authentifizierung mit Azure PowerShell wird nicht unterstützt. Obwohl Sie für Ihre Arbeit mit Terraform das Azure PowerShell-Modul verwenden können, müssen Sie sich daher zunächst mithilfe der Azure CLI bei Azure authentifizieren.

In diesem Artikel wird für die unten genannten Szenarien erläutert, wie Sie Terraform bei Azure authentifizieren. Weitere Informationen zu den Optionen für die Authentifizierung von Terraform bei Azure finden Sie unter Authentifizieren mithilfe der Azure CLI.

Authentifizieren bei Azure über ein Microsoft-Konto

Ein Microsoft-Konto ist ein Benutzername (mit einer zugeordneten E-Mail-Adresse und zugehörigen Anmeldeinformationen), der zum Anmelden bei Microsoft-Diensten wie z. B. Azure verwendet wird. Ein Microsoft-Konto kann mit einem oder mehreren Azure-Abonnements verknüpft werden, wobei eines davon das Standardabonnement ist.

In den folgenden Schritten wird die Vorgehensweise erläutert:

  • Melden Sie sich interaktiv mit einem Microsoft-Konto bei Azure an
  • Listen Sie die zugeordneten Azure-Abonnements des Kontos (einschließlich der Standardeinstellung) auf
  • Legen Sie das aktuelle Abonnement fest.

  1. Öffnen Sie eine Befehlszeile, die Zugriff auf die Azure CLI hat.

  2. Führen Sie az login ohne Parameter aus, und befolgen Sie die Anweisungen, um sich bei Azure anzumelden.

    az login

    Die wichtigsten Punkte:

    • Nach erfolgreicher Anmeldung zeigt az login eine Liste der Azure-Abonnements an, die mit dem angemeldeten Microsoft-Konto verknüpft sind (einschließlich des Standardabonnements).

  3. Führen Sie zum Überprüfen des aktuellen Azure-Abonnements az account show aus.

    az account show

  4. Führen Sie zum Anzeigen aller Azure-Abonnementnamen und -IDs für ein bestimmtes Microsoft-Konto az account list aus.

    az account list --query "[?user.name=='<microsoft_account_email>'].{Name:name, ID:id, Default:isDefault}" --output Table

    Die wichtigsten Punkte:

    • Ersetzen Sie den Platzhalter <microsoft_account_email> durch die E-Mail-Adresse des Microsoft-Kontos, dessen Azure-Abonnements Sie auflisten möchten.
    • Bei einem Live-Konto (z. B. Hotmail oder Outlook) müssen Sie möglicherweise die vollqualifizierte E-Mail-Adresse angeben. Wenn Ihre E-Mail-Adresse admin@hotmail.com lautet, würden Sie den Platzhalter in diesem Fall z. B. durch live.com#admin@hotmail.com ersetzen.

  5. Führen Sie az account set aus, um ein bestimmtes Azure-Abonnement zu verwenden.

    az account set --subscription "<subscription_id_or_subscription_name>"

    Die wichtigsten Punkte:

    • Ersetzen Sie den Platzhalter <subscription_id_or_subscription_name> durch die ID oder den Namen des gewünschten Abonnements.
    • Die Ergebnisse des Wechsels zum angegebenen Azure-Abonnement werden durch den Aufruf von az account set nicht angezeigt. Sie können sich jedoch mithilfe von az account show vergewissern, dass sich das aktuelle Azure-Abonnement geändert hat.
    • Wenn Sie den Befehl az account list im vorherigen Schritt ausführen, sehen Sie, dass das Azure-Standardabonnement in das Abonnement geändert wurde, das Sie mit az account set angegeben haben.

Erstellen eines Dienstprinzipals

Automatisierte Tools wie Terraform, die Azure-Dienste bereitstellen oder verwenden, sollten stets über eingeschränkte Berechtigungen verfügen. Azure bietet Dienstprinzipale, damit Anwendungen nicht als Benutzer mit uneingeschränkten Berechtigungen angemeldet werden müssen.

Das gängigste Muster für die interaktive Anmeldung bei Azure besteht darin, einen Dienstprinzipal zu erstellen, zu testen und dann für die zukünftige Authentifizierung (interaktiv oder über Ihre Skripts) zu verwenden.

  1. Um einen Dienstprinzipal zu erstellen, melden Sie sich bei Azure an. Führen Sie dazu die Schritte zum Authentifizieren bei Azure über ein Microsoft-Konto aus, und kehren Sie dann hierher zurück.

  2. Wenn Sie einen Dienstprinzipal über Git Bash erstellen, legen Sie die Umgebungsvariable MSYS_NO_PATHCONV fest. (Bei Verwendung von Cloud Shell ist dieser Schritt nicht erforderlich.)

    export MSYS_NO_PATHCONV=1

    Die wichtigsten Punkte:

    • Sie können die Umgebungsvariable MSYS_NO_PATHCONV global (für alle Terminalsitzungen) oder lokal (nur für die aktuelle Sitzung) festlegen. Da Sie nur selten einen Dienstprinzipal erstellen müssen, wird der Wert im Beispiel für die aktuelle Sitzung festgelegt. Um diese Umgebungsvariable global festzulegen, fügen Sie die Einstellung der ~/.bashrc-Datei hinzu.

  3. Führen Sie zum Erstellen eines Dienstprinzipals az ad sp create-for-rbac aus.

    az ad sp create-for-rbac --name <service_principal_name> --role Contributor --scopes /subscriptions/<subscription_id>

    Die wichtigsten Punkte:

    • Sie können <service-principal-name> durch einen benutzerdefinierten Namen für Ihre Umgebung ersetzen oder den Parameter ganz weglassen. Wenn Sie den Parameter weglassen, wird der Dienstprinzipalname basierend auf dem aktuellen Datum und der aktuellen Uhrzeit generiert.
    • Nach dem erfolgreichen Abschluss werden von az ad sp create-for-rbac verschiedene Werte angezeigt. Die Werte appId, password und tenant werden im nächsten Schritt verwendet.
    • Dieses Kennwort kann nicht erneut abgerufen werden. Es empfiehlt sich daher, das Kennwort an einem sicheren Ort zu speichern. Sollten Sie Ihr Kennwort vergessen, können Sie die Anmeldeinformationen für den Dienstprinzipal zurücksetzen.
    • In diesem Artikel wird ein Dienstprinzipal mit der Rolle Mitwirkender verwendet. Weitere Informationen zur rollenbasierten Zugriffssteuerung (Role-Based Access Control, RBAC) finden Sie unter RBAC: Integrierte Rollen.
    • Die Ausgabe der Erstellung des Dienstprinzipals enthält vertrauliche Anmeldeinformationen. Schließen Sie diese Anmeldeinformationen nicht in Ihren Code ein, und checken Sie sie nicht in Ihre Quellcodeverwaltung ein.
    • Weitere Informationen zu den Optionen beim Erstellen eines Dienstprinzipals mithilfe der Azure CLI finden Sie im Artikel Erstellen eines Azure-Dienstprinzipals mit der Azure-Befehlszeilenschnittstelle.

Angeben der Anmeldeinformationen für den Dienstprinzipal in Umgebungsvariablen

Nachdem Sie einen Dienstprinzipal erstellt haben, können Sie seine Anmeldeinformationen über Umgebungsvariablen für Terraform angeben.

  1. Bearbeiten Sie die ~/.bashrc-Datei, indem Sie die folgenden Umgebungsvariablen hinzufügen.

    export ARM_SUBSCRIPTION_ID="<azure_subscription_id>"
export ARM_TENANT_ID="<azure_subscription_tenant_id>"
export ARM_CLIENT_ID="<service_principal_appid>"
export ARM_CLIENT_SECRET="<service_principal_password>"

  2. Führen Sie source ~/.bashrc (oder die abgekürzte Entsprechung . ~/.bashrc) aus, um das Skript ~/.bashrc auszuführen. Sie können Cloud Shell auch beenden und erneut öffnen, damit das Skript automatisch ausgeführt wird.

    . ~/.bashrc

  3. Nachdem Sie die Umgebungsvariablen festgelegt haben, können Sie deren Werte wie folgt überprüfen:

    printenv | grep ^ARM*

Die wichtigsten Punkte:

  • Verwenden Sie wie bei jeder Umgebungsvariablen die folgende Syntax, um innerhalb eines Terraform-Skripts auf einen Azure-Abonnementwert zuzugreifen: ${env.<environment_variable>}. Beispiel: Wenn Sie auf den Wert ARM_SUBSCRIPTION_ID zugreifen möchten, geben Sie ${env.ARM_SUBSCRIPTION_ID} an.
  • Beim Erstellen und Anwenden von Terraform-Ausführungsplänen werden Änderungen an dem Azure-Abonnement vorgenommen, das dem Dienstprinzipal zugeordnet ist. Dies kann manchmal verwirrend sein, wenn Sie bei einem Azure-Abonnement angemeldet sind und die Umgebungsvariablen auf ein zweites Azure-Abonnement verweisen. Betrachten Sie zur Veranschaulichung das folgende Beispiel. Angenommen, Sie verfügen über zwei Azure-Abonnements: SubA und SubB. Wenn das aktuelle Azure-Abonnement SubA ist (über az account show ermittelt), während die Umgebungsvariablen auf SubB verweisen, gelten alle von Terraform vorgenommenen Änderungen für SubB. Daher müssen Sie sich beim Abonnement SubB anmelden, um Azure CLI- oder Azure PowerShell-Befehle auszuführen und Ihre Änderungen anzuzeigen.

Angeben der Anmeldeinformationen für den Dienstprinzipal in einem Terraform-Anbieterblock

Der Azure-Anbieterblock definiert die Syntax, mit der Sie die Authentifizierungsinformationen Ihres Azure-Abonnements angeben können.

terraform {
  required_providers {
    azurerm = {
      source = "hashicorp/azurerm"
      version = "~>2.0"
    }
  }
}

provider "azurerm" {
  features {}

  subscription_id   = "<azure_subscription_id>"
  tenant_id         = "<azure_subscription_tenant_id>"
  client_id         = "<service_principal_appid>"
  client_secret     = "<service_principal_password>"
}

# Your code goes here

Achtung

Die Möglichkeit, Anmeldeinformationen für Ihr Azure-Abonnement in einer Terraform-Konfigurationsdatei anzugeben, kann besonders beim Testen praktisch sein. Sie sollten Anmeldeinformationen jedoch nicht in einer Klartextdatei speichern, die von nicht vertrauenswürdigen Personen angezeigt werden kann.

Implementieren des Terraform-Codes

Hinweis

Der Beispielcode für diesen Artikel befindet sich im Azure Terraform-GitHub-Repository. Sie können die Protokolldatei anzeigen, die die Testergebnisse von aktuellen und früheren Terraform-Versionen enthält.

Betrachten Sie die weiteren Artikel und Beispielcodes zur Verwendung von Terraform zum Verwalten von Azure-Ressourcen.

  1. Erstellen Sie ein Verzeichnis, in dem Sie den Terraform-Beispielcode testen können, und legen Sie es als aktuelles Verzeichnis fest.

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

    terraform {
  required_version = ">=1.0"

  required_providers {
    azapi = {
      source  = "azure/azapi"
      version = "~>1.5"
    }
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "~>3.0"
    }
    random = {
      source  = "hashicorp/random"
      version = "~>3.0"
    }
    time = {
      source  = "hashicorp/time"
      version = "0.9.1"
    }
  }
}

provider "azurerm" {
  features {}
}

  3. Erstellen Sie eine Datei namens ssh.tf, und fügen Sie den folgenden Code ein:

    resource "random_pet" "ssh_key_name" {
  prefix    = "ssh"
  separator = ""
}

resource "azapi_resource_action" "ssh_public_key_gen" {
  type        = "Microsoft.Compute/sshPublicKeys@2022-11-01"
  resource_id = azapi_resource.ssh_public_key.id
  action      = "generateKeyPair"
  method      = "POST"

  response_export_values = ["publicKey", "privateKey"]
}

resource "azapi_resource" "ssh_public_key" {
  type      = "Microsoft.Compute/sshPublicKeys@2022-11-01"
  name      = random_pet.ssh_key_name.id
  location  = azurerm_resource_group.rg.location
  parent_id = azurerm_resource_group.rg.id
}

output "key_data" {
  value = jsondecode(azapi_resource_action.ssh_public_key_gen.output).publicKey
}

  4. Erstellen Sie eine Datei namens main.tf, und fügen Sie den folgenden Code ein:

    # Generate random resource group name
resource "random_pet" "rg_name" {
  prefix = var.resource_group_name_prefix
}

resource "azurerm_resource_group" "rg" {
  location = var.resource_group_location
  name     = random_pet.rg_name.id
}

resource "random_pet" "azurerm_kubernetes_cluster_name" {
  prefix = "cluster"
}

resource "random_pet" "azurerm_kubernetes_cluster_dns_prefix" {
  prefix = "dns"
}

resource "azurerm_kubernetes_cluster" "k8s" {
  location            = azurerm_resource_group.rg.location
  name                = random_pet.azurerm_kubernetes_cluster_name.id
  resource_group_name = azurerm_resource_group.rg.name
  dns_prefix          = random_pet.azurerm_kubernetes_cluster_dns_prefix.id

  identity {
    type = "SystemAssigned"
  }

  default_node_pool {
    name       = "agentpool"
    vm_size    = "Standard_D2_v2"
    node_count = var.node_count
  }
  linux_profile {
    admin_username = var.username

    ssh_key {
      key_data = jsondecode(azapi_resource_action.ssh_public_key_gen.output).publicKey
    }
  }
  network_profile {
    network_plugin    = "kubenet"
    load_balancer_sku = "standard"
  }
}

  5. Erstellen Sie eine Datei namens variables.tf, und fügen Sie den folgenden Code ein:

    variable "resource_group_location" {
  type        = string
  default     = "eastus"
  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 "node_count" {
  type        = number
  description = "The initial quantity of nodes for the node pool."
  default     = 3
}

variable "msi_id" {
  type        = string
  description = "The Managed Service Identity ID. Set this value if you're running this example using Managed Identity as the authentication method."
  default     = null
}

variable "username" {
  type        = string
  description = "The admin username for the new cluster."
  default     = "azureadmin"
}

  6. Erstellen Sie eine Datei namens outputs.tf, und fügen Sie den folgenden Code ein:

    output "resource_group_name" {
  value = azurerm_resource_group.rg.name
}

output "kubernetes_cluster_name" {
  value = azurerm_kubernetes_cluster.k8s.name
}

output "client_certificate" {
  value     = azurerm_kubernetes_cluster.k8s.kube_config[0].client_certificate
  sensitive = true
}

output "client_key" {
  value     = azurerm_kubernetes_cluster.k8s.kube_config[0].client_key
  sensitive = true
}

output "cluster_ca_certificate" {
  value     = azurerm_kubernetes_cluster.k8s.kube_config[0].cluster_ca_certificate
  sensitive = true
}

output "cluster_password" {
  value     = azurerm_kubernetes_cluster.k8s.kube_config[0].password
  sensitive = true
}

output "cluster_username" {
  value     = azurerm_kubernetes_cluster.k8s.kube_config[0].username
  sensitive = true
}

output "host" {
  value     = azurerm_kubernetes_cluster.k8s.kube_config[0].host
  sensitive = true
}

output "kube_config" {
  value     = azurerm_kubernetes_cluster.k8s.kube_config_raw
  sensitive = true
}

Initialisieren von Terraform

Führen Sie zum Initialisieren der Terraform-Bereitstellung terraform init aus. Mit diesem Befehl wird der Azure-Anbieter heruntergeladen, der zum Verwalten Ihrer Azure-Ressourcen erforderlich ist.

terraform init -upgrade

Die wichtigsten Punkte:

  • Der Parameter -upgrade aktualisiert die erforderlichen Anbieter-Plug-Ins auf die neueste Version, die den Versionseinschränkungen der Konfiguration entspricht.

Erstellen eines Terraform-Ausführungsplans

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

terraform plan -out main.tfplan

Die wichtigsten Punkte:

  • Durch den Befehl terraform plan wird ein Ausführungsplan erstellt, aber nicht ausgeführt. Stattdessen werden die Aktionen ermittelt, die erforderlich sind, um die in Ihren Konfigurationsdateien angegebene Konfiguration zu erstellen. Mit diesem Muster können Sie überprüfen, ob der Ausführungsplan Ihren Erwartungen entspricht, bevor Sie Änderungen an den eigentlichen Ressourcen vornehmen.
  • Der optionale Parameter -out ermöglicht die Angabe einer Ausgabedatei für den Plan. Durch die Verwendung des Parameters -out wird sichergestellt, dass genau der von Ihnen überprüfte Plan angewendet wird.

Anwenden eines Terraform-Ausführungsplans

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

terraform apply main.tfplan

Die wichtigsten Punkte:

  • Der Beispielbefehl terraform apply setzt voraus, dass Sie zuvor terraform plan -out main.tfplan ausgeführt haben.
  • Wenn Sie einen anderen Dateinamen für den Parameter -out angegeben haben, verwenden Sie denselben Dateinamen im Aufruf von terraform apply.
  • Wenn Sie den Parameter -out nicht verwendet haben, rufen Sie terraform apply ohne Parameter auf.

Überprüfen der Ergebnisse

  1. Mit dem folgenden Befehl rufen Sie den Namen der Azure-Ressourcengruppe ab.

    resource_group_name=$(terraform output -raw resource_group_name)

  2. Mit dem Befehl az aks list zeigen Sie den Namen Ihres neuen Kubernetes-Clusters an.

    az aks list \
  --resource-group $resource_group_name \
  --query "[].{\"K8s cluster name\":name}" \
  --output table

  3. Mit dem folgenden Befehl rufen Sie die Kubernetes-Konfiguration aus dem Terraform-Status ab und speichern sie in einer Datei, die kubectl lesen kann.

    echo "$(terraform output kube_config)" > ./azurek8s

  4. Vergewissern Sie sich, dass der vorherige Befehl kein ASCII EOT-Zeichen hinzugefügt hat, indem Sie den Befehl „“ verwenden.

    cat ./azurek8s

    Die wichtigsten Punkte:

    • Wenn am Anfang << EOT und am Ende EOT angezeigt wird, entfernen Sie diese Zeichen aus der Datei. Sie erhalten andernfalls unter Umständen die folgende Fehlermeldung: error: error loading config file "./azurek8s": yaml: line 2: mapping values are not allowed in this context

  5. Mit dem folgenden Befehl legen Sie eine Umgebungsvariable fest, damit kubectl die korrekte Konfiguration übernehmen kann.

    export KUBECONFIG=./azurek8s

  6. Überprüfen Sie die Integrität des Clusters mithilfe des Befehls „kubectl get nodes“.

    kubectl get nodes

Die wichtigsten Punkte:

  • Beim Erstellen des AKS-Clusters wurde die Überwachung aktiviert, um Integritätsmetriken für die Clusterknoten und die Pods zu erfassen. Diese Integritätsmetriken sind im Azure-Portal verfügbar. Weitere Informationen zur Überwachung der Integrität von Containern finden Sie unter Überwachen der Integrität von Azure Kubernetes Service.
  • Beim Anwenden des Terraform-Ausführungsplans wurden mehrere Schlüsselwerte als Ausgabe klassifiziert. Beispielsweise werden die Hostadresse, der AKS-Clusterbenutzername und das AKS-Clusterkennwort ausgegeben.

Bereitstellen der Anwendung

Zum Bereitstellen der Anwendung verwenden Sie eine Manifestdatei, um alle Objekte zu erstellen, die für die Ausführung der AKS Store-Anwendungerforderlich 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:

Screenshot: Beispielarchitektur für einen Azure-Store

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

Hinweis

Zustandsbehaftete Container wie Rabbit MQ sollten nicht ohne permanenten Speicher für die Produktion ausgeführt werden. Sie werden hier der Einfachheit halber verwendet, jedoch sollten verwaltete Dienste wie Azure CosmosDB oder Azure Service Bus verwendet werden.

  1. Erstellen Sie eine Datei namens aks-store-quickstart.yaml, und fügen Sie das folgende Manifest ein:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: rabbitmq
spec:
  replicas: 1
  selector:
    matchLabels:
      app: rabbitmq
  template:
    metadata:
      labels:
        app: rabbitmq
    spec:
      nodeSelector:
        "kubernetes.io/os": linux
      containers:
      - name: rabbitmq
        image: mcr.microsoft.com/mirror/docker/library/rabbitmq:3.10-management-alpine
        ports:
        - containerPort: 5672
          name: rabbitmq-amqp
        - containerPort: 15672
          name: rabbitmq-http
        env:
        - name: RABBITMQ_DEFAULT_USER
          value: "username"
        - name: RABBITMQ_DEFAULT_PASS
          value: "password"
        resources:
          requests:
            cpu: 10m
            memory: 128Mi
          limits:
            cpu: 250m
            memory: 256Mi
        volumeMounts:
        - name: rabbitmq-enabled-plugins
          mountPath: /etc/rabbitmq/enabled_plugins
          subPath: enabled_plugins
      volumes:
      - name: rabbitmq-enabled-plugins
        configMap:
          name: rabbitmq-enabled-plugins
          items:
          - key: rabbitmq_enabled_plugins
            path: enabled_plugins
---
apiVersion: v1
data:
  rabbitmq_enabled_plugins: |
    [rabbitmq_management,rabbitmq_prometheus,rabbitmq_amqp1_0].
kind: ConfigMap
metadata:
  name: rabbitmq-enabled-plugins            
---
apiVersion: v1
kind: Service
metadata:
  name: rabbitmq
spec:
  selector:
    app: rabbitmq
  ports:
    - name: rabbitmq-amqp
      port: 5672
      targetPort: 5672
    - name: rabbitmq-http
      port: 15672
      targetPort: 15672
  type: ClusterIP
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: order-service
spec:
  replicas: 1
  selector:
    matchLabels:
      app: order-service
  template:
    metadata:
      labels:
        app: order-service
    spec:
      nodeSelector:
        "kubernetes.io/os": linux
      containers:
      - name: order-service
        image: ghcr.io/azure-samples/aks-store-demo/order-service:latest
        ports:
        - containerPort: 3000
        env:
        - name: ORDER_QUEUE_HOSTNAME
          value: "rabbitmq"
        - name: ORDER_QUEUE_PORT
          value: "5672"
        - name: ORDER_QUEUE_USERNAME
          value: "username"
        - name: ORDER_QUEUE_PASSWORD
          value: "password"
        - name: ORDER_QUEUE_NAME
          value: "orders"
        - name: FASTIFY_ADDRESS
          value: "0.0.0.0"
        resources:
          requests:
            cpu: 1m
            memory: 50Mi
          limits:
            cpu: 75m
            memory: 128Mi
      initContainers:
      - name: wait-for-rabbitmq
        image: busybox
        command: ['sh', '-c', 'until nc -zv rabbitmq 5672; do echo waiting for rabbitmq; sleep 2; done;']
        resources:
          requests:
            cpu: 1m
            memory: 50Mi
          limits:
            cpu: 75m
            memory: 128Mi    
---
apiVersion: v1
kind: Service
metadata:
  name: order-service
spec:
  type: ClusterIP
  ports:
  - name: http
    port: 3000
    targetPort: 3000
  selector:
    app: order-service
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: product-service
spec:
  replicas: 1
  selector:
    matchLabels:
      app: product-service
  template:
    metadata:
      labels:
        app: product-service
    spec:
      nodeSelector:
        "kubernetes.io/os": linux
      containers:
      - name: product-service
        image: ghcr.io/azure-samples/aks-store-demo/product-service:latest
        ports:
        - containerPort: 3002
        resources:
          requests:
            cpu: 1m
            memory: 1Mi
          limits:
            cpu: 1m
            memory: 7Mi
---
apiVersion: v1
kind: Service
metadata:
  name: product-service
spec:
  type: ClusterIP
  ports:
  - name: http
    port: 3002
    targetPort: 3002
  selector:
    app: product-service
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: store-front
spec:
  replicas: 1
  selector:
    matchLabels:
      app: store-front
  template:
    metadata:
      labels:
        app: store-front
    spec:
      nodeSelector:
        "kubernetes.io/os": linux
      containers:
      - name: store-front
        image: ghcr.io/azure-samples/aks-store-demo/store-front:latest
        ports:
        - containerPort: 8080
          name: store-front
        env: 
        - name: VUE_APP_ORDER_SERVICE_URL
          value: "http://order-service:3000/"
        - name: VUE_APP_PRODUCT_SERVICE_URL
          value: "http://product-service:3002/"
        resources:
          requests:
            cpu: 1m
            memory: 200Mi
          limits:
            cpu: 1000m
            memory: 512Mi
---
apiVersion: v1
kind: Service
metadata:
  name: store-front
spec:
  ports:
  - port: 80
    targetPort: 8080
  selector:
    app: store-front
  type: LoadBalancer

    Eine Aufschlüsselung der YAML-Manifestdateien finden Sie unter Bereitstellungen und YAML-Manifeste.

    Wenn Sie die YAML-Datei lokal erstellen und speichern, können Sie die Manifestdatei in Ihr Standardverzeichnis in CloudShell hochladen, indem Sie die Schaltfläche Dateien hochladen/herunterladen auswählen und die Datei aus Ihrem lokalen Dateisystem auswählen.

  2. Stellen Sie die Anwendung über den Befehl „kubectl apply“ bereit, und geben Sie den Namen Ihres YAML-Manifests an.

    kubectl apply -f aks-store-quickstart.yaml

    Die folgende Beispielausgabe zeigt die Bereitstellungen und Dienste:

    deployment.apps/rabbitmq 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

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. Überprüfen Sie den Status der bereitgestellten Pods mithilfe des Befehls kubectl get pods. Stellen Sie sicher, dass alle Pods den Status Running haben, bevor Sie fortfahren.

    kubectl get pods

  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 service store-front --watch

    Die Ausgabe von EXTERNAL-IP für den store-front-Dienst lautet anfangs pending (ausstehend):

    NAME          TYPE           CLUSTER-IP    EXTERNAL-IP   PORT(S)        AGE
store-front   LoadBalancer   10.0.100.10   <pending>     80:30025/TCP   4h4m

  3. Nachdem die externe IP-Adresse (EXTERNAL-IP) von ausstehend in eine tatsächliche öffentliche IP-Adresse geändert wurde, verwenden Sie CTRL-C, um die kubectl-Überwachung zu beenden.

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

    NAME          TYPE           CLUSTER-IP    EXTERNAL-IP    PORT(S)        AGE
store-front   LoadBalancer   10.0.100.10   20.62.159.19   80:30025/TCP   4h5m

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

    Screenshot der AKS Store-Beispielanwendung

Bereinigen von Ressourcen

Löschen von AKS-Ressourcen

Wenn Sie die über Terraform erstellten Ressourcen nicht mehr benötigen, führen Sie die folgenden Schritte aus:

  1. Führen Sie terraform plan aus, und geben Sie das Flag destroy an.

    terraform plan -destroy -out main.destroy.tfplan

    Die wichtigsten Punkte:

    • Durch den Befehl terraform plan wird ein Ausführungsplan erstellt, aber nicht ausgeführt. Stattdessen werden die Aktionen ermittelt, die erforderlich sind, um die in Ihren Konfigurationsdateien angegebene Konfiguration zu erstellen. Mit diesem Muster können Sie überprüfen, ob der Ausführungsplan Ihren Erwartungen entspricht, bevor Sie Änderungen an den eigentlichen Ressourcen vornehmen.
    • Der optionale Parameter -out ermöglicht die Angabe einer Ausgabedatei für den Plan. Durch die Verwendung des Parameters -out wird sichergestellt, dass genau der von Ihnen überprüfte Plan angewendet wird.

  2. Führen Sie zum Anwenden des Ausführungsplans den Befehl terraform apply aus.

    terraform apply main.destroy.tfplan

Löschen eines Dienstprinzipals

  1. Mit dem folgenden Befehl rufen Sie die Dienstprinzipal-ID ab.

    sp=$(terraform output -raw sp)

  2. Löschen Sie den Dienstprinzipal mithilfe des Befehls az ad sp delete.

    az ad sp delete --id $sp

Klonen der Azure Developer CLI-Vorlage

Mit der Azure Developer CLI können Sie schnell Beispiele aus dem Repository Azure-Samples herunterladen. In unserer Schnellstartanleitung laden Sie die Anwendung aks-store-demo herunter. Weitere Informationen zu diesen Optionen finden Sie in der Übersicht zu azd.

  1. Klonen Sie die Demovorlage für einen AKS-Store aus dem Azure-Samples-Repository, indem Sie den Befehl azd init mit dem Parameter --template ausführen.

    azd init --template Azure-Samples/aks-store-demo

  2. Geben Sie einen Umgebungsnamen für Ihr Projekt ein, der nur alphanumerische Zeichen und Bindestriche enthält, z. B. aks-terraform-1.

    Enter a new environment name: aks-terraform-1

Anmelden beim Azure-Cloudkonto

Die azd-Vorlage enthält den gesamten Code, der zum Erstellen der Dienste erforderlich ist. Sie müssen sich jedoch bei Ihrem Azure-Konto anmelden, um die Anwendung in AKS zu hosten.

  1. Melden Sie sich mithilfe des Befehls azd auth login bei Ihrem Konto an.

    azd auth login

  2. Kopieren Sie den Gerätecode, der in der Ausgabe angezeigt wird, und drücken Sie die EINGABETASTE, um sich anzumelden.

    Start by copying the next code: XXXXXXXXX
Then press enter and continue to log in from your browser...

    Wichtig

    Wenn Sie eine VM außerhalb des Netzwerks oder GitHub Codespace verwenden, verursachen bestimmte Azure-Sicherheitsrichtlinien Konflikte bei der Anmeldung über azd auth login. Wenn Sie hierbei Probleme haben, können Sie die erläuterte Problemumgehung mit „azd auth“ und einer curl-Anforderung an die Localhost-URL verwenden, zu der Sie nach dem Ausführen von azd auth login weitergeleitet wurden.

  3. Authentifizieren Sie sich mit Ihren Anmeldeinformationen auf der Anmeldeseite Ihrer Organisation.

  4. Bestätigen Sie, dass Sie die Person sind, die versucht, eine Verbindung mit der Azure CLI herzustellen.

  5. Vergewissern Sie sich, dass die Meldung „Gerätecodeauthentifizierung abgeschlossen. Bei Azure angemeldet.“ im ursprünglichen Terminal angezeigt wird.

    Waiting for you to complete authentication in the browser...
Device code authentication completed.
Logged in to Azure.

Problemumgehung mit „azd auth“

Für diese Problemumgehung müssen Sie die Azure CLI installiert haben.

  1. Öffnen Sie ein Terminalfenster, und melden Sie sich über die Azure CLI mit dem Befehl az login an. Legen Sie dabei den Parameter --scope auf https://graph.microsoft.com/.default fest.

    az login --scope https://graph.microsoft.com/.default

    Sie sollten auf eine Authentifizierungsseite auf einer neuen Registerkarte umgeleitet werden, um ein Browserzugriffstoken zu erstellen, wie im folgenden Beispiel zu sehen:

    https://login.microsoftonline.com/organizations/oauth2/v2.0/authorize?clientid=<your_client_id>.

  2. Kopieren Sie die Localhost-URL der Webseite, die Sie erhalten haben, nachdem Sie versucht haben, sich mit azd auth login anzumelden.

  3. Verwenden Sie in einem neuen Terminalfenster die folgende curl-Anforderung, um sich anzumelden. Stellen Sie sicher, dass Sie den Platzhalter <localhost> durch die Localhost-URL ersetzen, die Sie im vorherigen Schritt kopiert haben.

    curl <localhost>

    Bei einer erfolgreichen Anmeldung wird eine HTML-Webseite ausgegeben, wie im folgenden Beispiel zu sehen:

    <!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8" />
    <meta http-equiv="refresh" content="60;url=https://docs.microsoft.com/cli/azure/">
    <title>Login successfully</title>
    <style>
        body {
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
        }

        code {
            font-family: Consolas, 'Liberation Mono', Menlo, Courier, monospace;
            display: inline-block;
            background-color: rgb(242, 242, 242);
            padding: 12px 16px;
            margin: 8px 0px;
        }
    </style>
</head>
<body>
    <h3>You have logged into Microsoft Azure!</h3>
    <p>You can close this window, or we will redirect you to the <a href="https://docs.microsoft.com/cli/azure/">Azure CLI documentation</a> in 1 minute.</p>
    <h3>Announcements</h3>
    <p>[Windows only] Azure CLI is collecting feedback on using the <a href="https://learn.microsoft.com/windows/uwp/security/web-account-manager">Web Account Manager</a> (WAM) broker for the login experience.</p>
    <p>You may opt-in to use WAM by running the following commands:</p>
    <code>
        az config set core.allow_broker=true<br>
        az account clear<br>
        az login
    </code>
</body>
</html>

  4. Schließen Sie das aktuelle Terminal, und öffnen Sie das ursprüngliche. Ihnen sollte nun eine JSON-Liste mit Ihren Abonnements angezeigt werden.

  5. Kopieren Sie das id-Feld des Abonnements, das Sie verwenden möchten.

  6. Legen Sie Ihr Abonnement mithilfe des Befehls az account set fest.

    az account set --subscription <subscription_id>

Erstellen und Bereitstellen von Ressourcen für Ihren Cluster

Zum Bereitstellen der Anwendung verwenden Sie den Befehl azd up, um alle Objekte zu erstellen, die für die Ausführung der AKS Store-Anwendung erforderlich sind.

  • Eine Datei vom Typ azure.yaml definiert den gewünschten Zustand eines Clusters, z. B. die abzurufenden Containerimages, und enthält die folgenden Kubernetes-Bereitstellungen und -Dienste:

Diagramm, das die Azure-Store-Beispielarchitektur zeigt

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

Hinweis

Zustandsbehaftete Container wie Rabbit MQ sollten nicht ohne permanenten Speicher für die Produktion ausgeführt werden. Sie werden hier der Einfachheit halber verwendet, jedoch sollten verwaltete Dienste wie Azure Cosmos DB oder Azure Service Bus verwendet werden.

Bereitstellen von Anwendungsressourcen

Mit der azd-Vorlage für diese Schnellstartanleitung wird eine neue Ressourcengruppe mit einem AKS-Cluster und einer Azure Key Vault-Instanz erstellt. Die Key Vault-Instanz speichert geheime Clientschlüssel und führt die Dienste im Namespace pets aus.

  1. Erstellen Sie mit dem Befehl azd up alle Anwendungsressourcen.

    azd up

    azd up führt alle Hooks im azd-hooks-Ordner aus, um die Anwendungsdienste vorab zu registrieren und bereitzustellen.

    Passen Sie Hooks an, um benutzerdefinierten Code in den azd-Workflowphasen hinzuzufügen. Weitere Informationen finden Sie in der Referenz zu azd-Hooks.

  2. Wählen Sie ein Azure-Abonnement für die Abrechnung aus.

    ? Select an Azure Subscription to use:  [Use arrows to move, type to filter]
> 1. My Azure Subscription (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx)

  3. Wählen Sie eine Region aus, in der Ihre Anwendung bereitgestellt werden soll.

    Select an Azure location to use:  [Use arrows to move, type to filter]
  1.  (South America) Brazil Southeast (brazilsoutheast)
  2.  (US) Central US (centralus)
  3.  (US) East US (eastus)
> 43. (US) East US 2 (eastus2)
  4.  (US) East US STG (eastusstg)
  5.  (US) North Central US (northcentralus)
  6.  (US) South Central US (southcentralus)

    azd führt automatisch die Hooks vor und nach der Bereitstellung aus, um die Ressourcen für Ihre Anwendung zu erstellen. Dieser Vorgang kann einige Minuten dauern. Anschließend sollte eine Ausgabe ähnlich der folgenden Beispielausgabe angezeigt werden:

    SUCCESS: Your workflow to provision and deploy to Azure completed in 9 minutes 40 seconds.

Generieren von Terraform-Plänen

In Ihrer Azure-Entwicklervorlage enthält der Ordner /infra/terraform den gesamten Code, der zum Generieren des Terraform-Plans verwendet wird.

Terraform stellt Befehle bereit und führt sie aus, die terraform apply als Teil des azd-Bereitstellungsschritts verwenden. Anschließend sollte eine Ausgabe ähnlich der folgenden Beispielausgabe angezeigt werden:

Plan: 5 to add, 0 to change, 0 to destroy.
...
Saved the plan to: /workspaces/aks-store-demo/.azure/aks-terraform-azd/infra/terraform/main.tfplan

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. Verwenden Sie den Befehl kubectl set-context, um Ihren Namespace auf den Demonamespace pets festzulegen.

    kubectl config set-context --current --namespace=pets

  2. Überprüfen Sie den Status der bereitgestellten Pods mithilfe des Befehls kubectl get pods. Stellen Sie sicher, dass alle Pods den Status Running haben, bevor Sie fortfahren.

    kubectl get pods

  3. Suchen Sie nach einer öffentlichen IP-Adresse für die Storefront-Anwendung, und überwachen Sie den Fortschritt mithilfe des Befehls kubectl get service mit dem Argument --watch.

    kubectl get service store-front --watch

    Die Ausgabe von EXTERNAL-IP für den store-front-Dienst lautet anfangs pending (ausstehend):

    NAME          TYPE           CLUSTER-IP    EXTERNAL-IP   PORT(S)        AGE
store-front   LoadBalancer   10.0.100.10   <pending>     80:30025/TCP   4h4m

  4. Nachdem die externe IP-Adresse (EXTERNAL-IP) von ausstehend in eine tatsächliche öffentliche IP-Adresse geändert wurde, verwenden Sie CTRL-C, um die kubectl-Überwachung zu beenden.

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

    NAME          TYPE           CLUSTER-IP    EXTERNAL-IP    PORT(S)        AGE
store-front   LoadBalancer   10.0.100.10   20.62.159.19   80:30025/TCP   4h5m

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

    Screenshot der AKS Store-Beispielanwendung

Löschen des Clusters

Bereinigen Sie nach Abschluss der Schnellstartanleitung die nicht benötigten Ressourcen, um Azure-Gebühren zu vermeiden.

  1. Löschen Sie alle in der Schnellstartanleitung erstellten Ressourcen mit dem Befehl azd down.

    azd down

  2. Bestätigen Sie Ihre Entscheidung, alle verwendeten Ressourcen aus Ihrem Abonnement zu entfernen, indem Sie y eingeben und die Enter-TASTE drücken.

    ? Total resources to delete: 14, are you sure you want to continue? (y/N)

  3. Erlauben Sie bei der Bereinigung, dass die Variablen aus dieser Schnellstartanleitung ggf. wiederverwendet werden, indem Sie y eingeben und dann die Enter-TASTE drücken.

    [Warning]: These resources have soft delete enabled allowing them to be recovered for a period or time after deletion. During this period, their names can't be reused. In the future, you can use the argument --purge to skip this confirmation.

Problembehandlung für Terraform in Azure

Behandeln Sie allgemeine Probleme bei der Verwendung von Terraform in Azure.

Nächste Schritte

In dieser Schnellstartanleitung haben Sie einen Kubernetes-Cluster und eine Beispielanwendung mit mehreren Containern 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 Azure Kubernetes Service (AKS) sowie ein vollständiges Beispiel vom Code bis zur Bereitstellung finden Sie im Tutorial zu Kubernetes-Clustern.

Weitere Informationen zur Verwendung von AKS.