Tutorial: Bereitstellen eines ereignisgesteuerten Auftrags mit Azure Container Apps

Aufträge von Azure Container Apps ermöglichen die Ausführung containerisierter Aufgaben, die für einen begrenzten Zeitraum ausgeführt und dann beendet werden. Sie können eine Auftragsausführung manuell, nach einem Zeitplan oder basierend auf Ereignissen auslösen. Aufträge eignen sich am besten für Aufgaben wie Datenverarbeitung, maschinelles Lernen, Ressourcenbereinigung oder Szenarios, die serverlose kurzlebige Computeressourcen erfordern.

In diesem Tutorial erfahren Sie, wie Sie ereignisgesteuerte Aufträge verwenden.

Erstellen einer Container Apps-Umgebung für die Bereitstellung Ihrer Container-Apps
Erstellen einer Azure Storage-Warteschlange zum Senden von Nachrichten an die Container-App
Erstellen eines Containerimages, das einen Auftrag ausführt
Bereitstellen des Auftrags in der Container Apps-Umgebung
Überprüfen der Verarbeitung der Warteschlangennachrichten durch die Container-App

Der erstellte Auftrag startet eine Ausführung für jede Nachricht, die an eine Azure Storage-Warteschlange gesendet wird. Jede Auftragsausführung führt einen Container aus, der folgende Schritte durchführt:

Abrufen einer Nachricht aus der Warteschlange
Protokollieren der Nachricht in den Auftragsausführungsprotokollen
Löschen der Nachricht aus der Warteschlange
Beenden

Wichtig

Der Scaler überwacht die Länge der Warteschlange, um zu ermitteln, wie viele Aufträge gestartet werden sollen. Löschen Sie für eine genaue Skalierung keine Nachricht aus der Warteschlange, bis die Verarbeitung der Auftragsausführung abgeschlossen ist.

Der Quellcode für den Auftrag, der in diesem Tutorial ausgeführt wird, ist in einem GitHub-Repository mit Azure-Beispielen verfügbar.

Voraussetzungen

Ein Azure-Konto mit einem aktiven Abonnement. Falls Sie keins haben, können Sie kostenlos eins erstellen.
Die Azure CLI

Informationen zu Features, die Container-Apps-Aufträge nicht unterstützen, finden Sie unter Auftragseinschränkungen.

Vorbereiten der Umgebung

Um sich über die Azure CLI bei Azure anzumelden, führen Sie den folgenden Befehl aus, und folgen Sie den Anweisungen, um den Authentifizierungsprozess abzuschließen.
```
az login
```
Stellen Sie sicher, dass Sie die neueste Version der Azure CLI über den az upgrade Befehl ausführen.
```
az upgrade
```
Installieren Sie die neueste Version der Container Apps CLI-Erweiterung.
```
az extension add --name containerapp --upgrade
```

Registrieren Sie die Namespaces Microsoft.App, Microsoft.OperationalInsights und Microsoft.Storage, wenn sie noch nicht in Ihrem Azure-Abonnement registriert sind.

az provider register --namespace Microsoft.App
az provider register --namespace Microsoft.OperationalInsights
az provider register --namespace Microsoft.Storage

Definieren Sie die Umgebungsvariablen, die in diesem Artikel verwendet werden.

RESOURCE_GROUP="jobs-quickstart"
LOCATION="northcentralus"
ENVIRONMENT="env-jobs-quickstart"
JOB_NAME="my-job"

Erstellen einer Container-Apps-Umgebung

Die Container-Apps-Umgebung fungiert als Isolationsgrenze für Container-Apps und -Aufträge, sodass sie dasselbe Netzwerk gemeinsam nutzen und miteinander kommunizieren können.

Erstellen Sie mit dem folgenden Befehl eine Ressourcengruppe.

az group create \
    --name "$RESOURCE_GROUP" \
    --location "$LOCATION"

Erstellen Sie die Container-Apps-Umgebung mithilfe des folgenden Befehls.

az containerapp env create \
    --name "$ENVIRONMENT" \
    --resource-group "$RESOURCE_GROUP" \
    --location "$LOCATION"

Einrichten einer Speicherwarteschlange

Der Auftrag verwendet eine Azure Storage-Warteschlange, um Nachrichten zu empfangen. In diesem Abschnitt werden ein Speicherkonto und eine Warteschlange erstellt.

Definieren Sie einen eindeutigen Namen für Ihr Speicherkonto.
```
STORAGE_ACCOUNT_NAME="<STORAGE_ACCOUNT_NAME>"
QUEUE_NAME="myqueue"
```
Ersetzen Sie <STORAGE_ACCOUNT_NAME> durch einen eindeutigen Namen für Ihr Speicherkonto. Speicherkontonamen müssen innerhalb von Azure eindeutig und zwischen 3 und 24 Zeichen lang sein und dürfen nur Zahlen und Kleinbuchstaben enthalten.

Erstellen Sie ein Azure Storage-Konto.

az storage account create \
    --name "$STORAGE_ACCOUNT_NAME" \
    --resource-group "$RESOURCE_GROUP" \
    --location "$LOCATION" \
    --sku Standard_LRS \
    --kind StorageV2

Wenn dieser Befehl den folgenden Fehler zurückgibt:

(SubscriptionNotFound) Subscription <SUBSCRIPTION_ID> was not found.
Code: SubscriptionNotFound
Message: Subscription <SUBSCRIPTION_ID> was not found.

Stellen Sie sicher, dass Sie den Namespace Microsoft.Storage in Ihrem Azure-Abonnement registriert haben.

az provider register --namespace Microsoft.Storage

Speichern Sie die Verbindungszeichenfolge der Warteschlange in einer Variablen.

QUEUE_CONNECTION_STRING=$(az storage account show-connection-string -g $RESOURCE_GROUP --name $STORAGE_ACCOUNT_NAME --query connectionString --output tsv)

Erstellen Sie die Nachrichtenwarteschlange.

az storage queue create \
    --name "$QUEUE_NAME" \
    --account-name "$STORAGE_ACCOUNT_NAME" \
    --connection-string "$QUEUE_CONNECTION_STRING"

Erstellen einer benutzerseitig zugewiesenen verwalteten Identität

Um die Verwendung von Administratoranmeldeinformationen zu vermeiden, pullen Sie Images aus privaten Repositorys in Microsoft Azure Container Registry unter Verwendung von verwalteten Identitäten für die Authentifizierung. Verwenden Sie nach Möglichkeit eine benutzerseitig zugewiesene verwaltete Identität zum Pullen von Images.

Erstellen einer benutzerseitig zugewiesenen verwalteten Identität. Wählen Sie vor dem Ausführen der folgenden Befehle einen Namen für die verwaltete Identität aus, und ersetzen Sie \<PLACEHOLDER\> durch den Namen.
```
IDENTITY="<YOUR_IDENTITY_NAME>"
```
```
az identity create \
    --name $IDENTITY \
    --resource-group $RESOURCE_GROUP
```

Rufen Sie die Ressourcen-ID der Identität ab.

IDENTITY_ID=$(az identity show \
    --name $IDENTITY \
    --resource-group $RESOURCE_GROUP \
    --query id \
    --output tsv)

Erstellen und Bereitstellen des Auftrags

Um den Auftrag bereitzustellen, müssen Sie zunächst ein Containerimage für den Auftrag erstellen und es in eine Registrierung pushen. Anschließend können Sie den Auftrag in der Container Apps-Umgebung bereitstellen.

Definieren Sie einen Namen für Ihr Containerimage und die Registrierung.
```
CONTAINER_IMAGE_NAME="queue-reader-job:1.0"
CONTAINER_REGISTRY_NAME="<CONTAINER_REGISTRY_NAME>"
```
Ersetzen Sie <CONTAINER_REGISTRY_NAME> durch einen eindeutigen Namen für Ihre Containerregistrierung. Containerregistrierungsnamen müssen innerhalb von Azure eindeutig und zwischen fünf und 50 Zeichen lang sein. Außerdem dürfen sie nur Zahlen und Kleinbuchstaben enthalten.

Erstellen Sie eine Containerregistrierung.

az acr create \
    --name "$CONTAINER_REGISTRY_NAME" \
    --resource-group "$RESOURCE_GROUP" \
    --location "$LOCATION" \
    --sku Basic

Ihre Containerregistrierung muss ARM-Zielgruppentoken (Azure Resource Manager) für die Authentifizierung zulassen, um eine verwaltete Identität zum Pullen von Images zu verwenden.

Verwenden Sie den folgenden Befehl, um zu überprüfen, ob ARM-Token auf Ihre ACR-Instanz (Azure Container Registry) zugreifen dürfen:
```
az acr config authentication-as-arm show --registry "$CONTAINER_REGISTRY_NAME"
```
Wenn ARM-Token zulässig sind, gibt der Befehl Folgendes aus:
```
{
  "status": "enabled"
}
```
Wenn status für disabled angegeben ist, lassen Sie ARM-Token mit dem folgenden Befehl zu:
```
az acr config authentication-as-arm update --registry "$CONTAINER_REGISTRY_NAME" --status enabled
```
Der Quellcode für den Auftrag ist auf GitHub verfügbar. Führen Sie den folgenden Befehl aus, um das Repository zu klonen und das Containerimage mithilfe des Befehls az acr build in der Cloud zu erstellen.
```
az acr build \
    --registry "$CONTAINER_REGISTRY_NAME" \
    --image "$CONTAINER_IMAGE_NAME" \
    "https://github.com/Azure-Samples/container-apps-event-driven-jobs-tutorial.git"
```
Das Image ist jetzt in der Containerregistrierung verfügbar.

Erstellen Sie einen Auftrag in der Container Apps-Umgebung.

az containerapp job create \
    --name "$JOB_NAME" \
    --resource-group "$RESOURCE_GROUP" \
    --environment "$ENVIRONMENT" \
    --trigger-type "Event" \
    --replica-timeout "1800" \
    --min-executions "0" \
    --max-executions "10" \
    --polling-interval "60" \
    --scale-rule-name "queue" \
    --scale-rule-type "azure-queue" \
    --scale-rule-metadata "accountName=$STORAGE_ACCOUNT_NAME" "queueName=$QUEUE_NAME" "queueLength=1" \
    --scale-rule-auth "connection=connection-string-secret" \
    --image "$CONTAINER_REGISTRY_NAME.azurecr.io/$CONTAINER_IMAGE_NAME" \
    --cpu "0.5" \
    --memory "1Gi" \
    --secrets "connection-string-secret=$QUEUE_CONNECTION_STRING" \
    --registry-server "$CONTAINER_REGISTRY_NAME.azurecr.io" \
    --mi-user-assigned "$IDENTITY_ID" \
    --registry-identity "$IDENTITY_ID" \
    --env-vars "AZURE_STORAGE_QUEUE_NAME=$QUEUE_NAME" "AZURE_STORAGE_CONNECTION_STRING=secretref:connection-string-secret"

In der folgenden Tabelle werden die wichtigsten Parameter des Befehls beschrieben:

Parameter	Beschreibung
`--replica-timeout`	Die maximale Dauer, für die ein Replikat ausgeführt werden kann.
`--min-executions`	Die Mindestanzahl von Auftragsausführungen, die pro Abrufintervall ausgeführt werden sollen.
`--max-executions`	Die maximale Anzahl von Auftragsausführungen, die pro Abrufintervall ausgeführt werden sollen.
`--polling-interval`	Das Abrufintervall, mit dem die Skalierungsregel ausgewertet werden soll.
`--scale-rule-name`	Der Name der Skalierungsregel.
`--scale-rule-type`	Der Typ der zu verwendenden Skalierungsregel.
`--scale-rule-metadata`	Die Metadaten für die Skalierungsregel.
`--scale-rule-auth`	Die Authentifizierung für die Skalierungsregel.
`--secrets`	Die Geheimnisse, die für den Auftrag verwendet werden sollen.
`--registry-server`	Der Containerregistrierungsserver, der für den Auftrag verwendet werden soll. Bei einer Azure Container Registry-Instanz wird die Authentifizierung automatisch durch den Befehl konfiguriert.
`--mi-user-assigned`	Die Ressourcen-ID der benutzerseitig zugewiesenen verwalteten Identität zum Zuweisen des Auftrags
`--registry-identity`	Die Ressourcen-ID einer verwalteten Identität zum Authentifizieren beim Registrierungsserver anstelle eines Benutzernamens und eines Kennworts. Sofern möglich, wird automatisch die Rollenzuweisung „acrpull“ für die Identität erstellt.
`--env-vars`	Die Umgebungsvariablen, die für den Auftrag verwendet werden sollen.

Die Konfiguration der Skalierungsregel definiert die zu überwachende Ereignisquelle. Sie wird in jedem Abrufintervall ausgewertet und bestimmt, wie viele Auftragsausführungen ausgelöst werden. Weitere Informationen finden Sie unter Festlegen von Skalierungsregeln.

Der ereignisgesteuerte Auftrag wird nun in der Container Apps-Umgebung erstellt.

Überprüfen der Bereitstellung

Der Auftrag wird so konfiguriert, dass die Skalierungsregel alle 60 Sekunden ausgewertet wird, um die Anzahl von Nachrichten in der Warteschlange zu überprüfen. In jedem Auswertungszeitraum wird eine neue Auftragsausführung für jede Nachricht in der Warteschlange gestartet (bis zur Obergrenze von zehn Ausführungen).

Um zu überprüfen, ob der Auftrag ordnungsgemäß konfiguriert wurde, können Sie einige Nachrichten an die Warteschlange senden und sich vergewissern, dass Auftragsausführungen gestartet und die Meldungen in den Auftragsausführungsprotokollen protokolliert werden.

Senden Sie eine Nachricht an die Warteschlange.

az storage message put \
    --content "Hello Queue Reader Job" \
    --queue-name "$QUEUE_NAME" \
    --connection-string "$QUEUE_CONNECTION_STRING"

Listen Sie die Ausführungen eines Auftrags auf.
```
az containerapp job execution list \
    --name "$JOB_NAME" \
    --resource-group "$RESOURCE_GROUP" \
    --output json
```
Da der Auftrag so konfiguriert ist, dass die Skalierungsregel alle 60 Sekunden ausgewertet wird, kann es bis zu einer Minute dauern, bis die Auftragsausführung gestartet wird. Wiederholen Sie den Befehl, bis die Auftragsausführung angezeigt wird und der Status Succeeded lautet.
Führen Sie die folgenden Befehle aus, um die protokollierten Nachrichten anzuzeigen. Für diese Befehle ist die Log Analytics-Erweiterung erforderlich. Stimmen Sie daher der ggf. angezeigten Aufforderung zur Installation der Erweiterung zu.
```
LOG_ANALYTICS_WORKSPACE_ID=$(az containerapp env show --name $ENVIRONMENT --resource-group $RESOURCE_GROUP --query properties.appLogsConfiguration.logAnalyticsConfiguration.customerId --output tsv)

az monitor log-analytics query \
    --workspace "$LOG_ANALYTICS_WORKSPACE_ID" \
    --analytics-query "ContainerAppConsoleLogs_CL | where ContainerJobName_s == '$JOB_NAME' | order by _timestamp_d asc"
```
Bis die Tabelle ContainerAppConsoleLogs_CL bereit ist, gibt der Befehl einen Fehler zurück: BadArgumentError: The request had some invalid properties. Warten Sie einige Minuten, und versuchen Sie erneut.

Tipp

Treten Probleme auf? Informieren Sie uns über GitHub, indem Sie ein Problem im Azure Container Apps-Repository öffnen.

Bereinigen von Ressourcen

Führen Sie anschließend den folgenden Befehl aus, um die Ressourcengruppe zu löschen, die Ihre Container Apps-Ressourcen enthält.

Achtung

Mit dem folgenden Befehl werden die angegebene Ressourcengruppe und alle darin enthaltenen Ressourcen gelöscht. Falls in der angegebenen Ressourcengruppe Ressourcen enthalten sind, die nicht zum Umfang dieses Tutorials gehören, werden sie ebenfalls gelöscht.

az group delete \
    --resource-group $RESOURCE_GROUP

Nächste Schritte

Container Apps-Aufträge

Feedback

War diese Seite hilfreich?

Last updated on 2024-12-12