Lernprogramm – Vorbereiten einer Anwendung für Azure Kubernetes Service (AKS)

In diesem Lernprogramm bereiten Sie eine Multicontaineranwendung für die Verwendung in Kubernetes vor. Sie können dieses Lernprogramm verwenden, unabhängig davon, ob Sie mit einer neuen Beispiel-App beginnen oder Docker Compose-Konzepte für eine App anpassen, die Sie zu Azure Kubernetes Service (AKS) migrieren möchten. Sie verwenden vorhandene Entwicklungstools wie Docker Compose, um die Anwendung lokal zu erstellen und zu testen. Folgendes wird vermittelt:

Nach Abschluss wird die Anwendung in Ihrer lokalen Entwicklungsumgebung ausgeführt:

In späteren Lernprogrammen laden Sie das Containerimage in eine Azure Container Registry (ACR) hoch und stellen es dann in einem AKS-Cluster bereit.

Voraussetzungen

In diesem Tutorial wird vorausgesetzt, dass zentrale Docker-Konzepte wie Container und Containerimages sowie docker-Befehle bekannt sind. Eine Einführung in Container finden Sie bei Bedarf unter Get started with Docker (Erste Schritte mit Docker).

Für dieses Tutorial ist eine lokale Docker-Entwicklungsumgebung mit Linux-Containern erforderlich. Docker stellt Pakete bereit, die Docker auf einem Mac, Windows oder Linux System konfigurieren.

Abrufen von Anwendungscode

Die in diesem Lernprogramm verwendete sample-Anwendung ist eine einfache Store-Front-App, einschließlich der folgenden Kubernetes-Bereitstellungen und -Dienste:

• Store Front: Webanwendung für Kunden zum Anzeigen von Produkten und Aufgeben von Bestellungen
• Product Service: Zum Anzeigen von Produktinformationen
• Order Service: dient der Aufgabe von Bestellungen.
• RabbitMQ: Nachrichtenwarteschlange für eine Bestellwarteschlange.

Überprüfen der Docker Compose-Datei

Die Beispielanwendung, die Sie in diesem Lernprogramm erstellen, verwendet die docker-compose-quickstart YAML-Datei aus dem Repository, das Sie geklont haben.

In der folgenden Tabelle werden die wichtigsten Standardwerte aus der Beispieldatei zum Verfassen zusammengefasst, sodass Sie schnell sehen können, welche Dienste, Ports und Abhängigkeiten das Lernprogramm verwendet:

services:
  rabbitmq:
    image: rabbitmq:4.3.2-management-alpine
    container_name: 'rabbitmq'
    restart: always
    environment:
      - "RABBITMQ_DEFAULT_USER=username"
      - "RABBITMQ_DEFAULT_PASS=password"
    ports:
      - 15672:15672
      - 5672:5672
    healthcheck:
      test: ["CMD", "rabbitmqctl", "status"]
      interval: 30s
      timeout: 10s
      retries: 5
    networks:
      - backend_services
  order-service:
    build: src/order-service
    container_name: 'order-service'
    restart: always
    ports:
      - 3000:3000
    healthcheck:
      test: ["CMD", "wget", "-O", "/dev/null", "-q", "http://order-service:3000/health"]
      interval: 30s
      timeout: 10s
      retries: 5
    environment:
      - ORDER_QUEUE_HOSTNAME=rabbitmq
      - ORDER_QUEUE_PORT=5672
      - ORDER_QUEUE_USERNAME=username
      - ORDER_QUEUE_PASSWORD=password
      - ORDER_QUEUE_NAME=orders
    networks:
      - backend_services
    depends_on:
      rabbitmq:
        condition: service_healthy
  product-service:
    build: src/product-service
    container_name: 'product-service'
    restart: always
    ports:
      - 3002:3002
    healthcheck:
      test: ["CMD", "wget", "-O", "/dev/null", "-q", "http://product-service:3002/health"]
      interval: 30s
      timeout: 10s
      retries: 5
    environment:
      - AI_SERVICE_URL=http://ai-service:5001/
    networks:
      - backend_services
  store-front:
    build: src/store-front
    container_name: 'store-front'
    restart: always
    ports:
      - 8080:8080
    healthcheck:
      test: ["CMD", "wget", "-O", "/dev/null", "-q", "http://store-front:80/health"]
      interval: 30s
      timeout: 10s
      retries: 5
    environment:
      - VUE_APP_PRODUCT_SERVICE_URL=http://product-service:3002/
      - VUE_APP_ORDER_SERVICE_URL=http://order-service:3000/
    networks:
      - backend_services
    depends_on:
      - product-service
      - order-service
networks:
  backend_services:
    driver: bridge

Erstellen von Containerimages und Ausführen einer Anwendung

Sie können Docker Compose verwenden, um die Erstellung von Containerimages und die Bereitstellung von Anwendungen mit mehreren Containern zu automatisieren.

Stellen Sie sicher, dass Docker im Linux-Containermodus ausgeführt wird, bevor Sie die folgenden Befehle ausführen.

1. Erstellen Sie im Stammverzeichnis des geklonten aks-store-demo Repositorys das Containerimage, laden Sie das RabbitMQ-Image herunter, und starten Sie die Anwendung mit dem docker compose Befehl:

   docker compose -f docker-compose-quickstart.yml up -d
   

2. Zeigen Sie die erstellten Images mithilfe des Befehls docker images an.

   docker images
   

   Die folgende verkürzte Beispielausgabe zeigt die erstellten Images:

   REPOSITORY                        TAG                          IMAGE ID
   aks-store-demo-product-service    latest                       72f5cd7e6b84
   aks-store-demo-order-service      latest                       54ad5de546f9
   aks-store-demo-store-front        latest                       1125f85632ae
   ...
   

3. Zeigen Sie die ausgeführten Container mithilfe des Befehls docker ps an.

   docker ps
   

   Die folgende verkürzte Beispielausgabe zeigt vier ausgeführte Container:

   CONTAINER ID        IMAGE
   f27fe74cfd0a        aks-store-demo-product-service
   df1eaa137885        aks-store-demo-order-service
   b3ce9e496e96        aks-store-demo-store-front
   31df28627ffa        rabbitmq:4.3.2-management-alpine
   

Lokales Testen der Anwendung

Zum Anzeigen Ihrer ausgeführten Anwendung wechseln Sie in einem lokalen Webbrowser zu http://localhost:8080. Die Beispielanwendung wird wie im folgenden Beispiel geladen:

Auf dieser Seite können Sie Produkte anzeigen und ihrem Warenkorb hinzufügen und dann eine Bestellung aufgeben.

Eigene Compose-Dateien migrieren

Wenn Sie bereits eine Anwendung in einer Docker-Compose-Datei definiert haben, können Sie diese Anleitung als Referenz für die lokale Validierung verwenden und anschließend Ihre vorhandene Compose-Konfiguration in Kubernetes-Manifeste umwandeln. Verwenden Sie Tools wie Kompose, Move2Kube, Docker Compose Bridge oder Podman , um Docker Compose-Definitionen in Kubernetes-Ressourcen zu konvertieren. Den vollständigen End-to-End-Konvertierungspfad finden Sie in der Kubernetes-Dokumentation zum Migrieren von Docker Compose zu Kubernetes und der AKS-Migrationsübersicht , wenn Sie auch von einem anderen Orchestrator- oder Modernisierungsworkflow wechseln.

Auswählen eines Konvertierungstools

Verwenden Sie diese Tabelle, wenn Sie einen schnellen Vergleich der gängigsten Compose-zu-Kubernetes-Optionen benötigen.

Welches Tool sollte ich auswählen?

• Wenn Sie einen schnellen Machbarkeitsnachweis oder Startmanifest benötigen, verwenden Sie Kompose.
• Wenn Sie Docker Desktop verwenden und einen nativen Docker-Pfad verwenden möchten, verwenden Sie Docker Compose Bridge.
• Wenn Sie einen größeren Mehrdienstmigrations- oder Modernisierungsaufwand haben, verwenden Sie Move2Kube.
• Wenn Sie von laufenden Containern oder Pods exportieren möchten, verwenden Sie Podman.
• Wenn Sie bereits über Manifeste verfügen und Verpackungen oder Überlagerungen benötigen, verwenden Sie Helm oder Kustomize.
• Wenn Sie nach der Konvertierung eine lokale Kubernetes-Entwicklungsschleife benötigen, verwenden Sie Skaffold oder Tilt.
• Wenn Sie Entwürfe für Manifeste oder Migrationserklärungen benötigen, verwenden Sie KI-Unterstützung, und überprüfen Sie das Ergebnis anhand der offiziellen Kubernetes- und AKS-Anleitungen.

Weitere zu berücksichtigende Tools:

• 8gwifi.org Kubernetes YAML-Konverter: Nützlich für schnelle Online-Experimente mit kleinen Compose-Dateien.
• Okteto: Nützlich, wenn Sie eine Cloud- oder Remote-Kubernetes-Entwicklungsschleife für Anwendungsteams benötigen.
• Devtron: Nützlich, wenn Sie nach der Konvertierung einen Plattformworkflow rund um Kubernetes-Übermittlung wünschen.
• Portainer: Nützlich, wenn Sie einen benutzeroberflächengesteuerten Container und Kubernetes-Verwaltungserfahrung wünschen.

Konvertieren Sie Ihre Compose-Dateien

Verwenden Sie die folgenden kopierbaren Befehle als Ausgangspunkt:

kompose convert
move2kube plan -s ./path && move2kube transform
docker compose bridge convert -o ./k8s/
podman kube generate mypod > k8s.yaml
skaffold init

Kompose-Konvertierung (Beispiel)

Das Open-Source-Tool Kompose konvertiert allgemeine Docker Compose-Einstellungen in Kubernetes-Objekte wie Bereitstellungen und Dienste.

1. Installieren Sie auf Windows Kompose mit dem folgenden Befehl:

   curl -L https://github.com/kubernetes/kompose/releases/latest/download/kompose-windows-amd64.exe -o kompose.exe
   

   Weitere Installationsoptionen finden Sie in den Kompose-Installationsanweisungen.

2. Führen Sie Kompose aus dem Verzeichnis aus, das Ihre docker-compose.yml Datei enthält.

   kompose convert
   

3. Überprüfen Sie die generierten Kubernetes YAML-Dateien, bevor Sie sie in AKS bereitstellen.

KI-unterstützte Konvertierung

Sie können einen KI-Assistenten verwenden, um Kubernetes-Manifeste zu entwerfen, Verfasseneinstellungen mit Kubernetes-Entsprechungen zu vergleichen oder zu erläutern, warum eine Konvertierung manuelle Änderungen benötigt.

Generische Beispielaufforderung:

Convert this docker-compose.yml into production-ready Kubernetes manifests. Use Apps/v1, move secrets to Kubernetes Secret objects, map local volumes to PersistentVolumeClaims, and add readiness and liveness probes for the web service.

AKS-gezielte Beispielaufforderung:

Convert this docker-compose.yml into AKS-ready Kubernetes manifests. Target an AKS cluster, push images to Azure Container Registry, use Apps/v1 objects, move secrets to Kubernetes Secret objects, map local volumes to Azure Files or Azure Disks-backed PersistentVolumeClaims, and add readiness and liveness probes for the web service.

Überprüfen Sie immer die KI-Ausgabe, bevor Sie sie anwenden. Überprüfen Sie apiVersion-Werte, Ressourcenanforderungen und -limits, Speicherklassen, Service-Exposition und Health-Probes.

Behandeln häufiger Übersetzungsprobleme

Wie werden Volumes behandelt?

Compose volumes benötigt häufig persistente Kubernetes-Volumes und eine Speicherklasse. Ersetzen Sie in AKS ausschließlich lokale Einbindungen durch Dienste wie Azure Disks oder Azure Files.

Was ersetzt depends_on?

Compose depends_on erzwingt in Kubernetes keine Laufzeitbereitschaft. Ersetzen Sie sie bei Bedarf durch Bereitschaftssonden, Startsonden oder Init-Containerlogik.

Wie gehe ich mit Secrets und Umgebungsvariablen um?

Compose-Umgebungswerte werden häufig in Kubernetes-ConfigMap- oder -Secret-Ressourcen oder in Azure-Key-Vault-Integrationen umgewandelt.

Was passiert mit Ports und Ingress?

Verfassen einer ports Zuordnung zu Kubernetes-Objekten Service und manchmal ingress- oder Gateway-API-Ressourcen, je nachdem, wie Sie die Anwendung veröffentlichen.

Wie übersetzen Integritätsprüfungen?

Compose-Einstellungen healthcheck werden in der Regel als Kubernetes-Liveness- und Readiness-Probes verwendet.

Was geschieht mit Compose-Netzwerken?

Compose-Netzwerke werden in der Regel in Kubernetes über Services und Cluster-DNS zur Diensterkennung abgebildet, statt über benutzerdefinierte Bridge-Netzwerke.

Wie teste ich lokal mit Kubernetes?

Stellen Sie nach der Konvertierung die generierten Manifeste in einer lokalen Kubernetes-Umgebung wie Art oder Minikube bereit, und verwenden Sie dann Skaffold oder Tilt , wenn Sie eine schnellere Edit-Build-Deploy-Schleife benötigen.

Anwenden von AKS-spezifischen Anpassungen nach der Konvertierung

Kompose gibt Ihnen einen Ausgangspunkt, aber in der Regel müssen Sie für AKS manuelle Änderungen vornehmen:

• Aktualisieren Sie Bildverweise so, dass sie auf Ihre Azure Container Registry (ACR) zeigen.
• Ersetzen Sie ausschließlich lokalen Speicher und Bind-Mounts durch persistenten Speicher wie Azure Disks oder Azure Files, je nach Ihren Workloadanforderungen.
• Ersetzen Sie Compose-Geheimnisse oder umgebungsspezifische Werte durch Kubernetes Secrets, ConfigMaps oder Azure-Key-Vault-Integrationen.
• Überprüfen Sie die Netzwerk- und Expositionseinstellungen, z. B. LoadBalancer, Ingress- oder Gatewaykonfigurationen, je nachdem, wie Sie die App in AKS veröffentlichen möchten.
• Überprüfen Sie, ob zustandsbehaftete Komponenten als Bereitstellungen beibehalten oder zu Mustern wie StatefulSets wechseln sollen, wenn Sie ein stabiles Identitäts- oder Speicherverhalten benötigen.
• Prüfen Sie Ressourcenanforderungen, Probes und alle Annahmen zur Startreihenfolge, da sich Compose-Verhaltensweisen wie depends_on nicht direkt auf das Laufzeitverhalten von Kubernetes übertragen lassen.

Workflow nach der Konvertierung

1. Konvertieren Sie die Compose-Datei mit einem Tool wie Kompose, Move2Kube, Docker Compose Bridge, Podman oder einem von einer KI geprüften Entwurf.
2. Überprüfen und härten Sie die Manifeste, indem Sie Speicher, Secrets, Service-Exposition, Probes und Image-Referenzen korrigieren.
3. Paketieren Sie die Manifeste mit Helm oder überlagern Sie umgebungsspezifische Änderungen mit Kustomize.
4. Übertragen Sie Ihre Images in eine Registry wie ACR und stellen Sie sie dann mit GitOps, CI/CD oder direkten kubectl-Workflows bereit.

Beispielsequenz: kompose convert -> Manifeste überprüfen -> Images per Push an ACR übertragen -> Imageverweise aktualisieren ->kubectl apply oder helm install.

Bereinigen von Ressourcen

Wenn Sie dem Docker Compose-Workflow gefolgt sind, können Sie die ausgeführten Container beenden und entfernen. Löschen Sie die Containerimages nicht , da Sie sie im nächsten Lernprogramm verwenden. Wenn Sie den Azure Developer CLI-Workflow befolgt haben, verwenden Sie azd down anstelle von docker compose down.

Beenden und entfernen Sie die Containerinstanzen und -ressourcen mithilfe des Befehls docker compose down.

docker compose down

Azure-Entwickler-CLI-Befehle

Wenn Sie azd verwenden, gibt es keine manuellen Containerimageabhängigkeiten. Bei azd werden für die Bereitstellung und die Bereinigung Ihrer Anwendungen und Cluster die Befehle azd up und azd down verwendet, ähnlich wie bei Docker.

Sie können die Vorbereitungsschritte im Abschnitt infra Ihrer Datei azure.yaml so anpassen, dass entweder Terraform oder Bicep verwendet wird, bevor Sie den Cluster bereitstellen. Standardmäßig wird in diesem Projekt Terraform verwendet:

infra:
  provider: terraform
  path: infra/terraform

Wenn Sie den Anbieter in Bicep ändern möchten, aktualisieren Sie die Datei azure.yaml wie folgt:

infra:
  provider: bicep
  path: infra/bicep

Nächste Schritte

Azure CLI

In diesem Tutorial haben Sie eine Beispielanwendung erstellt, Containerimages für die Anwendung erstellt und dann die Anwendung getestet. Sie haben Folgendes gelernt:

Im nächsten Tutorial erfahren Sie, wie Sie Containerimages in einer ACR-Instanz speichern.

Azure Developer-Befehlszeilenschnittstelle (CLI)

In diesem Tutorial haben Sie eine Beispielanwendung mithilfe von azd geklont. Sie haben Folgendes gelernt:

Im nächsten Tutorial erfahren Sie, wie Sie mithilfe der von Ihnen geklonten azd-Vorlage einen Cluster erstellen.