Tutorial: Implantar executores e agentes de CI/CD auto-hospedados com tarefas de Aplicações de Contentor do Azure

Neste tutorial, você aprenderá a executar executores de Ações do GitHub como um trabalho de Aplicativos de Contêiner orientado a eventos.

Neste tutorial, você aprenderá a executar agentes do Azure Pipelines como um trabalho de Aplicativos de Contêiner controlado por eventos.

• Organização de DevOps do Azure: se você não tiver uma organização de DevOps com uma assinatura ativa, poderá criar uma gratuitamente.

Criar um repositório GitHub para executar um fluxo de trabalho

Para executar um fluxo de trabalho, precisa de criar um repositório no GitHub que contenha a definição do fluxo de trabalho.

1. Vai ao GitHub e inicia sessão.

2. Crie um novo repositório inserindo os seguintes valores.

   Configurações	Valor
   Proprietário	Selecione seu nome de usuário do GitHub.
   Nome do repositório	Insira um nome para o repositório.
   Visibilidade	Selecione Privado.
   Inicialize este repositório com	Selecione Adicionar um ficheiro LEIA-ME.

   Use os valores padrão para as outras definições.

3. Selecione Criar repositório.

4. No novo repositório, selecione Ações.

5. Procure o modelo de fluxo de trabalho simples e selecione Configurar.

6. Selecione Confirmar alterações para adicionar o fluxo de trabalho ao repositório.

O fluxo de trabalho é executado no runner hospedado no ubuntu-latest GitHub e imprime uma mensagem no terminal. Mais tarde, você substitui o corredor hospedado no GitHub por um corredor auto-hospedado.

Obter um token de acesso pessoal do GitHub

Para executar um corredor auto-hospedado, você precisa criar um token de acesso pessoal (PAT) no GitHub. Cada vez que um runner inicia, o PAT gera um token para registar o runner no GitHub. A regra de escala do runner Actions do GitHub usa o PAT para monitorizar a fila de workflow do repositório e iniciar os runners conforme necessário.

1. No GitHub, selecione sua foto de perfil no canto superior direito e selecione Configurações.

2. Selecione Configurações do desenvolvedor.

3. Em Tokens de acesso pessoal, selecione Tokens de grão fino.

4. Selecione Gerar novo token.

5. Na tela Novo token de acesso pessoal refinado , insira os seguintes valores.

   Configurações	Valor
   Nome do token	Insira um nome para o seu token.
   Expiração	Selecione 30 dias.
   Acesso ao repositório	Selecione Somente repositórios e selecione o repositório que você criou.

   Insira os seguintes valores para permissões de repositório.

   Configurações	Valor
   Ações	Selecione Somente leitura.
   Administração	Selecione Ler e escrever.
   Metadados	Selecione Somente leitura.

6. Selecione Gerar token.

7. Copie o valor do token.

8. Define variáveis que usas para configurar o runner e a regra de escala mais tarde.

   • Bash
   • PowerShell

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

   Substitua os marcadores de posição pelos seguintes valores:

   Marcador de posição	Valor
   <GITHUB_PAT>	O PAT do GitHub que tu geraste.
   <REPO_OWNER>	O proprietário do repositório criado anteriormente. Esse valor geralmente é seu nome de usuário do GitHub.
   <REPO_NAME>	O nome do repositório criado anteriormente. Esse valor é o mesmo nome que você inseriu no campo Nome do repositório .
   <YOUR_REGISTRATION_TOKEN_API_URL>	A URL da API do token de registro no arquivo entrypoint.sh . Por exemplo, 'https://myapi.example.com/get-token'

Criar a imagem do contentor do runner do GitHub Actions

Para criar um corredor auto-hospedado, você precisa criar uma imagem de contêiner que execute o corredor. Nesta secção, cria-se a imagem de contêiner e carrega-se para um registo de contêineres.

1. Defina um nome para a imagem do contêiner e o registro.

   • Bash
   • PowerShell

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

   Substitua <CONTAINER_REGISTRY_NAME> por um nome exclusivo para criar um registro de contêiner. Os nomes do Registro de contêiner devem ser exclusivos no Azure e ter de 5 a 50 caracteres de comprimento, contendo apenas números e letras minúsculas.

2. Crie um registro de contêiner.

   • Bash
   • PowerShell

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

3. O seu registo de contentores deve permitir que tokens de audiência do Azure Resource Manager (ARM) usem identidade gerida para autenticação a fim de extrair imagens.

   Use o comando a seguir para verificar se os tokens ARM têm permissão para acessar seu Registro de Contêiner do Azure (ACR).

   • Bash
   • PowerShell

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

   Se os tokens ARM forem permitidos, o comando produzirá o seguinte.

   {
     "status": "enabled"
   }
   

   Se for statusdisabled, use o seguinte comando para permitir tokens ARM.

   • Bash
   • PowerShell

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

4. O Dockerfile para criar a imagem do runner está disponível no GitHub. Execute o seguinte comando para clonar o repositório e construir a imagem do contentor na cloud usando o 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"
   

   A imagem agora está disponível no registro do contêiner.

Criar uma identidade gerenciada atribuída pelo usuário

Para evitar o uso de credenciais administrativas, extraia imagens de repositórios privados no Microsoft Azure Container Registry utilizando identidades geridas para autenticação. Sempre que possível, use uma identidade gerenciada atribuída pelo usuário para extrair imagens.

1. Crie uma identidade gerida atribuída pelo utilizador. Antes de executar os comandos a seguir, escolha um nome para sua identidade gerenciada e substitua o \<PLACEHOLDER\> pelo nome.

   • Bash
   • PowerShell

   IDENTITY="<YOUR_IDENTITY_NAME>"
   

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

2. Obtenha o ID de recurso da identidade.

   • Bash
   • PowerShell

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

Implantar um corredor auto-hospedado como um trabalho

Agora você pode criar um trabalho que usa a imagem do contêiner. Nesta secção, cria um trabalho que executa o executor auto-hospedado e autentica com o GitHub usando o PAT que gerou anteriormente. A tarefa usa a github-runner regra de escala para criar execuções de tarefa com base no número de fluxos de trabalho pendentes.

1. Crie um trabalho no ambiente 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"
   

   A tabela a seguir descreve os principais parâmetros usados no comando.

   Parâmetro	Descrição
   --replica-timeout	A duração máxima que uma réplica pode executar.
   --replica-retry-limit	O número de vezes para repetir uma réplica que falhou.
   --replica-completion-count	O número de réplicas que devem ser concluídas com sucesso antes da execução de um trabalho ser considerada bem-sucedida.
   --parallelism	O número de réplicas a serem iniciadas por execução de trabalho.
   --min-executions	O número mínimo de execuções de trabalho a serem executadas por intervalo de sondagem.
   --max-executions	O número máximo de execuções de trabalho a serem executadas por intervalo de sondagem.
   --polling-interval	O intervalo de sondagem no qual se avalia a regra de escala.
   --scale-rule-name	O nome da regra de escala.
   --scale-rule-type	O tipo de regra de escala a ser usada. Para saber mais sobre o escalador de corredores do GitHub, consulte a documentação do KEDA.
   --scale-rule-metadata	Os metadados para a regra de escala. Se você estiver usando o GitHub Enterprise, atualize githubAPIURL com sua URL de API.
   --scale-rule-auth	A autenticação para a regra de escala.
   --secrets	Os segredos para usar no trabalho.
   --env-vars	As variáveis de ambiente a serem usadas para o trabalho.
   --registry-server	O servidor de registro de contêiner a ser usado para o trabalho. Para um Registro de Contêiner do Azure, o comando configura automaticamente a autenticação.
   --mi-user-assigned	O ID do recurso da identidade gerida atribuída pelo utilizador a ser associada à tarefa.
   --registry-identity	A ID de recurso de uma identidade gerenciada para autenticar com o servidor de registro em vez de usar um nome de usuário e senha. Se possível, uma atribuição de função 'acrpull' é criada para a identidade automaticamente.

   A configuração da regra de escala define a origem do evento a ser monitorada. As regras são avaliadas em cada intervalo de sondagem para determinar quantas execuções de trabalho devem ser acionadas. Para mais informações, veja Definir regras de escalabilidade.

O trabalho controlado por eventos agora é criado no ambiente Container Apps.

Executar um fluxo de trabalho e verificar o trabalho

O trabalho é configurado para avaliar a regra de escala a cada 30 segundos. Durante cada avaliação, verifica o número de execuções de workflows pendentes que requerem um executor auto-hospedado e inicia uma nova execução de tarefa para cada workflow pendente, até um máximo configurado de 10 execuções.

Para verificar a configuração do trabalho, modifique o fluxo de trabalho para usar um runner auto-hospedado e desencadeie uma execução do fluxo de trabalho. Em seguida, você pode exibir os logs de execução do trabalho para ver o fluxo de trabalho executado.

1. No repositório do GitHub, vai ao fluxo de trabalho que geraste anteriormente. É um arquivo YAML no .github/workflows diretório.

2. Selecione Editar no local.

3. Atualize a runs-on propriedade para self-hosted:

   runs-on: self-hosted
   

4. Selecione Confirmar alterações....

5. Selecione Confirmar alterações.

6. Vai ao separador Ações .

   Um novo fluxo de trabalho está agora na fila. Em 30 segundos, a execução do trabalho começa e o fluxo de trabalho termina pouco depois.

   Aguarde a conclusão da ação antes de avançar para a próxima etapa.

7. Liste as execuções do trabalho para confirmar que uma execução foi criada e concluída com êxito.

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

Criar um projeto e repositório do Azure DevOps

Para correr um pipeline, precisas de um projeto e repositório Azure DevOps.

1. Vai ao Azure DevOps e inicia sessão na tua conta.

2. Selecione uma organização existente ou crie uma nova.

3. Na página de visão geral da organização, selecione Novo projeto e insira os seguintes valores.

   Configurações	Valor
   Nome do projeto	Insira um nome para o seu projeto.
   Visibilidade	Selecione Privado.

4. Selecione Criar.

5. Na navegação lateral, selecione Repos.

6. Em Inicializar a ramificação principal com um README ou .gitignore, selecione Adicionar um README.

7. Mantém os valores predefinidos para o resto das definições e seleciona Inicializar.

Criar um novo pool de agentes

Crie um novo pool de agentes para executar o corredor auto-hospedado.

1. Em seu projeto do Azure DevOps, expanda a barra de navegação esquerda e selecione Configurações do projeto.

   

2. Na seção Pipelines no menu de navegação Configurações do projeto , selecione Pools de agentes.

   

3. Selecione Adicionar pool e insira os seguintes valores.

   Configurações	Valor
   Pool para vincular	Selecione Novo.
   Tipo de piscina	Selecione Servidor próprio.
   Nome	Insira container-apps.
   Conceder permissão de acesso a todos os pipelines	Marque essa caixa de seleção.

4. Selecione Criar.

Obter um token de acesso pessoal do Azure DevOps

Para executar um corredor auto-hospedado, você precisa criar um token de acesso pessoal (PAT) no Azure DevOps. Use o PAT para autenticar o agente executor com Azure DevOps. A regra de escala também usa o token para controlar o número de execuções pendentes de pipeline e desencadear novas execuções de tarefas.

1. No Azure DevOps, selecione Configurações do usuário ao lado da sua foto de perfil no canto superior direito.

2. Selecione Tokens de acesso pessoal.

3. Na página Tokens de acesso pessoal , selecione Novo token e insira os seguintes valores.

   Configurações	Valor
   Nome	Insira um nome para o seu token.
   Organização	Selecione a organização escolhida ou criada anteriormente.
   Escopos	Selecione Definido pelo utilizador.
   Mostrar todos os escopos	Selecione Mostrar todos os escopos.
   Pools de agentes (visualizar e gerir)	Selecione Pools de agentes (Ler e gerenciar).

   Deixe todos os outros escopos desmarcados.

4. Selecione Criar.

5. Copie o valor do token para um local seguro.

   Não é possível recuperar o token depois de sair da página.

6. Define variáveis que usas para configurar os trabalhos das Aplicações Container mais tarde.

   • Bash
   • PowerShell

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

   Substitua os marcadores de posição pelos seguintes valores:

   Marcador de posição	Valor	Observações
   <AZP_TOKEN>	O PAT do Azure DevOps que geraste.
   <ORGANIZATION_URL>	A URL da sua organização do Azure DevOps. Certifique-se de que nenhum caractere / esteja presente no final do URL.	Por exemplo, https://dev.azure.com/myorg ou https://myorg.visualstudio.com.

Criar a imagem do contêiner do agente do Azure Pipelines

Para criar um agente auto-hospedado, você precisa criar uma imagem de contêiner que execute o agente. Nesta secção, cria-se a imagem de contêiner e carrega-se para um registo de contêineres.

1. De volta ao seu terminal, defina um nome para a imagem e o registro do contêiner.

   • Bash
   • PowerShell

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

   Substitua <CONTAINER_REGISTRY_NAME> por um nome exclusivo para criar um registro de contêiner.

   Os nomes do Registro de contêiner devem ser exclusivos no Azure e ter de 5 a 50 caracteres de comprimento, contendo apenas números e letras minúsculas.

2. Crie um registro de contêiner.

   • Bash
   • PowerShell

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

3. O Dockerfile para criar a imagem do runner está disponível no GitHub. Execute o seguinte comando para clonar o repositório e construir a imagem do contentor na cloud usando o 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"
   

   A imagem agora está disponível no registro do contêiner.

Criar um agente auto-hospedado provisório

Antes de poderes executar um agente autogerido no teu novo grupo de agentes, precisas de criar um agente temporário. O agente placeholder garante que o pool de agentes esteja disponível. Os pipelines que utilizam o pool de agentes falham quando não há nenhum agente substituto.

Você pode executar um trabalho manual para registrar um agente de espaço reservado offline. O trabalho é executado uma vez e podes apagá-lo. O agente de placeholder não consome recursos nos Azure Container Apps ou no Azure DevOps.

1. Crie um trabalho manual no ambiente do Container Apps que cria o agente substituto.

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

   A tabela a seguir descreve os principais parâmetros usados no comando.

   Parâmetro	Descrição
   --replica-timeout	A duração máxima que uma réplica pode executar.
   --replica-retry-limit	O número de vezes para repetir uma réplica que falhou.
   --replica-completion-count	O número de réplicas que devem ser concluídas com sucesso antes de a execução de um trabalho ser considerada bem-sucedida.
   --parallelism	O número de réplicas a serem iniciadas por execução de trabalho.
   --secrets	Os segredos para usar no trabalho.
   --env-vars	As variáveis de ambiente a serem usadas para o trabalho.
   --registry-server	O servidor de registro de contêiner a ser usado para o trabalho. Para um Registro de Contêiner do Azure, o comando configura automaticamente a autenticação.

   A definição da AZP_PLACEHOLDER variável de ambiente configura o container do agente para se registar como um agente temporário offline sem executar uma tarefa.

2. Executar o trabalho manual para criar o agente marcador de posição.

   • Bash
   • PowerShell

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

3. Liste as execuções do trabalho para confirmar que uma execução foi criada e concluída com êxito.

   • 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. Verifique se o agente de marcador de posição foi criado no Azure DevOps.

   1. No Azure DevOps, vá para o seu projeto.
   2. Selecione Configurações do projeto>Grupos de agentes>aplicativos de contêiner>Agentes.
   3. Confirme se um agente de espaço reservado chamado placeholder-agent está listado e se seu status está offline.

5. Não precisas do emprego outra vez. Poderá eliminá-la.

   • Bash
   • PowerShell

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

Criar um agente autogerido como uma tarefa orientada a eventos

Depois de criar um agente provisório, pode criar um agente auto-hospedado. Nesta seção, o utilizador cria uma tarefa orientada por eventos que executa um agente autogerido quando um pipeline é iniciado.

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"

A tabela a seguir descreve os parâmetros da regra de escala usados no comando.

A configuração da regra de escala define a origem do evento a ser monitorada. As regras são avaliadas em cada intervalo de sondagem para determinar quantas execuções de trabalho devem ser acionadas. Para mais informações, veja Definir regras de escalabilidade.

O trabalho controlado por eventos agora é criado no ambiente Container Apps.

Executar um pipeline e verificar a tarefa

Depois de configurares um job de agente auto-hospedado, executa um pipeline para verificar se funciona corretamente.

1. Na navegação à esquerda do seu projeto Azure DevOps, vá a Pipelines.

2. Selecione Criar pipeline.

3. Selecione Azure Repos Git como o local do seu código.

4. Selecione o repositório criado anteriormente.

5. Selecione pipeline inicial.

6. No pipeline YAML, altere o pool de vmImage: ubuntu-latest para name: container-apps.

   pool:
     name: container-apps
   

7. Selecione Guardar e executar.

   O pipeline é executado e usa o trabalho de agente auto-hospedado que você criou no ambiente de Aplicativos de Contêiner.

8. Liste as execuções do trabalho para confirmar que uma execução foi criada e concluída com êxito.

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