Tutoriel : Déployer un travail piloté par les événements avec Azure Container Apps

Article
12/12/2024

Les travaux Azure Container Apps vous permettent d’exécuter des tâches conteneurisées qui s’exécutent pendant une durée limitée et s’arrêtent. Vous pouvez déclencher une exécution de travail manuellement, selon une planification ou en fonction d’événements. Les travaux conviennent bien aux tâches telles que le traitement des données, le Machine Learning, le nettoyage des ressources ou tout scénario nécessitant des ressources de calcul éphémères serverless.

Dans ce tutoriel, vous allez apprendre à utiliser des travaux pilotés par les événements.

Créer un environnement Container Apps pour déployer vos applications de conteneur
Créer une file d’attente stockage Azure pour envoyer des messages à l’application conteneur
Créer une image conteneur qui exécute un travail
Déployer le travail dans l’environnement Container Apps
Vérifier que les messages de la file d’attente sont traités par l’application conteneur

Le travail que vous créez démarre une exécution pour chaque message envoyé à une file d’attente du Stockage Azure. Chaque exécution de travail exécute un conteneur qui effectue les étapes suivantes :

Recevez un message de la file d’attente.
Journalise le message dans les journaux d’exécution du travail.
Supprime le message de la file d’attente.
S’arrête.

Important

Le processus de mise à l’échelle surveille la longueur de la file d’attente pour déterminer le nombre de travaux à démarrer. Pour une mise à l’échelle précise, ne supprimez pas un message de la file d’attente, avant la fin de son traitement par l’exécution du travail.

Le code source du travail que vous exécutez dans ce tutoriel est disponible dans un dépôt GitHub d’exemples Azure.

Prérequis

Compte Azure avec un abonnement actif.
- Si vous n’en avez pas, vous pouvez en créer un gratuitement.
Installez Azure CLI.
Se référer aux restrictions d’emploi pour obtenir une liste des limitations.

Programme d’installation

Pour vous connecter à Azure à partir de l’interface CLI, exécutez la commande suivante et suivez les invites pour procéder à l’authentification.
```
az login
```
Vérifiez que vous exécutez la dernière version de l’interface CLI à l’aide de la commande de mise à niveau.
```
az upgrade
```
Installez la dernière version de l’extension CLI Azure Container Apps.
```
az extension add --name containerapp --upgrade
```

Inscrivez les espaces de noms Microsoft.App, Microsoft.OperationalInsights et Microsoft.Storage si vous ne les avez pas déjà inscrits dans votre abonnement Azure.

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

À présent que votre configuration Azure CLI est terminée, vous pouvez définir les variables d’environnement utilisées dans cet article.
```
RESOURCE_GROUP="jobs-quickstart"
LOCATION="northcentralus"
ENVIRONMENT="env-jobs-quickstart"
JOB_NAME="my-job"
```

Créer un environnement Container Apps

L’environnement Azure Container Apps fait office de barrière sécurisée entourant les applications conteneur et les travaux afin qu’ils puissent partager le même réseau et communiquer entre eux.

Créez un groupe de ressources à l’aide de la commande suivante.

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

Créez l’environnement Container Apps à l’aide de la commande suivante.

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

Configurer une file d’attente de stockage

Le travail utilise une file d’attente Stockage Azure pour recevoir les messages. Dans cette section, vous créez un compte de stockage et une file d’attente.

Définissez un nom pour votre compte de stockage.
```
STORAGE_ACCOUNT_NAME="<STORAGE_ACCOUNT_NAME>"
QUEUE_NAME="myqueue"
```
Remplacez <STORAGE_ACCOUNT_NAME> par un nom unique pour votre compte de stockage. Les noms des comptes de stockage doivent être uniques dans Azure et comporter entre 3 et 24 caractères, uniquement des lettres minuscules et des chiffres.

Créez un compte de stockage Azure.

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

Si cette commande retourne l’erreur :

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

Vérifiez que vous avez inscrit l’espace de noms Microsoft.Storage dans votre abonnement Azure.

az provider register --namespace Microsoft.Storage

Enregistrez la chaîne de connexion de la file d’attente dans une variable.

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

Créez la file d’attente de messages.

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

Créer une identité managée attribuée par l’utilisateur

Pour éviter d’utiliser des informations d’identification d’administration, tirez (pull) des images depuis des référentiels privés dans Microsoft Azure Container Registry en utilisant des identités managées pour l’authentification. Si possible, utilisez une identité managée affectée par l’utilisateur pour tirer (pull) des images.

Créer une identité managée attribuée par l’utilisateur. Avant d’exécuter les commandes suivantes, choisissez un nom pour votre identité managée, puis remplacez le \<PLACEHOLDER\> par ce nom.
```
IDENTITY="<YOUR_IDENTITY_NAME>"
```
```
az identity create \
    --name $IDENTITY \
    --resource-group $RESOURCE_GROUP
```

Obtenez l’ID de ressource de l’identité.

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

Créer et déployer le travail

Pour déployer le travail, vous devez d’abord créer une image conteneur pour le travail et la pousser dans un registre. Vous pouvez ensuite déployer le travail dans l’environnement Container Apps.

Définissez un nom pour votre image conteneur et votre registre.
```
CONTAINER_IMAGE_NAME="queue-reader-job:1.0"
CONTAINER_REGISTRY_NAME="<CONTAINER_REGISTRY_NAME>"
```
Remplacez <CONTAINER_REGISTRY_NAME> par un nom unique pour votre registre de conteneurs. Les noms de registre de conteneurs doivent être uniques dans Azure et comporter entre 5 et 50 caractères, uniquement des lettres minuscules et des chiffres.

Créez un registre de conteneurs.

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

Votre registre de conteneurs doit autoriser les jetons d’audience Azure Resource Manager (ARM) pour l’authentification afin de pouvoir utiliser l’identité managée pour tirer (pull) des images.

Utilisez la commande suivante pour vérifier si les jetons ARM sont autorisés à accéder à votre instance Azure Container Registry (ACR).
```
az acr config authentication-as-arm show --registry "$CONTAINER_REGISTRY_NAME"
```
Si les jetons ARM sont autorisés, la commande produit la sortie suivante.
```
{
  "status": "enabled"
}
```
Si le status est disabled, autorisez les jetons ARM avec la commande suivante.
```
az acr config authentication-as-arm update --registry "$CONTAINER_REGISTRY_NAME" --status enabled
```
Le code source de ce travail est disponible sur GitHub. Exécutez la commande suivante pour cloner le dépôt et créer l’image conteneur dans le cloud à l’aide de la commande az acr build.
```
az acr build \
    --registry "$CONTAINER_REGISTRY_NAME" \
    --image "$CONTAINER_IMAGE_NAME" \
    "https://github.com/Azure-Samples/container-apps-event-driven-jobs-tutorial.git"
```
L’image est maintenant disponible dans le registre de conteneurs.

Créez un travail dans l’environnement Container Apps.

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"

Le tableau suivant décrit les paramètres clés utilisés dans la commande.

Paramètre	Description
`--replica-timeout`	Durée maximale pendant laquelle un réplica peut s’exécuter.
`--min-executions`	Nombre minimal d’exécutions de travaux à exécuter par intervalle d’interrogation.
`--max-executions`	Nombre maximal d’exécutions de travaux à exécuter par intervalle d’interrogation.
`--polling-interval`	Intervalle d’interrogation auquel évaluer la règle de mise à l’échelle.
`--scale-rule-name`	Nom de la règle de mise à l’échelle.
`--scale-rule-type`	Type de règle de mise à l’échelle à utiliser.
`--scale-rule-metadata`	Métadonnées pour la règle de mise à l’échelle.
`--scale-rule-auth`	Authentification pour la règle de mise à l’échelle.
`--secrets`	Secrets à utiliser pour le travail.
`--registry-server`	Serveur de registre de conteneurs à utiliser pour le travail. Pour une instance Azure Container Registry, la commande configure automatiquement l’authentification.
`--mi-user-assigned`	L’ID de ressource de l’identité managée affectée par l’utilisateur à affecter au travail.
`--registry-identity`	L’ID de ressource d’une identité managée à authentifier auprès du serveur de registres au lieu d’utiliser un nom d’utilisateur et un mot de passe. Si possible, une attribution de rôle « acrpull » est créée automatiquement pour l’identité.
`--env-vars`	Variables d’environnement à utiliser pour le travail.

La configuration de la règle de mise à l’échelle définit la source d’événement à surveiller. Elle est évaluée à chaque intervalle d’interrogation et détermine le nombre d’exécutions de travaux à déclencher. Pour en savoir plus, consultez Définir des règles de mise à l’échelle.

Le travail piloté par les événements est maintenant créé dans l’environnement Container Apps.

Vérifier le déploiement

Le travail est configuré pour évaluer la règle de mise à l’échelle toutes les 60 secondes, qui vérifie le nombre de messages dans la file d’attente. Pour chaque période d’évaluation, il démarre une nouvelle exécution de travail pour chaque message de la file d’attente, jusqu’à un maximum de 10 exécutions.

Pour vérifier que le travail a été correctement configuré, vous pouvez envoyer des messages à la file d’attente, confirmer que les exécutions de travaux ont été démarrées et que les messages sont consignés dans les journaux d’exécution de travail.

Envoyez un message dans la file d’attente.

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

Listez les exécutions d’un travail.
```
az containerapp job execution list \
    --name "$JOB_NAME" \
    --resource-group "$RESOURCE_GROUP" \
    --output json
```
Étant donné que le travail est configuré pour évaluer la règle de mise à l’échelle toutes les 60 secondes, le démarrage de l’exécution du travail peut prendre jusqu’à une minute entière. Répétez la commande jusqu’à ce que l’exécution du travail s’affiche et que son état soit Succeeded.
Exécutez les commandes suivantes pour voir les messages journalisés. Ces commandes nécessitent l’extension Log Analytics, donc acceptez la demande d’installation de l’extension lorsque vous y êtes invité.
```
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"
```
Tant que la table ContainerAppConsoleLogs_CL n’est pas prête, la commande retourne une erreur : BadArgumentError: The request had some invalid properties. Patientez quelques minutes, puis réessayez.

Conseil

Vous rencontrez des problèmes ? Faites-le nous savoir sur GitHub en ouvrant un problème dans le dépôt Azure Container Apps.

Nettoyer les ressources

Une fois que vous avez terminé, exécutez la commande suivante pour supprimer le groupe de ressources qui contient vos ressources Container Apps.

Attention

La commande suivante supprime le groupe de ressources spécifié et toutes les ressources qu’il contient. Si des ressources en dehors du cadre de ce tutoriel existent dans le groupe de ressources spécifié, elles seront également supprimées.

az group delete \
    --resource-group $RESOURCE_GROUP

Étapes suivantes

Travaux Container Apps

Partager via