Übung – Bereitstellen einer Multicontainerlösung auf einem Kubernetes-Cluster

15 Minuten

Die mit Ihrem Projekt bereitgestellte Releasepipeline soll die Lösung als Docker-Container erstellen und in Azure App Service bereitstellen. Um die Bereitstellung mehrerer Container in einem Kubernetes-Cluster zu unterstützen, müssen Sie diese Pipeline ändern.

In dieser Lerneinheit lernen Sie Folgendes:

Aktualisieren Sie die Pipeline so, dass sie bei einem Commit im Branch „main“ ausgelöst wird.
Definieren Sie Variablen, die für die gesamte Pipeline freigegeben werden sollen.
Erstellen und Veröffentlichen von Docker-Images
Veröffentlichen Sie Kubernetes-Manifeste.
Fügen Sie eine Aufgabe hinzu, um einen Image-Pullschlüssel für die Verwendung zwischen Ihren Kubernetes- und Containerregistrierungsinstanzen zu erstellen.
Stellen Sie aktualisierte Images in einem Kubernetes-Cluster bereit.

Aktualisieren der Pipeline zur Unterstützung von Triggern

Melden Sie sich bei Ihrer Azure DevOps-Organisation an, und navigieren Sie dann zu Ihrem Projekt.
Wählen Sie "Pipelines" und dann Ihre Pipeline aus.
Wählen Sie "Bearbeiten" aus, um Ihre azure-pipelines.yml zu bearbeiten.

Andy: Dies war die Buildphase, die wir für die vorherige Einzelcontainerlösung eingerichtet hatten. Ich wusste, dass es nicht ordnungsgemäß ausgeführt werden würde, also habe ich es deaktiviert. Wir können beginnen, indem wir Trigger bei Commits im Branch main reaktivieren.
Ersetzen Sie die vorhandene trigger Zeile oben in der Datei durch den folgenden Codeausschnitt. Dadurch wird jedes Mal eine Pipelineausführung ausgelöst, wenn ein Commit im Mainbranch erfolgt.
```
trigger:
- 'main'
```

Definieren von Variablen, auf die über die Pipeline zugegriffen werden kann

Andy: Wir müssen zwei Pipelinevariablen hinzufügen. Eine zur Angabe des Namens des Leaderboard-Verzeichnisses, das leaderboard ist. Die andere für den Namen des Pullgeheimnisses des Images, das für die Freigabe zwischen AKS- und ACR-Instanzen während der Bereitstellung verwendet wird.

Fügen Sie dem variables Abschnitt den folgenden hervorgehobenen Code hinzu.

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

Erstellen und Veröffentlichen eines Docker-Images in der Azure-Containerregistrierung

Andy: Wir haben bereits eine Aufgabe zum Erstellen der Web-App als Docker-Container, die wir in unserer Containerregistrierung veröffentlichen. Das Gleiche können wir mit einem zweiten Task für unser Leaderboard tun.

Fügen Sie eine zweite Docker@2 Aufgabe hinzu, um den Bestenlistencontainer mithilfe des folgenden hervorgehobenen Codeausschnitts zu erstellen und zu veröffentlichen. Fügen Sie diese Aufgabe direkt hinter der Webcontaineraufgabe hinzu.

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

Tipp

Achten Sie darauf, dass der Task, den Sie hier hinzufügen, die gleiche Einrückung verwendet wie der vorherige Task, da Leerzeichen in einer YAML-Datei wichtig sind.

Veröffentlichen der Kubernetes-Manifeste

Andy: Ich glaube, wir können auf die nächste Stufe gehen. Sehen Sie etwas, das fehlt?

Mara: Sie haben erwähnt, dass es im Quellprojekt einige Manifestdateien gab, die die Bereitstellung definieren, und Dienste Kubernetes, die bei der Bereitstellung benötigt werden. Wir sollten diese veröffentlichen, bevor wir diese Phase abgeschlossen haben.

Andy: Müssen wir? Befinden sie sich nicht noch auf dem lokalen Datenträger?

Mara: Dies wäre, wenn wir die Bereitstellungsaufgaben innerhalb derselben Phase wie der Build hinzufügen würden. Da unsere Bereitstellungsaufgaben jedoch in einer eigenen Bereitstellungsphase ausgeführt werden, erfolgt die Ausführung in einer neuen Umgebung, möglicherweise sogar auf einem anderen Agenten. Wir sollten sicherstellen, dass alles veröffentlicht wird, was diese Stufe produziert und die andere Stufe benötigt.

Andy: Das ist ein großer Punkt. Ist es einfach zu tun? Wir müssen lediglich sicherstellen, dass der Manifestordner in den neuen Agent kopiert wird.

Mara: Dafür ist der Task PublishBuildArtifacts@1 vorgesehen. Es ist so üblich, dass es sogar eine Kurzform dafür gibt. publish

Fügen Sie eine publish Aufgabe hinzu, die den Manifestordner für eine zukünftige Phase speichert, wie im folgenden Codeausschnitt gezeigt. Achten Sie darauf, dass die Einrückung dieses Tasks mit derjenigen des vorherigen Tasks übereinstimmt.

- 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

Ersetzen der Bereitstellungsphase

Mara: Ich werde unsere vorhandene Bereitstellungsphase durch eine Phase ersetzen, die einen Bereitstellungsauftrag verwendet. Ein Bereitstellungsauftrag ist eine besondere Art von Auftrag, mit dem wir unsere Bereitstellung mit der zuvor erstellten Azure DevOps-Umgebung verknüpfen können. Dies erleichtert das Nachverfolgen des Bereitstellungsverlaufs, was besonders nützlich ist, da unsere Lösungen komplexer werden.

Entfernen Sie die vorhandene Bereitstellungsphase (alles nach der Buildphase), und ersetzen Sie sie durch den folgenden Codeausschnitt. Notieren Sie sich die hervorgehobene Zeile, die die zu verwendende Bereitstellungsumgebung angibt.
```
- stage: 'Deploy'
  displayName: 'Deploy the containers'
  dependsOn: Build
  jobs:
  - deployment: Deploy
    displayName: Deploy
    pool:
      vmImage: 'ubuntu-20.04'
    environment: 'Dev'
    variables:
    - group: Release
    strategy:
      runOnce:
        deploy:
          steps:
```
Mara: Der erste Schritt, den wir in der Bereitstellungsphase hinzufügen, besteht darin, die zuvor veröffentlichten Manifestartefakte mithilfe der DownloadBuildArtifacts@0 Aufgabe herunterzuladen.

Andy: Lassen Sie mich erraten, gibt es eine download Kurzform für diese Aufgabe?

Mara: Genau richtig! Wir können den current Bezeichner verwenden, um anzugeben, dass das Artefakt aus der aktuellen Ausführung der Pipeline stammen soll.
Fügen Sie die hervorgehobenen Zeilen als ersten Schritt der Bereitstellungsphase hinzu .
```
- stage: 'Deploy'
  displayName: 'Deploy the containers'
  dependsOn: Build
  jobs:
  - deployment: Deploy
    displayName: Deploy
    pool:
      vmImage: 'ubuntu-20.04'
    environment: 'spike.default'
    variables:
    - group: Release
    strategy:
      runOnce:
        deploy:
          steps:
          - download: current
            artifact: manifests
```
Andy: Nun müssen wir ein Image-Pullgeheimnis erstellen, das von unserer ACR- und AKS-Instanz gemeinsam genutzt wird. Wissen Sie, ob es eine Aufgabe gibt, die wir verwenden können?

Mara: Ich habe gerade danach gesucht. Und wir haben Glück. Die KubernetesManifest@0 Aufgabe unterstützt eine Aktion, um den benötigten Geheimschlüssel zu erstellen.

Kubernetes-Manifest-Aufgabe

Die Kubernetes-Manifestaufgabe wurde entwickelt, um alle gängigen Bereitstellungsvorgänge zu verwalten, die für Kubernetes erforderlich sind. Es unterstützt mehrere action Optionen, die von der Erstellung geheimer Schlüssel bis zur Bereitstellung von Images reichen. In diesem Fall wird die createSecret Aktion zusammen mit den folgenden Parametern verwendet:

action gibt das auszuführende Feature an. In diesem Fall wird mit createSecret das gemeinsam genutzte Geheimnis erstellt.
connectionType Gibt den Typ der zu verwendenden Dienstverbindung an. Optionen: azureResourceManager oder kubernetesServiceConnection.
secretName Gibt den Namen des zu erstellenden geheimen Schlüssels an.
dockerRegistryEndpoint Gibt den Namen der Azure Container Registry Services-Verbindung an.
azureSubscriptionConnection Gibt den Namen der ARM Services-Verbindung an.
azureResourceGroup Gibt den Namen Ihrer Ressourcengruppe an.
kubernetesCluster Gibt den Namen Ihres AKS-Clusters an.
namespace Gibt den Kubernetes-Namespace an, für den diese Aktion gilt.

Fügen Sie den folgenden hervorgehobenen Codeschnipsel am Ende Ihrer Pipeline hinzu. Stellen Sie sicher, dass sowohl der Ressourcengruppenname als auch der Clustername mit den Namen der zuvor erstellten übereinstimmen. Achten Sie darauf, dass die Einrückung dieses Tasks mit derjenigen des Tasks Herunterladen übereinstimmt.
```
- 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'
```
Andy: Der letzte Schritt besteht darin, die Bereitstellung unserer Images im Kubernetes-Cluster auszulösen. Basierend auf der Dokumentation sieht es so aus, als ob wir dieselbe Aufgabe verwenden können, aber mit einer anderen Aktion und parametern.
- action gibt das auszuführende Feature an. In diesem Fall deploy für die Bereitstellung im AKS-Cluster.
- connectionType Gibt den Typ der zu verwendenden Dienstverbindung an. Optionen: azureResourceManager oder kubernetesServiceConnection.
- azureSubscriptionConnection Gibt den Namen der ARM Services-Verbindung an.
- azureResourceGroup Gibt den Namen Ihrer Ressourcengruppe an.
- kubernetesCluster Gibt den Namen Ihres AKS-Clusters an.
- namespace Gibt den Kubernetes-Namespace an, für den diese Aktion gilt.
- imagePullSecrets Gibt die Liste der geheimen Schlüssel an, die zum Abrufen aus der Containerregistrierung erforderlich sind.
- containers Gibt die Liste der bereitzustellenden Containerimages an.

Fügen Sie den folgenden Abschnitt an das Ende der Pipeline hinzu. Stellen Sie sicher, dass sowohl der Ressourcengruppenname als auch der Clustername mit den Namen der zuvor erstellten übereinstimmen. Achten Sie darauf, dass die Einrückung dieses Tasks mit derjenigen des vorherigen Tasks übereinstimmt.

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

Ausführen Ihrer Pipeline

Wählen Sie "Speichern" in der oberen rechten Ecke der Seite aus. Wählen Sie "Speichern" aus, um Ihre Commit-Nachricht zu bestätigen.
Wählen Sie Ausführen aus, bestätigen Sie Ihren Branchnamen, und wählen Sie dann Ausführen aus, um eine Pipelineausführung auszulösen.
Wählen Sie Pipelines und dann Ihre Pipeline aus, um die Protokolle anzuzeigen, während Ihre Pipeline ausgeführt wird.
Nachdem die Pipelineausführung abgeschlossen ist, wählen Sie "Umgebungen" im linken Bereich aus, und wählen Sie dann die Dev-Umgebung aus, um Ihre Bereitstellungsaufträge anzuzeigen.
Sehen wir uns nun unsere bereitgestellten Web-App- und API-Endpunkte an. Dazu müssen wir die externen IP-Adressen sowohl für die Webdienste als auch für die Ranglistendienste erhalten.
Navigieren Sie zum Azure-Portal, wählen Sie Ihren AKS-Cluster aus, und wählen Sie dann "Dienste und Eineingänge" aus.
Wählen Sie die externe IP für Ihren Webdienst aus, um Ihre Website auf AKS anzuzeigen.
Kehren Sie zu Ihrem Azure-Portal zurück, wo Sie aufgehört haben, und kopieren Sie dann die externe IP für Ihren Ranglistendienst. Diese IP-Adresse ist der Ort, an dem die Bestenlisten-API öffentlich gehostet wird.
Ersetzen Sie den Platzhalter im folgenden Link durch die externe IP, die Sie kopiert haben. Sie können auch einen pageSize=10 Abfrageparameter hinzufügen, um das Anzeigen der JSON-Antwort in Ihrem Browser zu vereinfachen. Verwenden Sie eine URL wie die folgende in einem neuen Tab des Browsers.
```
http://[IP]/api/Leaderboard?pageSize=10
```
Sie können die rohe JSON-Antwort von der Ranglisten-API anzeigen, die in Ihrem AKS-Cluster gehostet wird. Sie verfügen jetzt über eine REST-API, die Sie von anderen Anwendungen aufrufen können.

Andy: Das hat super geklappt! Ich denke, die Verwendung von Kubernetes wäre eine großartige Möglichkeit für uns, eine breitere Microservices-Strategie zu übernehmen.