Tutorial: Implementación de ejecutores y agentes de CI/CD autohospedados con trabajos de Azure Container Apps

En este tutorial, aprenderá a ejecutar ejecutores de Acciones de GitHub como un trabajo de Container Apps controlado por un evento.

En este tutorial, aprenderá a ejecutar agentes de Azure Pipelines como un trabajo de Container Apps controlado por eventos.

• Organización de Azure DevOps: si no tiene una organización de DevOps con una suscripción activa, puede crear una gratuitamente.

Crear un repositorio de GitHub para ejecutar un flujo de trabajo

Para ejecutar un flujo de trabajo, debe crear un repositorio de GitHub que contenga la definición del flujo de trabajo.

1. Vaya a GitHub e inicie sesión.

2. Para crear un repositorio, escriba los valores siguientes.

   Configuración	Importancia
   Propietario	Seleccione el nombre de usuario de GitHub.
   Nombre del repositorio	Escriba un nombre para el repositorio.
   Visibilidad	Seleccione Privado.
   Inicializar este repositorio con	Seleccione Agregar un archivo README.

   Use los valores predeterminados para la otra configuración.

3. Seleccione Crear repositorio.

4. En el nuevo repositorio, seleccione Acciones.

5. Busque la plantilla Flujo de trabajo simple y seleccione Configurar.

6. Seleccione Confirmar cambios para agregar el flujo de trabajo al repositorio.

El flujo de trabajo se ejecuta en el ejecutor hospedado en GitHub ubuntu-latest e imprime un mensaje en la consola. Más adelante, reemplace el ejecutor hospedado en GitHub por un ejecutor autohospedado.

Obtener un token de acceso personal de GitHub

Para ejecutar un ejecutor autohospedado, debe crear un token de acceso personal (PAT) en GitHub. Cada vez que se inicia un ejecutor, el PAT genera un token para registrar el ejecutor con GitHub. La regla de escalado del ejecutor de Acciones de GitHub usa el PAT para supervisar la cola de flujo de trabajo del repositorio e iniciar ejecutores según sea necesario.

1. En GitHub, seleccione la imagen de perfil en la esquina superior derecha y seleccione Configuración.

2. Seleccione Configuración de desarrollador.

3. En Tokens de acceso personal, seleccione Tokens específicos.

4. Seleccione Generar nuevo token.

5. En la pantalla Nuevo token de acceso personal específico , escriba los valores siguientes.

   Configuración	Importancia
   Nombre del token	Escriba un nombre para el token.
   Vencimiento	Seleccione 30 días.
   Acceso al repositorio	Seleccione Solo repositorios y seleccione el repositorio que creó.

   Escriba los valores siguientes para Permisos de repositorio.

   Configuración	Importancia
   Acciones	Seleccione Solo lectura.
   Administración	Seleccione Leer y escribir.
   Metadatos	Seleccione Solo lectura.

6. Seleccione Generar token.

7. Copie el valor del token.

8. Defina las variables que use para configurar el ejecutor y la regla de escalado más adelante.

   • Bash
   • PowerShell

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

   Reemplace los marcadores de posición por los siguientes valores:

   Marcador de posición	Importancia
   <GITHUB_PAT>	PAT de GitHub que generó.
   <REPO_OWNER>	El propietario del repositorio que creó anteriormente. Este valor suele ser el nombre de usuario de GitHub.
   <REPO_NAME>	Nombre del repositorio que creó anteriormente. Este valor es el mismo nombre que especificó en el campo Nombre del repositorio .
   <YOUR_REGISTRATION_TOKEN_API_URL>	Dirección URL de la API del token de registro en el archivo entrypoint.sh. Por ejemplo, "https://myapi.example.com/get-token"

Compilar la imagen de contenedor del ejecutor de Acciones de GitHub

Para crear un ejecutor autohospedado, debe crear una imagen de contenedor que ejecute el ejecutor. En esta sección, compilará la imagen de contenedor y la insertará en un registro de contenedor.

1. Defina un nombre para la imagen de contenedor y el registro.

   • Bash
   • PowerShell

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

   Reemplace <CONTAINER_REGISTRY_NAME> por un nombre único para crear un registro de contenedor. Los nombres del registro de contenedor deben ser únicos en Azure y tener entre 5 y 50 caracteres de longitud que contengan solo números y letras minúsculas.

2. Cree un registro de contenedor.

   • Bash
   • PowerShell

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

3. Su registro de contenedores debe permitir tokens de audiencia de Azure Resource Manager (ARM) para la autenticación para utilizar la identidad administrada para extraer imágenes.

   Utilice el siguiente comando para comprobar si los tokens ARM pueden acceder a su Azure Container Registry (ACR).

   • Bash
   • PowerShell

   az acr config authentication-as-arm show --registry "$CONTAINER_REGISTRY_NAME"
   

   Si se permiten los tokens ARM, el comando muestra lo siguiente.

   {
     "status": "enabled"
   }
   

   Si el status es disabled, use el siguiente comando para permitir tokens de ARM.

   • Bash
   • PowerShell

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

4. El Dockerfile para crear la imagen del ejecutor está disponible en GitHub. Ejecute el siguiente comando para clonar el repositorio y compilar la imagen de contenedor en la nube mediante el az acr build comando .

   • 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"
   

   La imagen ya está disponible en el registro de contenedor.

Crear una identidad administrada asignada por el usuario

Para evitar el uso de credenciales administrativas, extraiga imágenes de repositorios privados en Microsoft Azure Container Registry mediante identidades administradas para la autenticación. Cuando sea posible, use una identidad administrada asignada por el usuario para extraer las imágenes.

1. Cree una identidad administrada asignada por el usuario. Antes de ejecutar los comandos siguientes, elija el nombre de la identidad administrada y reemplace \<PLACEHOLDER\> por el nombre.

   • Bash
   • PowerShell

   IDENTITY="<YOUR_IDENTITY_NAME>"
   

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

2. Obtenga el id. de recurso de la identidad.

   • Bash
   • PowerShell

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

Implementar un ejecutor autohospedado como trabajo

Ahora puede crear un trabajo que use la imagen de contenedor. En esta sección, creas un trabajo que ejecuta el runner autohospedado y se autentica con GitHub utilizando el PAT que generaste anteriormente. El trabajo usa la regla de escalado github-runner para crear ejecuciones de trabajos en función del número de ejecuciones de flujo de trabajo pendientes.

1. Cree un trabajo en el entorno de 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"
   

   La siguiente tabla describe los principales parámetros que se usan en el comando.

   Parámetro	Descripción
   --replica-timeout	La duración máxima que se puede ejecutar una réplica.
   --replica-retry-limit	Número de veces que se reintenta una réplica con errores.
   --replica-completion-count	Número de réplicas que deben completarse correctamente antes de que la ejecución de un trabajo se considere exitosa.
   --parallelism	El número de réplicas que se inician por ejecución de trabajo.
   --min-executions	El número mínimo de ejecuciones de trabajos que tienen lugar por intervalo de sondeo.
   --max-executions	El número máximo de ejecuciones de trabajos que tienen lugar por intervalo de sondeo.
   --polling-interval	El intervalo de sondeo en el que se evalúa la regla de escalado.
   --scale-rule-name	El nombre de la regla de escalado.
   --scale-rule-type	El tipo de regla de escalado que se usa. Para más información sobre el escalador de ejecutores de GitHub, consulte la documentación de KEDA.
   --scale-rule-metadata	Los metadatos de la regla de escalado. Si usa GitHub Enterprise, actualice githubAPIURL con su dirección URL de API.
   --scale-rule-auth	La autenticación de la regla de escalado.
   --secrets	Los secretos que se usan para el trabajo.
   --env-vars	Las variables de entorno que se usan para el trabajo.
   --registry-server	El servidor de registro de contenedor que se usa para el trabajo. En el caso de una instancia de Azure Container Registry, el comando configura automáticamente la autenticación.
   --mi-user-assigned	El id. de recurso de la identidad administrada asignada por el usuario para asignar al trabajo.
   --registry-identity	El id. de recurso de una identidad administrada para autenticarse con el servidor de registro en lugar de utilizar un nombre de usuario y una contraseña. Si es posible, se crea automáticamente una asignación de función "acrpull" para la identidad.

   La configuración de la regla de escalado define el origen del evento que se supervisa. Las reglas se evalúan en cada intervalo de sondeo para determinar cuántas ejecuciones de trabajos deben desencadenarse. Para obtener más información, consulte Establecimiento de reglas de escalado.

El trabajo controlado por eventos ahora se crea en el entorno de Container Apps.

Ejecutar un flujo de trabajo y comprobar el trabajo

El trabajo está configurado para evaluar la regla de escalado cada 30 segundos. Durante cada evaluación, comprueba el número de ejecuciones de flujo de trabajo pendientes que requieren un ejecutor autohospedado e inicia una nueva ejecución de trabajos para cada flujo de trabajo pendiente, hasta un máximo configurado de 10 ejecuciones.

Para comprobar la configuración del trabajo, modifique el flujo de trabajo para usar un ejecutor autohospedado y desencadene una ejecución de flujo de trabajo. A continuación, puede ver los registros de ejecución del trabajo para ver la ejecución del flujo de trabajo.

1. En el repositorio de GitHub, vaya al flujo de trabajo que generó anteriormente. Es un archivo YAML en el directorio .github/workflows.

2. Seleccione Editar en su lugar.

3. Actualice la propiedad runs-on a self-hosted:

   runs-on: self-hosted
   

4. Seleccione Confirmar cambios....

5. Seleccione Confirmar cambios.

6. Vaya a la pestaña Acciones .

   Ahora se pone en cola un nuevo flujo de trabajo. En un plazo de 30 segundos, se inicia la ejecución del trabajo y el flujo de trabajo se completa poco después.

   Espere a que se complete la acción antes de continuar con el paso siguiente.

7. Enumere las ejecuciones del trabajo para confirmar que se ha creado y completado correctamente una ejecución de trabajo.

   • 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}'
   

Crear un repositorio y un proyecto de Azure DevOps

Para ejecutar una canalización, necesita un proyecto y un repositorio de Azure DevOps.

1. Vaya a Azure DevOps e inicie sesión en su cuenta.

2. Seleccione una organización existente o cree una nueva.

3. En la página de información general de la organización, seleccione Nuevo proyecto y escriba los valores siguientes.

   Configuración	Importancia
   Nombre del proyecto	Escriba un nombre para el proyecto.
   Visibilidad	Seleccione Privado.

4. Seleccione Crear.

5. En el panel de navegación lateral, seleccione Repositorios.

6. En Inicializar rama principal con un archivo README o .gitignore, seleccione Agregar un README.

7. Mantenga los valores predeterminados para el resto de la configuración y seleccione Inicializar.

Crear un nuevo grupo de agentes

Cree un nuevo grupo de agentes para ejecutar el ejecutor autohospedado.

1. En el proyecto de Azure DevOps, expanda la barra de navegación izquierda y seleccione Configuración del proyecto.

   

2. En la sección Canalizaciones del menú de navegación Configuración del proyecto , seleccione Grupos de agentes.

   

3. Seleccione Agregar grupo y escriba los valores siguientes.

   Configuración	Importancia
   Grupo que se va a vincular	Seleccione Nuevo.
   Tipo de pool	Seleccione Autohospedado.
   Nombre	Escriba container-apps.
   Concesión de permiso de acceso a todas las canalizaciones	Seleccione esta casilla de verificación.

4. Seleccione Crear.

Obtener un token de acceso personal de Azure DevOps

Para ejecutar un ejecutor autohospedado, debe crear un token de acceso personal (PAT) en Azure DevOps. Use el PAT para autenticar el ejecutor con Azure DevOps. La regla de escalado también usa el token para comprobar el número de ejecuciones de canalización pendientes y desencadenar nuevas ejecuciones de trabajos.

1. En Azure DevOps, seleccione Configuración de usuario junto a la imagen de perfil en la esquina superior derecha.

2. Seleccione Tokens de acceso personal.

3. En la página Tokens de acceso personal , seleccione Nuevo token y escriba los valores siguientes.

   Configuración	Importancia
   Nombre	Escriba un nombre para el token.
   Organización	Seleccione la organización que eligió o creó anteriormente.
   Ámbitos	Seleccione Definido por el usuario.
   Mostrar todos los ámbitos	Seleccione Mostrar todos los ámbitos.
   Grupos de agentes (leer y administrar)	Seleccione Grupos de agentes (Leer y administrar).

   Deje sin seleccionar todos los demás ámbitos.

4. Seleccione Crear.

5. Copie el valor del token en una ubicación segura.

   No se puede recuperar el token después de salir de la página.

6. Defina las variables que use para configurar los trabajos de Container Apps más adelante.

   • Bash
   • PowerShell

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

   Reemplace los marcadores de posición por los siguientes valores:

   Marcador de posición	Importancia	Comentarios
   <AZP_TOKEN>	PAT de Azure DevOps que generó.
   <ORGANIZATION_URL>	Dirección URL de la organización de Azure DevOps. Asegúrese de que no haya ningún / final al final de la dirección URL.	Por ejemplo, https://dev.azure.com/myorg o https://myorg.visualstudio.com.

Compilar la imagen de contenedor del agente de Azure Pipelines

Para crear un agente autohospedado, debe crear una imagen de contenedor que ejecute el agente. En esta sección, compilará la imagen de contenedor y la insertará en un registro de contenedor.

1. De nuevo en el terminal, defina un nombre para la imagen de contenedor y el registro.

   • Bash
   • PowerShell

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

   Reemplace <CONTAINER_REGISTRY_NAME> por un nombre único para crear un registro de contenedor.

   Los nombres del registro de contenedor deben ser únicos en Azure y tener entre 5 y 50 caracteres de longitud que contengan solo números y letras minúsculas.

2. Cree un registro de contenedor.

   • Bash
   • PowerShell

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

3. El Dockerfile para crear la imagen del ejecutor está disponible en GitHub. Ejecute el siguiente comando para clonar el repositorio y compilar la imagen de contenedor en la nube mediante el az acr build comando .

   • 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"
   

   La imagen ya está disponible en el registro de contenedor.

Crear un agente autohospedado de marcador de posición

Para poder ejecutar un agente autohospedado en el nuevo grupo de agentes, debe crear un agente de marcador de posición. El agente de marcador de posición garantiza que el grupo de agentes está disponible. Las canalizaciones que usan el grupo de agentes producen un error cuando no hay ningún agente de marcador de posición.

Puede ejecutar un trabajo manual para registrar un agente de marcador de posición sin conexión. El trabajo se ejecuta una vez y puede eliminarlo. El agente de marcador de posición no consume ningún recurso en Azure Container Apps ni En Azure DevOps.

1. Cree un trabajo manual en el entorno de Container Apps que cree el agente de marcador de posición.

   • 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"
   

   La siguiente tabla describe los principales parámetros que se usan en el comando.

   Parámetro	Descripción
   --replica-timeout	La duración máxima que se puede ejecutar una réplica.
   --replica-retry-limit	Número de veces que se reintenta una réplica con errores.
   --replica-completion-count	El número de réplicas que deben completarse exitosamente antes de que se considere exitosa la ejecución de un trabajo.
   --parallelism	El número de réplicas que se inician por ejecución de trabajo.
   --secrets	Los secretos que se usan para el trabajo.
   --env-vars	Las variables de entorno que se usan para el trabajo.
   --registry-server	El servidor de registro de contenedor que se usa para el trabajo. En el caso de una instancia de Azure Container Registry, el comando configura automáticamente la autenticación.

   Establecer la variable de entorno AZP_PLACEHOLDER configura el contenedor del agente para que se registre como un agente de marcador de posición sin conexión sin ejecutar un trabajo.

2. Ejecute el trabajo manual para crear el agente de marcador de posición.

   • Bash
   • PowerShell

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

3. Enumere las ejecuciones del trabajo para confirmar que se ha creado y completado correctamente una ejecución de trabajo.

   • 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. Compruebe que el agente de marcador de posición se creó en Azure DevOps.

   1. Ve a tu proyecto en Azure DevOps.
   2. Seleccione Configuración del proyecto>Grupos de agentes>container-apps>Agentes.
   3. Confirme que aparece un agente de marcador de posición denominado placeholder-agent y su estado es sin conexión.

5. No necesita el trabajo de nuevo. Puede eliminarla.

   • Bash
   • PowerShell

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

Crear un agente autohospedado como un trabajo controlado por un evento

Después de crear un agente de marcador de posición, puede crear un agente autohospedado. En esta sección, creará un trabajo controlado por un evento que ejecuta un agente autohospedado cuando se desencadena una canalización.

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"

En la tabla siguiente se describen los parámetros de regla de escalado usados en el comando.

La configuración de la regla de escalado define el origen del evento que se supervisa. Las reglas se evalúan en cada intervalo de sondeo para determinar cuántas ejecuciones de trabajos deben desencadenarse. Para obtener más información, consulte Establecimiento de reglas de escalado.

El trabajo controlado por eventos ahora se crea en el entorno de Container Apps.

Ejecutar una canalización y comprobar el trabajo

Después de configurar un trabajo de agente autohospedado, ejecute una canalización para comprobar que funciona correctamente.

1. En el panel de navegación izquierdo del proyecto de Azure DevOps, vaya a Canalizaciones.

2. Seleccione Crear canalización.

3. Seleccione Git de Azure Repos como ubicación del código.

4. Seleccione el repositorio que ha creado anteriormente.

5. Seleccione Canalización de inicio.

6. En la canalización YAML, cambie el pool de vmImage: ubuntu-latest a name: container-apps.

   pool:
     name: container-apps
   

7. Seleccione Guardar y ejecutar.

   La canalización se ejecuta y usa el trabajo del agente autohospedado que creó en el entorno de Container Apps.

8. Enumere las ejecuciones del trabajo para confirmar que se ha creado y completado correctamente una ejecución de trabajo.

   • 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}'