Tutoriel : Déployer des exécuteurs et des agents CI/CD autohébergés avec des travaux Azure Container Apps

Dans ce tutoriel, vous découvrez comment exécuter des exécuteurs GitHub Actions en tant que travail Container Apps basé sur un événement.

Dans ce tutoriel, vous découvrez comment exécuter des agents Azure Pipelines en tant que travail Container Apps basé sur des événements.

• Organisation Azure DevOps : si vous ne disposez pas d’une organisation DevOps avec un abonnement actif, vous pouvez en créer une gratuitement.

Créer un dépôt GitHub pour l’exécution d’un workflow

Pour exécuter un flux de travail, vous devez créer un dépôt GitHub qui contient la définition du flux de travail.

1. Accédez à GitHub et connectez-vous.

2. Créez un dépôt en entrant les valeurs suivantes.

   Paramètre	Valeur
   Propriétaire	Sélectionnez votre nom d’utilisateur GitHub.
   Nom du dépôt	Entrez un nom pour votre dépôt.
   Visibilité	Sélectionnez Privé.
   Initialiser ce dépôt avec	Sélectionnez Ajouter un fichier README.

   Utilisez les valeurs par défaut pour les autres paramètres.

3. Sélectionnez Créer un dépôt.

4. Dans votre nouveau dépôt, sélectionnez Actions.

5. Recherchez le modèle Workflow simple, puis sélectionnez Configurer.

6. Sélectionnez Valider les modifications pour ajouter le workflow à votre référentiel.

Le workflow s’exécute sur l’exécuteur ubuntu-latest hébergé sur GitHub et imprime un message sur la console. Vous remplacez plus tard l’exécuteur hébergé sur GitHub par un exécuteur autohébergés.

Obtenir un jeton d’accès personnel GitHub

Pour exécuter un exécuteur autohébergé, vous devez créer un jeton d’accès personnel (PAT) dans GitHub. Chaque fois qu’un exécuteur démarre, le jeton d’accès personnel (PAT) génère un jeton pour enregistrer l’exécuteur auprès de GitHub. La règle d’échelle de l’exécuteur GitHub Actions utilise le jeton d’accès personnel (PAT) pour surveiller la file d’attente du flux de travail du référentiel et démarrer les exécuteurs selon les besoins.

1. Dans GitHub, sélectionnez votre image de profil dans le coin supérieur droit, puis sélectionnez Paramètres.

2. Sélectionnez Paramètres de développeur.

3. Sous Jetons d’accès personnels, sélectionnez Jetons affinés.

4. Sélectionnez Générer un nouveau jeton.

5. Dans l’écran Nouveau jeton d’accès personnel affiné, entrez les valeurs suivantes.

   Paramètre	Valeur
   Nom du jeton	Entrez un nom pour votre jeton.
   Expiration	Sélectionnez 30 jours.
   Accès au dépôt	Sélectionnez Sélectionner uniquement les dépôts, puis le dépôt que vous avez créé.

   Entrez les valeurs suivantes pour Autorisations de dépôt.

   Paramètre	Valeur
   Actions	Sélectionnez Lecture seule.
   Administration	Sélectionnez Lecture et écriture.
   Métadonnées	Sélectionnez Lecture seule.

6. Sélectionnez Générer un jeton.

7. Copiez la valeur du jeton.

8. Définissez des variables que vous utilisez pour configurer le runner et les règles de mise à l'échelle ultérieurement.

   • Bash
   • PowerShell

   GITHUB_PAT="<GITHUB_PAT>"
   REPO_OWNER="<REPO_OWNER>"
   REPO_NAME="<REPO_NAME>"
   REGISTRATION_TOKEN_API_URL="<YOUR_REGISTRATION_TOKEN_API_URL>"
   

   Remplacez les espaces réservés par les valeurs suivantes :

   Espace réservé	Valeur
   <GITHUB_PAT>	Le jeton PAT GitHub que vous avez généré.
   <REPO_OWNER>	Le propriétaire du référentiel que vous avez créé plus tôt. Cette valeur est généralement votre nom d’utilisateur GitHub.
   <REPO_NAME>	Le nom du référentiel que vous avez créé précédemment. Cette valeur est le même nom entré dans le champ Nom du référentiel.
   <YOUR_REGISTRATION_TOKEN_API_URL>	URL de l’API du jeton d’inscription dans le fichier entrypoint.sh. Par exemple, « https://myapi.example.com/get-token ».

Générer l’image conteneur d’exécuteur GitHub Actions

Pour créer un exécuteur autohébergé, vous devez créer une image conteneur qu’exécute l’exécuteur. Dans cette section, vous générez l’image conteneur, puis l’envoyez (push) à un registre de conteneurs.

1. Définissez un nom pour votre image conteneur et votre registre.

   • Bash
   • PowerShell

   CONTAINER_IMAGE_NAME="github-actions-runner:1.0"
   CONTAINER_REGISTRY_NAME="<CONTAINER_REGISTRY_NAME>"
   

   Remplacez <CONTAINER_REGISTRY_NAME> par un nom unique pour créer un 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.

2. Créez un registre de conteneurs.

   • Bash
   • PowerShell

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

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

   Utilisez la commande suivante pour vérifier si les jetons ARM sont autorisés à accéder à votre instance Azure Container Registry (ACR).

   • Bash
   • PowerShell

   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 status est disabled, utilisez la commande suivante pour autoriser les jetons ARM.

   • Bash
   • PowerShell

   az acr config authentication-as-arm update --registry "$CONTAINER_REGISTRY_NAME" --status enabled
   

4. Le Dockerfile pour créer l’image d’exécuteur est disponible sur GitHub. Exécutez la commande suivante pour cloner le référentiel et générer l’image conteneur dans le cloud à l’aide de la az acr build commande.

   • Bash
   • PowerShell

   az acr build \
       --registry "$CONTAINER_REGISTRY_NAME" \
       --image "$CONTAINER_IMAGE_NAME" \
       --file "Dockerfile.github" \
       "https://github.com/Azure-Samples/container-apps-ci-cd-runner-tutorial.git"
   

   L’image est maintenant disponible dans le registre de conteneurs.

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

Pour éviter d’utiliser des informations d’identification administratives, extrayez des images à partir de référentiels privés dans Microsoft Azure Container Registry à l’aide d’identités managées pour l’authentification. Si possible, utilisez une identité managée affectée par l’utilisateur pour tirer (pull) des images.

1. Créez une identité managée affecté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.

   • Bash
   • PowerShell

   IDENTITY="<YOUR_IDENTITY_NAME>"
   

   az identity create \
       --name $IDENTITY \
       --resource-group $RESOURCE_GROUP
   

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

   • Bash
   • PowerShell

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

Déployer un exécuteur autohébergé comme travail

Vous pouvez maintenant créer un travail qui utilise l’image conteneur. Dans cette section, vous allez créer une tâche qui exécute l’exécuteur auto-hébergé et s’authentifie auprès de GitHub à l’aide du jeton d’accès personnel (PAT) que vous avez généré précédemment. Le travail utilise la règle de mise à l’échelle github-runnerpour créer des exécutions de travail en fonction du nombre d’exécutions de workflow en attente.

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

   • Bash
   • PowerShell

   az containerapp job create \
       --name "$JOB_NAME" \
       --resource-group "$RESOURCE_GROUP" \
       --environment "$ENVIRONMENT" \
       --trigger-type Event \
       --replica-timeout 1800 \
       --replica-retry-limit 0 \
       --replica-completion-count 1 \
       --parallelism 1 \
       --image "$CONTAINER_REGISTRY_NAME.azurecr.io/$CONTAINER_IMAGE_NAME" \
       --min-executions 0 \
       --max-executions 10 \
       --polling-interval 30 \
       --scale-rule-name "github-runner" \
       --scale-rule-type "github-runner" \
       --scale-rule-metadata "githubAPIURL=https://api.github.com" "owner=$REPO_OWNER" "runnerScope=repo" "repos=$REPO_NAME" "targetWorkflowQueueLength=1" \
       --scale-rule-auth "personalAccessToken=personal-access-token" \
       --cpu "2.0" \
       --memory "4Gi" \
       --secrets "personal-access-token=$GITHUB_PAT" \
       --env-vars "GITHUB_PAT=secretref:personal-access-token" "GH_URL=https://github.com/$REPO_OWNER/$REPO_NAME" "REGISTRATION_TOKEN_API_URL=https://api.github.com/repos/$REPO_OWNER/$REPO_NAME/actions/runners/registration-token" \
       --registry-server "$CONTAINER_REGISTRY_NAME.azurecr.io" \
       --mi-user-assigned "$IDENTITY_ID" \
       --registry-identity "$IDENTITY_ID"
   

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

   Paramètre	Descriptif
   --replica-timeout	Durée maximale pendant laquelle un réplica peut s’exécuter.
   --replica-retry-limit	Nombre de nouvelles tentatives d’exécution d’un réplica en échec.
   --replica-completion-count	Nombre de réplicas qui doivent être exécutées avec succès avant qu’une tâche soit considérée comme réussie.
   --parallelism	Nombre de réplicas à démarrer par exécution de travail.
   --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. Pour plus d’informations sur l’outil de mise à l’échelle des exécuteurs GitHub, consultez la documentation KEDA.
   --scale-rule-metadata	Métadonnées pour la règle de mise à l’échelle. Si vous utilisez GitHub Enterprise, mettez à jour githubAPIURL avec son URL d’API.
   --scale-rule-auth	Authentification pour la règle de mise à l’échelle.
   --secrets	Secrets à utiliser pour le travail.
   --env-vars	Variables d’environnement à 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	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é.

   La configuration de la règle de mise à l’échelle définit la source d’événement à surveiller. Les règles sont évaluées à chaque fréquence d’interrogation pour déterminer le nombre d’exécutions de travail à déclencher. Pour plus d’informations, 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.

Exécuter un workflow et vérifier le travail

Le travail est configuré pour évaluer la règle de mise à l’échelle toutes les 30 secondes. Pendant chaque évaluation, il vérifie le nombre d’exécutions de flux de travail en attente qui nécessitent un exécuteur auto-hébergé et démarre une nouvelle exécution de travail pour chaque flux de travail en attente, jusqu’à un maximum de 10 exécutions configurées.

Pour vérifier la configuration du travail, modifiez le flux de travail pour utiliser un exécuteur auto-hébergé et déclencher une exécution de flux de travail. Vous pouvez ensuite afficher les journaux d’exécution de travail pour voir le workflow fonctionner.

1. Dans le référentiel GitHub, accédez au flux de travail que vous avez généré précédemment. Il s’agit d’un fichier YAML dans le répertoire .github/workflows.

2. Sélectionnez Modifier sur place.

3. Mettez à jour la propriété runs-on en spécifiant self-hosted :

   runs-on: self-hosted
   

4. Sélectionnez Commiter les modifications....

5. Sélectionnez Commiter les modifications.

6. Accédez à l’onglet Actions .

   Un nouveau workflow est désormais mis en file d’attente. Dans les 30 secondes, l’exécution du travail démarre et le flux de travail se termine peu après.

   Attendez la fin de l’action avant de passer à l’étape suivante.

7. Répertoriez les exécutions du travail pour confirmer qu’une exécution de travail a été créée et effectuée correctement.

   • Bash
   • PowerShell

   az containerapp job execution list \
       --name "$JOB_NAME" \
       --resource-group "$RESOURCE_GROUP" \
       --output table \
       --query '[].{Status: properties.status, Name: name, StartTime: properties.startTime}'
   

Créer un projet et un dépôt Azure DevOps

Pour exécuter un pipeline, vous avez besoin d’un projet et d’un dépôt Azure DevOps.

1. Accédez à Azure DevOps et connectez-vous à votre compte.

2. Sélectionnez une organisation existante ou en créer une.

3. Dans la page de vue d’ensemble de l’organisation, sélectionnez Nouveau projet et entrez les valeurs suivantes.

   Paramètre	Valeur
   Nom du projet	Entrez un nom pour votre projet.
   Visibilité	Sélectionnez Privé.

4. Sélectionnez Créer.

5. Dans la navigation latérale, sélectionnez Dépôts.

6. Sous Initialiser une branche primaire avec un fichier README ou .gitignore, sélectionnez Ajouter un fichier README.

7. Conservez les valeurs par défaut pour le reste des paramètres et sélectionnez Initialiser.

Créer un pool d’agents

Créez un pool d’agents pour exécuter l’exécuteur autohébergé.

1. Dans votre projet Azure DevOps, développez la barre de navigation gauche et sélectionnez Paramètres du projet.

   

2. Sous la section Pipelines dans le menu de navigation Paramètres du projet, sélectionnez Pools d’agents.

   

3. Sélectionnez Ajouter un pool et entrez les valeurs suivantes.

   Paramètre	Valeur
   Pool à lier	Sélectionnez Nouveau.
   Type de pool	Sélectionnez Autohébergé.
   Nom	Entrez container-apps.
   Accorder une autorisation d’accès à tous les pipelines	Activez cette case à cocher.

4. Sélectionnez Créer.

Obtenir un jeton d’accès personnel Azure DevOps

Pour exécuter un exécuteur autohébergé, vous devez créer un jeton d’accès personnel (PAT) dans Azure DevOps. Utilisez le PAT pour authentifier l’agent auprès d’Azure DevOps. La règle d’échelle utilise également le jeton pour vérifier le nombre d’exécutions de pipeline en attente et déclencher de nouvelles exécutions de tâches.

1. Dans Azure DevOps, sélectionnez Paramètres utilisateur à côté de votre image de profil dans le coin supérieur à droite.

2. Sélectionnez Jetons d’accès personnels.

3. Dans la page Jetons d’accès personnels, sélectionnez Nouveau jeton, puis entrez les valeurs suivantes.

   Paramètre	Valeur
   Nom	Entrez un nom pour votre jeton.
   Organisation	Sélectionnez l’organisation choisie ou créée plus tôt.
   Étendues	Sélectionnez Définition personnalisée.
   Afficher toutes les étendues	Sélectionnez Afficher toutes les étendues.
   Pools d’agents (lire et gérer)	Sélectionnez Pools d’agents (lire et gérer).

   Laissez toutes les autres étendues non sélectionnées.

4. Sélectionnez Créer.

5. Copiez la valeur de jeton en lieu sûr.

   Vous ne pouvez pas récupérer le jeton une fois que vous quittez la page.

6. Définissez des variables que vous utilisez pour configurer les travaux Container Apps ultérieurement.

   • Bash
   • PowerShell

   AZP_TOKEN="<AZP_TOKEN>"
   ORGANIZATION_URL="<ORGANIZATION_URL>"
   AZP_POOL="container-apps"
   

   Remplacez les espaces réservés par les valeurs suivantes :

   Espace réservé	Valeur	Commentaires
   <AZP_TOKEN>	Le jeton PAT Azure DevOps que vous avez généré.
   <ORGANIZATION_URL>	L’URL de votre organisation Azure DevOps. Veillez à ce qu’il n’y ait pas de / de fin présent à la fin de l’URL.	Par exemple, https://dev.azure.com/myorg ou https://myorg.visualstudio.com.

Créer l’image conteneur d’un agent Azure Pipelines

Pour créer un agent autohébergé, vous devez créer une image conteneur qu’exécute l’agent. Dans cette section, vous générez l’image conteneur, puis l’envoyez (push) à un registre de conteneurs.

1. De retour dans votre terminal, définissez un nom pour votre image conteneur et votre registre.

   • Bash
   • PowerShell

   CONTAINER_IMAGE_NAME="azure-pipelines-agent:1.0"
   CONTAINER_REGISTRY_NAME="<CONTAINER_REGISTRY_NAME>"
   

   Remplacez <CONTAINER_REGISTRY_NAME> par un nom unique pour créer un 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.

2. Créez un registre de conteneurs.

   • Bash
   • PowerShell

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

3. Le Dockerfile pour créer l’image d’exécuteur est disponible sur GitHub. Exécutez la commande suivante pour cloner le référentiel et générer l’image conteneur dans le cloud à l’aide de la az acr build commande.

   • Bash
   • PowerShell

   az acr build \
       --registry "$CONTAINER_REGISTRY_NAME" \
       --image "$CONTAINER_IMAGE_NAME" \
       --file "Dockerfile.azure-pipelines" \
       "https://github.com/Azure-Samples/container-apps-ci-cd-runner-tutorial.git"
   

   L’image est maintenant disponible dans le registre de conteneurs.

Créer un agent autohébergé d’espace réservé

Avant de pouvoir exécuter un agent autohébergé dans votre nouveau pool d’agents, vous devez créer un agent d’espace réservé. L’agent d’espace réservé veille à ce que le pool d’agents soit disponible. Les pipelines utilisés par le pool d’agents échouent lorsqu’il n’existe aucun agent d’espace réservé.

Vous pouvez exécuter un travail manuel pour enregistrer un agent d’espace réservé hors connexion. Ensuite, la tâche s’exécute seulement une fois et vous pouvez la supprimer. L’agent d’espace réservé ne consomme aucune ressource dans Azure Container Apps ou Azure DevOps.

1. Créez un travail manuel dans l’environnement Container Apps qui crée l’agent d’espace réservé.

   • Bash
   • PowerShell

   az containerapp job create -n "$PLACEHOLDER_JOB_NAME" -g "$RESOURCE_GROUP" --environment "$ENVIRONMENT" \
       --trigger-type Manual \
       --replica-timeout 300 \
       --replica-retry-limit 0 \
       --replica-completion-count 1 \
       --parallelism 1 \
       --image "$CONTAINER_REGISTRY_NAME.azurecr.io/$CONTAINER_IMAGE_NAME" \
       --cpu "2.0" \
       --memory "4Gi" \
       --secrets "personal-access-token=$AZP_TOKEN" "organization-url=$ORGANIZATION_URL" \
       --env-vars "AZP_TOKEN=secretref:personal-access-token" "AZP_URL=secretref:organization-url" "AZP_POOL=$AZP_POOL" "AZP_PLACEHOLDER=1" "AZP_AGENT_NAME=placeholder-agent" \
       --registry-server "$CONTAINER_REGISTRY_NAME.azurecr.io"
   

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

   Paramètre	Descriptif
   --replica-timeout	Durée maximale pendant laquelle un réplica peut s’exécuter.
   --replica-retry-limit	Nombre de nouvelles tentatives d’exécution d’un réplica en échec.
   --replica-completion-count	Nombre de répliques qui doivent s’achever avec succès avant qu'une exécution de tâche soit considérée comme réussie.
   --parallelism	Nombre de réplicas à démarrer par exécution de travail.
   --secrets	Secrets à utiliser pour le travail.
   --env-vars	Variables d’environnement à 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.

   La définition de la variable d’environnement AZP_PLACEHOLDER permet de configurer le conteneur d’agents à enregistrer en tant qu’agent d’espace réservé hors connexion sans exécuter de travail.

2. Exécutez le travail manuel pour créer l’agent d’espace réservé.

   • Bash
   • PowerShell

   az containerapp job start -n "$PLACEHOLDER_JOB_NAME" -g "$RESOURCE_GROUP"
   

3. Répertoriez les exécutions du travail pour confirmer qu’une exécution de travail a été créée et effectuée correctement.

   • Bash
   • PowerShell

   az containerapp job execution list \
       --name "$PLACEHOLDER_JOB_NAME" \
       --resource-group "$RESOURCE_GROUP" \
       --output table \
       --query '[].{Status: properties.status, Name: name, StartTime: properties.startTime}'
   

4. Vérifiez que l’agent d’espace réservé a été créé dans Azure DevOps.

   1. Dans Azure DevOps, accédez à votre projet.
   2. Sélectionnez Paramètres du projet>Pools d’agents>container-apps>Agents.
   3. Confirmez qu’un agent d’espace réservé nommé placeholder-agent est répertorié et que son état est hors connexion.

5. Vous n’avez pas besoin du poste à nouveau. Vous pouvez le supprimer.

   • Bash
   • PowerShell

   az containerapp job delete -n "$PLACEHOLDER_JOB_NAME" -g "$RESOURCE_GROUP"
   

Créer un agent autohébergé en tant que travail basé sur les événements

Après avoir créé un agent de réserve, vous pouvez créer un agent hébergé par soi-même. Dans cette section, vous créez un travail basé sur les événements qui exécute un agent autohébergé lors du déclenchement d’un pipeline.

az containerapp job create -n "$JOB_NAME" -g "$RESOURCE_GROUP" --environment "$ENVIRONMENT" \
    --trigger-type Event \
    --replica-timeout 1800 \
    --replica-retry-limit 0 \
    --replica-completion-count 1 \
    --parallelism 1 \
    --image "$CONTAINER_REGISTRY_NAME.azurecr.io/$CONTAINER_IMAGE_NAME" \
    --min-executions 0 \
    --max-executions 10 \
    --polling-interval 30 \
    --scale-rule-name "azure-pipelines" \
    --scale-rule-type "azure-pipelines" \
    --scale-rule-metadata "poolName=$AZP_POOL" "targetPipelinesQueueLength=1" \
    --scale-rule-auth "personalAccessToken=personal-access-token" "organizationURL=organization-url" \
    --cpu "2.0" \
    --memory "4Gi" \
    --secrets "personal-access-token=$AZP_TOKEN" "organization-url=$ORGANIZATION_URL" \
    --env-vars "AZP_TOKEN=secretref:personal-access-token" "AZP_URL=secretref:organization-url" "AZP_POOL=$AZP_POOL" \
    --registry-server "$CONTAINER_REGISTRY_NAME.azurecr.io"

az containerapp job create -n "$JOB_NAME" -g "$RESOURCE_GROUP" --environment "$ENVIRONMENT" `
    --trigger-type Event `
    --replica-timeout 1800 `
    --replica-retry-limit 0 `
    --replica-completion-count 1 `
    --parallelism 1 `
    --image "$CONTAINER_REGISTRY_NAME.azurecr.io/$CONTAINER_IMAGE_NAME" `
    --min-executions 0 `
    --max-executions 10 `
    --polling-interval 30 `
    --scale-rule-name "azure-pipelines" `
    --scale-rule-type "azure-pipelines" `
    --scale-rule-metadata "poolName=$AZP_POOL" "targetPipelinesQueueLength=1" `
    --scale-rule-auth "personalAccessToken=personal-access-token" "organizationURL=organization-url" `
    --cpu "2.0" `
    --memory "4Gi" `
    --secrets "personal-access-token=$AZP_TOKEN" "organization-url=$ORGANIZATION_URL" `
    --env-vars "AZP_TOKEN=secretref:personal-access-token" "AZP_URL=secretref:organization-url" "AZP_POOL=$AZP_POOL" `
    --registry-server "$CONTAINER_REGISTRY_NAME.azurecr.io"

Le tableau suivant décrit les paramètres de règle de mise à l’échelle utilisés dans la commande.

La configuration de la règle de mise à l’échelle définit la source d’événement à surveiller. Les règles sont évaluées à chaque fréquence d’interrogation pour déterminer le nombre d’exécutions de travail à déclencher. Pour plus d’informations, 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.

Exécuter un pipeline et vérifier le travail

Après avoir configuré une tâche d’agent auto-hébergé, exécutez un pipeline pour vérifier qu’il fonctionne correctement.

1. Dans le volet de navigation gauche de votre projet Azure DevOps, accédez à Pipelines.

2. Sélectionnez Créer un pipeline.

3. Sélectionnez Azure Repos Git comme emplacement de votre code.

4. Sélectionnez le dépôt que vous avez créé précédemment.

5. Sélectionnez Pipeline de démarrage.

6. Dans le pipeline YAML, remplacez le pool de vmImage: ubuntu-latest par name: container-apps.

   pool:
     name: container-apps
   

7. Sélectionnez Enregistrer et exécuter.

   Le pipeline s’exécute et utilise le travail d’agent autohébergé créé dans l’environnement Container Apps.

8. Répertoriez les exécutions du travail pour confirmer qu’une exécution de travail a été créée et effectuée correctement.

   • Bash
   • PowerShell

   az containerapp job execution list \
       --name "$JOB_NAME" \
       --resource-group "$RESOURCE_GROUP" \
       --output table \
       --query '[].{Status: properties.status, Name: name, StartTime: properties.startTime}'