Erstellen und Bereitstellen einer Multicontainer-App zum Azure Kubernetes Service

Verwenden Sie Azure Pipelines, um eine Multicontainer-App kontinuierlich zu erstellen und im Azure Kubernetes Service (AKS) bereitzustellen. In diesem Lernprogramm stellen Sie die Tailspin Space Game-Web-App und die Bestenlisten-API als separate Container bereit, übertragen beide Images an Azure Container Registry (ACR) und stellen sie mithilfe von Kubernetes-Manifesten in AKS bereit.

Voraussetzungen

Produkt	Anforderungen
Azure DevOps	– Eine Azure DevOps-Organisation und ein Projekt. Erstellen Sie ein kostenloses Konto. - Berechtigungen: – Um Zugriff auf alle Pipelines im Projekt zu gewähren: Sie müssen Mitglied der Gruppe "Projektadministratoren" sein. – Um Dienstverbindungen zu erstellen: Sie müssen über die Rolle "Administrator " oder " Ersteller " für Dienstverbindungen verfügen. – Eine Möglichkeit zum Ausführen von Pipelines auf von Microsoft gehosteten Agenten. Sie können entweder einen parallelen Auftrag erwerben oder ein kostenloses Kontingent anfordern.
GitHub	- Ein GitHub-Konto .
Azure	– Ein Azure-Abonnement.

Code abrufen

"Forken Sie das folgende Repository in Ihr GitHub-Konto:"

https://github.com/MicrosoftDocs/mslearn-tailspin-spacegame-web-kubernetes

Erstellen der Azure-Ressourcen

Verwenden Sie Azure Cloud Shell, um Ihren Azure Kubernetes Service Cluster und Azure Container Registry zu erstellen.

Melden Sie sich beim Portal Azure an, öffnen Sie dann Cloud Shell, und wählen Sie Bash aus.

Festlegen wiederverwendbarer Variablen:

resourceSuffix=$RANDOM
registryName="tailspinspacegame${resourceSuffix}"
aksName="tailspinspacegame-${resourceSuffix}"
rgName='tailspin-space-game-rg'

(Optional) Festlegen eines Standardbereichs:

az account list-locations \
  --query "[].{Name: name, DisplayName: displayName}" \
  --output table

az configure --defaults location=westus2

Erstellen Sie die Ressourcengruppe, das ACR und den AKS-Cluster.

az group create --name $rgName

az acr create \
  --name $registryName \
  --resource-group $rgName \
  --sku Standard

az aks create \
  --name $aksName \
  --resource-group $rgName \
  --enable-addons monitoring \
  --generate-ssh-keys

Gewähren Sie dem AKS Kubelet Identitätspullzugriff auf ACR. Das Kubelet ist der Knoten-Agent, der auf jedem Kubernetes-Knoten ausgeführt wird und Container-Images abruft, damit Ihre Pods Folgendes starten können:

clientId=$(az aks show \
  --resource-group $rgName \
  --name $aksName \
  --query "identityProfile.kubeletidentity.clientId" \
  --output tsv)

acrId=$(az acr show \
  --name $registryName \
  --resource-group $rgName \
  --query "id" \
  --output tsv)

az role assignment create \
  --assignee $clientId \
  --role AcrPull \
  --scope $acrId

Rufen Sie ihren ACR-Anmeldeserver ab, kopieren Sie den Wert, und behalten Sie ihn für den nächsten Abschnitt bei, in dem Sie die RegistryName Variable in der Pipelinevariablengruppe festlegen:
```
az acr list \
  --resource-group $rgName \
  --query "[].{loginServer: loginServer}" \
  --output table
```

Einrichten der Authentifizierung in Azure DevOps

Bevor Sie die Pipeline erstellen, richten Sie die Authentifizierung und freigegebenen Variablen ein, die Azure Pipelines für den Zugriff auf Ihre Azure Ressourcen und die Containerregistrierung verwendet.

Wechseln Sie in Ihrem Azure DevOps Projekt zu Pipelines>Library.
Erstellen Sie eine Variablegruppe mit dem Namen "Release".
Fügen Sie eine Variable mit dem Namen RegistryName hinzu, und legen Sie den Wert auf Ihren ACR-Anmeldeserver fest (z. B tailspinspacegame4692.azurecr.io. ).
Erstellen Sie diese Dienstverbindungen:
- Azure Resource Manager-Dienstverbindung für das Abonnement und die Ressourcengruppe.
- Docker Registry Service-Verbindung für die ACR-Instanz.

Erstellen der Pipeline

In diesem Abschnitt erstellen Sie eine mehrstufige Azure Pipelines Definition, die zwei Containerimages erstellt, Kubernetes-Manifeste veröffentlicht und beide Dienste in Ihrem Azure Kubernetes Service Cluster bereitstellt.

Stellen Sie vor dem Einfügen des YAML sicher, dass diese Elemente bereits in Ihrem Projekt vorhanden sind:

Eine Variablegruppe mit dem Namen Release, wobei RegistryName auf Ihren Azure Container Registry Anmeldeserver festgelegt ist.
Eine Docker-Registrierungsdienstverbindung mit dem Namen Container Registry Connection.
Eine Azure Resource Manager Dienstverbindung mit dem Namen Kubernetes Cluster Connection.

Melden Sie sich bei Ihrer Azure DevOps-Organisation an, und navigieren Sie dann zu Ihrem Projekt.
Wählen Sie "Pipelines" und dann "Bearbeiten" aus.

Fügen Sie den folgenden Codeausschnitt in Ihre YAML-Datei ein, und ersetzen Sie Platzhalterwerte durch die entsprechenden Werte für Ihre Umgebung:

trigger:
- 'main'

variables:
  buildConfiguration: 'Release'
  leaderboardRepository: 'leaderboard'
  webRepository: 'web'
  tag: '$(Build.BuildId)'
  imagePullSecret: 'secret'

stages:
- stage: Build
  displayName: Build the containers
  jobs:
  - job: Build
    pool:
      vmImage: 'ubuntu-latest'
    steps:
    - task: Docker@2
      displayName: Build and push the web image to container registry
      inputs:
        command: buildAndPush
        buildContext: $(Build.Repository.LocalPath)
        repository: $(webRepository)
        dockerfile: '$(Build.SourcesDirectory)/Tailspin.SpaceGame.Web/Dockerfile'
        containerRegistry: 'Container Registry Connection'
        tags: |
          $(tag)

    - task: Docker@2
      displayName: Build and push the leaderboard image to container registry
      inputs:
        command: buildAndPush
        buildContext: $(Build.Repository.LocalPath)
        repository: $(leaderboardRepository)
        dockerfile: '$(Build.SourcesDirectory)/Tailspin.SpaceGame.LeaderboardContainer/Dockerfile'
        containerRegistry: 'Container Registry Connection'
        tags: |
          $(tag)

    - publish: '$(Build.SourcesDirectory)/manifests'
      artifact: manifests

- stage: Deploy
  displayName: Deploy the containers
  dependsOn: Build
  jobs:
  - deployment: Deploy
    displayName: Deploy
    pool:
      vmImage: 'ubuntu-latest'
    environment: 'spike.default'
    variables:
    - group: Release
    strategy:
      runOnce:
        deploy:
          steps:
          - download: current
            artifact: manifests

          - task: KubernetesManifest@1
            displayName: Create imagePullSecret
            inputs:
              action: createSecret
              connectionType: azureResourceManager
              secretName: $(imagePullSecret)
              dockerRegistryEndpoint: 'Container Registry Connection'
              azureSubscriptionConnection: 'Kubernetes Cluster Connection'
              azureResourceGroup: 'tailspin-space-game-rg'
              kubernetesCluster: 'tailspinspacegame-24591'
              namespace: 'default'

          - task: KubernetesManifest@1
            displayName: Deploy to Kubernetes cluster
            inputs:
              action: deploy
              connectionType: azureResourceManager
              azureSubscriptionConnection: 'Kubernetes Cluster Connection'
              azureResourceGroup: 'tailspin-space-game-rg'
              kubernetesCluster: 'tailspinspacegame-24591'
              namespace: 'default'
              manifests: |
                $(Pipeline.Workspace)/manifests/deployment.yml
                $(Pipeline.Workspace)/manifests/service.yml
              imagePullSecrets: |
                $(imagePullSecret)
              containers: |
                $(RegistryName)/$(webRepository):$(tag)
                $(RegistryName)/$(leaderboardRepository):$(tag)

Tipp

YAML ist leerzeichenempfindlich. Achten Sie darauf, den Einzug gleichmäßig zu halten.

Funktionsweise der Pipeline

Diese Pipeline verwendet ein standardmäßiges Build-then-Deploy-Muster über zwei Phasen hinweg.

Erstellungsphase:
Die beiden Docker@2-Aufgaben erstellen und übertragen die web und leaderboard Images an Azure Container Registry.
Bildtags verwenden $(Build.BuildId) , sodass jede Ausführung eine nachverfolgbare, eindeutige Version erzeugt.
Der Ordner manifests wird als Pipelineartefakt veröffentlicht, sodass die Bereitstellungsphase dieselben Manifeste auf einem anderen Agent nutzen kann.
Bereitstellungsphase:
Der Bereitstellungsauftrag zielt auf die konfigurierte Azure DevOps Umgebung ab, wodurch Sie den Bereitstellungsverlauf und die Sichtbarkeit auf Umgebungsebene erhalten.
Im Schritt download wird das manifests-Artefakt aus der aktuellen Ausführung abgerufen.
KubernetesManifest@1 mit createSecret erstellt einen Image-Pullschlüssel im Zielnamespace, damit Clusterknoten sich bei Azure Container Registry authentifizieren können.
KubernetesManifest@1 zusammen mit deploy wendet die Kubernetes-Manifeste an und injiziert die web und leaderboard Bildreferenzen für den aktuellen Build-Tag.

Ausführen und Validieren der Bereitstellung

Verwenden Sie diesen Abschnitt, um zu überprüfen, ob Der Build abgeschlossen ist, die Bereitstellung erfolgreich war, und beide Anwendungsendpunkte können von außerhalb des Clusters erreicht werden.

Öffnen Sie in Azure DevOps die Pipelineausführung, und bestätigen Sie, dass beide Phasen erfolgreich abgeschlossen wurden:
- BuildStufe: Bestätigt, dass beide Bilder erstellt und an Azure Container Registry verschoben wurden.
- Deploy Phase: Bestätigt, dass Manifeste angewendet wurden und Pods in Ihrem Azure Kubernetes Service Cluster aktualisiert wurden.
Öffnen Sie in Azure Portal Ihren Azure Kubernetes Service Cluster, und wählen Sie dann Services und ingresses aus.
Finden Sie die web und leaderboard Dienste, und warten Sie, bis jeder Dienst über eine externe IP verfügt.
Öffnen Sie die externe IP für den web Dienst in Ihrem Browser.
Kopieren Sie die externe IP für den leaderboard Dienst, und öffnen Sie dann den folgenden Endpunkt in Ihrem Browser:
```
http://<external-ip>/api/Leaderboard?pageSize=10
```
Überprüfungsergebnisse bestätigen:
- Die Space Game-Webseite wird vom web Dienstendpunkt geladen.
- Der Leaderboard-Endpunkt gibt JSON-Daten aus der leaderboard API zurück.

Bereinigen von Ressourcen

Nachdem Sie dieses Lernprogramm abgeschlossen haben, löschen Sie die Ressourcengruppe, um zusätzliche Gebühren zu vermeiden. Führen Sie den folgenden Befehl aus, um die Ressourcengruppe und alle darin aufgeführten Ressourcen zu entfernen.

az group delete --name tailspin-space-game-rg

Feedback

War diese Seite hilfreich?

Last updated on 2026-04-28