Verwenden von Azure Kubernetes Fleet Manager Automatisierte Bereitstellungen zum Steuern der Platzierung von Multiclusterressourcen (Vorschau)

Automatisierte Bereitstellungen von Azure Kubernetes Fleet Manager können verwendet werden, um eine Anwendung aus einem Coderepository in einem oder mehreren AKS-Clustern in einer Flotte zu erstellen und bereitzustellen. Automatisierte Bereitstellungen vereinfachen das Einrichten eines GitHub Action-Workflows zum Erstellen und Bereitstellen Ihres Codes. Sobald die Verbindung hergestellt ist, wird die Pipeline bei jedem neuen Commit, den Sie vornehmen, ausgeführt.

Automatisierte Bereitstellungen basieren auf draft.sh. Wenn Sie einen neuen Bereitstellungsworkflow erstellen, können Sie eine vorhandene Dockerfile-Datei verwenden, eine Dockerfile generieren, vorhandene Kubernetes-Manifeste verwenden oder Kubernetes-Manifeste generieren. Die generierten Manifeste werden mit bewährten Methoden für Sicherheit und Resilienz erstellt.

Von Bedeutung

Previewfunktionen von Azure Kubernetes Fleet Manager sind auf Self-Service-Basis per Aktivierung verfügbar. Vorschauversionen werden „im Istzustand“ und „wie verfügbar“ bereitgestellt und sind von den Service Level Agreements und der eingeschränkten Garantie ausgeschlossen. Vorschauversionen von Azure Kubernetes Fleet Manager sind auf Best-Effort-Basis teilweise durch den Kundensupport abgedeckt. Daher sind diese Funktionen nicht für die Verwendung in der Produktion vorgesehen.

Voraussetzungen

• Ein GitHub-Konto mit der Anwendung, die bereitgestellt werden soll.
• Wenn Sie nicht über ein Azure-Konto verfügen, erstellen Sie ein kostenloses Konto , bevor Sie beginnen.
• Lesen Sie die konzeptionellen Übersichten über automatisierte Bereitstellungen und die Ressourcenverteilung , um die in diesem Artikel verwendeten Konzepte und Terminologie zu verstehen.
• Ein Kubernetes Fleet Manager mit einem Hubcluster und Mitgliedsclustern. Wenn Sie noch keine haben, lesen Sie bitte Erstellen einer Azure Kubernetes Fleet Manager-Ressource und Beitritt zu Mitgliedsclustern mithilfe der Azure CLI.
• Der Benutzer, der die Konfiguration abschließt, verfügt über Berechtigungen für die Fleet Manager-Hubcluster-Kubernetes-API. Weitere Informationen finden Sie unter Access the Kubernetes API for more details.
• Ein Kubernetes-Namespace, der bereits im Fleet Manager-Hubcluster bereitgestellt wurde.
• Eine Azure Container Registry (ACR) mit AcrPull-Rechten, die mitglieden AKS-Clustern gewährt werden.

Bringen Sie Ihren Anwendungsquellcode mit

Suchen Sie Ihren Azure Kubernetes Fleet Manager, und starten Sie die Konfiguration automatisierter Bereitstellungen.

1. Suchen Sie im Azure-Portal in der oberen Suchleiste nach Kubernetes Fleet Manager .
2. Wählen Sie kubernetes Flottenmanager in den Suchergebnissen aus.
3. Wählen Sie Ihren Azure Kubernetes Fleet Manager aus der Ressourcenliste aus.
4. Wählen Sie im Menü "Fleet Manager Service" unter "Flottenressourcen" die Option "Automatisierte Bereitstellungen" aus.
5. Wählen Sie im oberen Menü +Erstellen aus . Wenn dies Ihre erste Bereitstellung ist, können Sie im Bereich der Bereitstellungsliste auch Erstellen auswählen.

Herstellen einer Verbindung mit dem Quellcode-Repository

Erstellen Sie einen Workflow, und autorisieren Sie ihn, um eine Verbindung mit dem gewünschten Quellcode-Repository und Branch herzustellen. Führen Sie die folgenden Details auf der Registerkarte "Repository " aus.

1. Geben Sie einen aussagekräftigen Namen für den Workflow in das Feld " Workflowname " ein.
2. Wählen Sie als Nächstes " Autorisieren des Zugriffs " aus, um einen Benutzer für GitHub zu autorisieren, um eine Liste von Repositorys abzurufen.
3. Wählen Sie für Repositoryquelle eine der folgenden Optionen aus:
   1. Meine Repositorys für Repositorys, die der aktuell autorisierte GitHub-Benutzer besitzt oder;
   2. Alle Repositorys, auf die der aktuell autorisierte GitHub-Benutzer zugreifen kann. Sie müssen die Organisation auswählen, die das Repository besitzt.
4. Wählen Sie das Repository und den Branch aus.
5. Wählen Sie die Schaltfläche Weiter aus.

Angeben des Anwendungsimages und der Bereitstellungskonfiguration

Um eine Anwendung für die Ausführung auf Kubernetes vorzubereiten, müssen Sie sie in ein Containerimage integrieren, das Sie in einer Containerregistrierung speichern. Eine Dockerfile-Datei enthält Anweisungen zum Erstellen des Containerimages. Wenn Ihr Quellcode-Repository noch nicht über eine Dockerfile-Datei verfügt, können automatisierte Bereitstellungen eins für Sie generieren.

Verwenden vorhandener Dockerfile-Dateien

Wenn Ihr Code-Repository bereits über eine Dockerfile-Datei verfügt, können Sie es verwenden, um das Anwendungsimage zu erstellen.

1. Wählen Sie Vorhandene Dockerfile für die Containerkonfiguration aus.
2. Wählen Sie die Dockerfile aus Ihrem Repository aus.
3. Geben Sie den Dockerfile-Buildkontext ein, um den Satz von Dateien und Verzeichnissen an den Buildprozess zu übergeben (in der Regel denselben Ordner wie die Dockerfile). Diese Dateien werden verwendet, um das Image zu erstellen, und sie sind im endgültigen Bild enthalten, es sei denn, sie werden durch Einschluss in eine .dockerignore Datei ignoriert.
4. Wählen Sie eine vorhandene Azure-Containerregistrierung aus. Diese Registrierung wird verwendet, um das integrierte Anwendungsimage zu speichern. Jeder AKS-Cluster, der die Anwendung empfangen kann, muss Berechtigungen für die AcrPull Registry erhalten.
5. Legen Sie den Namen des Azure-Containerregistrierungsimages fest. Sie müssen diesen Imagenamen in Ihren Kubernetes-Bereitstellungsmanifesten verwenden.

Generieren einer Dockerfile-Datei

Verwenden Sie Fleet Manager Automatisierte Bereitstellungen, um eine Dockerfile für viele Sprachen und Frameworks wie Go, C#, Node.js, Python, Java, Gradle, Clojure, PHP, Ruby, Erlang, Swift und Rust zu generieren. Die Sprachunterstützung basiert auf den in draft.sh verfügbaren Sprachen.

1. Wählen Sie "Automatisch containerisieren" (Dockerfile generieren) für die Containerkonfiguration aus.
2. Legen Sie den Speicherort für Dateien im Repository auf einen Ordner im Quell-Repository fest.
3. Wählen Sie die Anwendungsumgebung aus der Liste der unterstützten Sprachen und Frameworks aus.
4. Geben Sie den Anwendungsport ein.
5. Wählen Sie eine vorhandene Azure-Containerregistrierung aus. Diese Registrierung wird verwendet, um das integrierte Anwendungsimage zu speichern. Jeder AKS-Cluster, der die Anwendung empfangen kann, muss Berechtigungen für die AcrPull Registry erhalten.
6. Legen Sie den Namen des Azure-Containerregistrierungsimages fest. Sie müssen diesen Imagenamen in Ihren Kubernetes-Bereitstellungsmanifesten verwenden.
7. Überprüfen Sie die generierten Dockerfile und .dockerignore Dateien.

Auswählen der Kubernetes-Manifestkonfiguration

Eine Anwendung, die auf Kubernetes ausgeführt wird, besteht aus vielen Kubernetes-Grundtypenkomponenten. Diese Komponenten beschreiben, welches Containerimage verwendet werden soll, wie viele Replikate ausgeführt werden sollen, wenn eine öffentliche IP erforderlich ist, um die Anwendung verfügbar zu machen usw. Weitere Informationen finden Sie in der offiziellen Kubernetes-Dokumentation. Wenn Ihr Quellcode-Repository noch nicht über Kubernetes-Manifeste verfügt, können automatisierte Bereitstellungen diese für Sie generieren. Sie können auch ein vorhandenes Helmdiagramm auswählen.

Warnung

Wählen Sie weder die fleet-system Namespaces noch einen der fleet-member Namespaces aus, da dies interne Namespaces sind, die von Fleet Manager verwendet werden, und können nicht verwendet werden, um Ihre Anwendung zu platzieren.

Verwenden vorhandener Kubernetes-Manifeste

Wenn Ihr Code-Repository bereits über ein Kubernetes-Manifest verfügt, können Sie es auswählen, um zu steuern, welche Workload von einer Clusterressourcenplatzierung bereitgestellt und konfiguriert wird.

1. Wählen Sie Vorhandene Kubernetes-Manifestbereitstellungsdateien verwenden für die Bereitstellungsoptionen.
2. Wählen Sie die Kubernetes-Manifestdatei oder den Ordner aus Ihrem Repository aus.
3. Wählen Sie den vorhandenen Flotten-Manager-Namespace aus, um die Arbeitsauslastung einzustufen.
4. Wählen Sie die Schaltfläche Weiter aus.

Generieren von Kubernetes-Manifesten

Verwenden Sie automatisierte Bereitstellungen von Fleet Manager, um eine Reihe grundlegender Kubernetes-Manifestdateien zu generieren, um Ihre Anwendung auf dem Laufenden zu halten. Zurzeit erstellt eine automatisierte Bereitstellung Deployment, Service und ConfigMap.

Die generierten Manifeste sind so konzipiert, dass Empfehlungen für Bereitstellungsvorkehrungen angewendet werden, z. B.:

• Automatisches Generieren von Liveness-, Bereitschafts- und Starttests
• Pod-Antiaffinität und Topologie-Verteilungsbeschränkungen, die Replikate auf verschiedene Knoten verteilen, um die Resilienz zu verbessern, werden bevorzugt.
• Das RuntimeDefaultsichere Computingprofil, das eine zusätzliche Schutzebene gegen gängige Schwachstellen bei Systemaufrufen bietet, die von böswilligen Akteuren ausgenutzt werden, wird erzwungen.
• Alle Linux-Funktionen werden abgelegt und nur ein begrenzter Satz nach den grundlegenden Kubernetes Pod Security Standards zugelassen.

So generieren Sie Kubernetes-Manifeste:

1. Wählen Sie " Anwendungsbereitstellungsdateien generieren" für die Bereitstellungsoptionen aus.
2. Geben Sie den Anwendungsport ein. Dieser Port wird auf dem generierten Service verwendet.
3. Wählen Sie den vorhandenen Flotten-Manager-Namespace aus, um die Arbeitsauslastung einzustufen.
4. Legen Sie den Speicherort für Dateien im Repository auf einen Ordner im Quell-Repository fest.
5. Wählen Sie die Schaltfläche Weiter aus.

Vorhandenes Helmdiagramm verwenden

Wenn Ihr Code-Repository bereits über ein Helm-Diagramm verfügt, können Sie es auswählen, um das Anwendungsimage zu erstellen.

1. Wählen Sie "Vorhandenes Helmdiagramm verwenden " für die Bereitstellungsoptionen aus.
2. Wählen Sie den Ordner "Diagrammpfad" aus Ihrem Repository aus.
3. Wählen Sie den Dateipfad Values.yaml aus Ihrem Repository aus.
4. Sie können optional Helmdiagramm-Überschreibungen bereitstellen.
5. Wählen Sie den vorhandenen Flotten-Manager-Namespace aus, um die Arbeitsauslastung einzustufen.
6. Wählen Sie die Schaltfläche Weiter aus.

Überprüfen der Konfiguration

Überprüfen Sie die Konfiguration für die Repository-, Image- und Bereitstellungskonfiguration.

Wählen Sie "Weiter" aus, um den Prozess zu starten, der diese Aktionen ausführt:

1. Erstellen Sie Verbundanmeldeinformationen, um die GitHub-Aktion zuzulassen:
   1. Übertragen Sie das erstellte Container-Image in die Azure-Containerregistrierung.
   2. Stellen Sie die Kubernetes-Manifeste im ausgewählten Namespace im Hubcluster des Flottenmanagers bereit.
2. Erstellen Sie eine Pull-Anforderung im Code-Repository mit allen generierten Dateien und dem Workflow.

Die Einrichtung dauert ein paar Minuten, also navigieren Sie nicht von der Seite "Bereitstellung" weg.

Überprüfen und Zusammenführen einer Pullanforderung

Wenn die Bereitstellungsphase abgeschlossen ist, wählen Sie die Schaltfläche " Pullanforderung genehmigen " aus, um die generierte Pullanforderung in Ihrem Code-Repository zu öffnen.

Hinweis

Es gibt ein bekanntes Problem mit der Benennung der generierten Pullanforderung, bei der angegeben wird, dass sie in AKS bereitgestellt wird. Trotz dieses falschen Namens stellt der resultierende Workflow Ihre Arbeitsauslastung im Hubcluster des Flottenmanagers im ausgewählten Namespace bereit.

1. Überprüfen Sie die Änderungen unter "Dateien geändert ", und nehmen Sie alle gewünschten Änderungen vor.
2. Wählen Sie "Zusammenführen"-Pullanforderung aus, um die Änderungen in Ihrem Code-Repository zusammenzuführen.

Beim Zusammenführen der Änderung wird der GitHub Actions-Workflow ausgeführt, der Ihre Anwendung in einem Containerimage erstellt und in der ausgewählten Azure-Containerregistrierung speichert.

Überprüfen der generierten Ressourcen

Nachdem die Pipeline abgeschlossen wurde, können Sie das erstellte Containerimage im Azure-Portal überprüfen, indem Sie die von Ihnen konfigurierte Azure-Containerregistrierungsinstanz suchen und das Image-Repository öffnen.

Sie können auch die Konfiguration für die automatisierte Bereitstellung von Fleet Manager anzeigen. Durch Auswählen des Namens workflow wird GitHub Action in GitHub geöffnet.

Schließlich können Sie bestätigen, dass die erwarteten Kubernetes-Ressourcen auf dem Fleet Manager-Hubcluster ausgeführt werden.

az fleet get-credentials \
    --resource-group ${GROUP} \
    --name ${FLEET}

kubectl describe deployments virtual-worker --namespace=contoso-store

Die Ausgabe sieht in etwa wie folgt aus. Eine Replikazahl von 0 ist zu erwarten, da keine Workloads im Hubcluster des Flottenmanagers geplant sind. Stellen Sie sicher, dass die Image Eigenschaft auf das integrierte Image in Ihrer Azure-Containerregistrierung verweist.

Name:                   virtual-worker
Namespace:              contoso-store
CreationTimestamp:      Thu, 24 Apr 2025 01:56:49 +0000
Labels:                 workflow=actions.github.com-k8s-deploy
                        workflowFriendlyName=contoso-store-deploy
Annotations:            <none>
Selector:               app=virtual-worker
Replicas:               1 desired | 0 updated | 0 total | 0 available | 0 unavailable
StrategyType:           RollingUpdate
MinReadySeconds:        0
RollingUpdateStrategy:  25% max unavailable, 25% max surge
Pod Template:
  Labels:  app=virtual-worker
  Containers:
   virtual-worker:
    Image:      contoso03.azurecr.io/virtual-worker:latest
    Port:       <none>
    Host Port:  <none>
    Limits:
      cpu:     2m
      memory:  20Mi
    Requests:
      cpu:     1m
      memory:  1Mi
    Environment:
      MAKELINE_SERVICE_URL:  http://makeline-service:3001
      ORDERS_PER_HOUR:       100
    Mounts:                  <none>
  Volumes:                   <none>
  Node-Selectors:            kubernetes.io/os=linux
  Tolerations:               <none>
Events:                      <none>

Definieren der Clusterressourcenplatzierung

Während der Vorschau können Sie zum Konfigurieren der Platzierung Ihrer mehrstufigen Workload an Mitgliedsclustern die folgenden Schritte ausführen.

1. Erstellen Sie im Quellcode-Repository für Ihre Anwendung einen Ordner im Repositorystamm namens Fleet.

2. Erstellen Sie eine neue Datei deploy-contoso-ns-two-regions.yaml im Flottenordner , und fügen Sie den angezeigten Inhalt hinzu. In diesem Beispiel wird der contoso-store Namespace in zwei Clustern bereitgestellt, die sich in zwei verschiedenen Azure-Regionen befinden müssen.

   apiVersion: placement.kubernetes-fleet.io/v1
   kind: ClusterResourcePlacement
   metadata:
     name: distribute-virtual-worker-two-regions
   spec:
     resourceSelectors:
       - group: ""
         kind: Namespace
         version: v1          
         name: contoso-store
     policy:
       placementType: PickN
       numberOfClusters: 2
       topologySpreadConstraints:
       - maxSkew: 1
         topologyKey: region
         whenUnsatisfiable: DoNotSchedule
   

3. Ändern Sie die GitHub Action-Workflowdatei, und fügen Sie einen Verweis auf die CRP-Datei hinzu.

   DEPLOYMENT_MANIFEST_PATH: |
     ./virtual-worker.yaml
     ./fleet/deploy-contoso-ns-two-regions.yaml
   

4. Übernehmen Sie das neue CRP-Manifest und die aktualisierte GitHub Actions-Workflowdatei.

5. Überprüfen Sie, ob die Arbeitslast gemäß der in der CRP-Definition definierten Richtlinie platziert ist. Sie überprüfen dies entweder über das Azure-Portal oder kubectl in der Befehlszeile.

Nächste Schritte

• Verwenden Sie die Clusterressourcenplatzierung, um Workloads in mehreren Clustern bereitzustellen.
• Intelligente clusterübergreifende Platzierung von Kubernetes-Ressourcen basierend auf den Eigenschaften der Mitgliedscluster.
• Häufig gestellte Fragen zu automatisierten Bereitstellungen.