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 verwenden vorhandene Entwicklungstools wie Docker Compose, um die Anwendung lokal zu erstellen und zu testen. Folgendes wird vermittelt:

Klonen Sie eine Beispielanwendungsquelle aus GitHub.
Erstellen eines Containerimages aus der Beispielanwendungsquelle
Testen der Anwendung mit mehreren Containern in einer lokalen Docker-Umgebung

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.

Hinweis

Azure Cloud Shell enthält nicht die Docker-Komponenten, die zum Ausführen jedes Schritts in diesen Lernprogrammen erforderlich sind. Aus diesem Grund wird empfohlen, eine vollständige Docker-Entwicklungsumgebung zu verwenden.

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.
Rabbit MQ: Nachrichtenwarteschlange für eine Auftragswarteschlange.

Git-Client
Azure Developer CLI

Erstellen Sie ein Verzeichnis auf Ihrem Computer, und wechseln Sie in Ihrer Terminalsitzung zu diesem Verzeichnis, z. B. Bash. In diesem Beispiel wird ein Verzeichnis namens Demorepo verwendet, Sie können jedoch einen beliebigen Namen verwenden.
```
mkdir demorepo
cd demorepo
```
Verwenden Sie Git, um die Beispielanwendung in Ihrer Entwicklungsumgebung zu klonen.
```
git clone https://github.com/Azure-Samples/aks-store-demo.git
```
Wechseln Sie in das geklonte Verzeichnis.
```
cd aks-store-demo
```

Wenn Sie azd lokal verwenden, erstellen Sie ein leeres Verzeichnis mit dem Namen aks-store-demo zum Hosten der azd-Vorlagendateien.
```
mkdir aks-store-demo
```
Wechseln Sie in das neue Verzeichnis, um alle Dateien aus der Azd-Vorlage zu laden.
```
cd aks-store-demo
```
Klonen Sie die Beispielanwendung mit dem Befehl aks-store-demo in das Verzeichnis azd init, und legen Sie dabei das Flag --template auf aks-store-demo fest.
```
azd init --template aks-store-demo
```

Ü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.

services:
  rabbitmq:
    image: rabbitmq:3.13.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
    volumes:
      - ./rabbitmq_enabled_plugins:/etc/rabbitmq/enabled_plugins
    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
      - ORDER_QUEUE_RECONNECT_LIMIT=3
    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

Docker
Azure Developer CLI

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

Docker

Führen Sie den Befehl docker compose aus, um das Containerimage zu erstellen, das RabbitMQ-Image herunterzuladen und die Anwendung zu starten:
```
docker compose -f docker-compose-quickstart.yml up -d
```

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

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:3.13.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.

Bereinigen von Ressourcen

Da Sie die Funktionsfähigkeit der Anwendung überprüft haben, können Sie die ausgeführten Container beenden und entfernen. Löschen Sie die Containerimages nicht , da Sie sie im nächsten Lernprogramm verwenden.

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

docker compose down

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

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

Klonen Sie eine Beispielanwendungsquelle aus GitHub.
Erstellen eines Containerimages aus der Beispielanwendungsquelle
Testen der Anwendung mit mehreren Containern in einer lokalen Docker-Umgebung

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

Images in das Azure Container Registry übertragen

Feedback

War diese Seite hilfreich?

Last updated on 2026-04-07