Construa pipelines do Azure DevOps do mundo real para modelos ARM

Tutoriais
DevOps

Quando você pesquisa online, encontrará vários posts de blog, documentações e tutoriais sobre o Azure DevOps. Todos esses itens são recursos valiosos, mas raramente alguém guia você por um cenário do mundo real. Muitos passam por cima do aspecto de segurança, deixando senhas em texto claro para simplificar ou resultando em um produto final que basicamente não faz nada. Vamos mudar isso.

Neste artigo/tutorial, você vai aprender do início ao fim como construir um pipeline de lançamento do Azure DevOps que automatiza a infraestrutura. Mais especificamente, você vai aprender como usar o Azure DevOps para construir um pipeline de implantação contínua para provisionar máquinas virtuais Azure.

Até o final deste projeto, você terá um pipeline Azure totalmente funcional. A partir de um único commit em um repositório do GitHub, ele:

  • Criará um grupo de recursos temporário do Azure
  • Provisionará uma VM do Azure via um modelo ARM
  • Configurará o referido modelo ARM em um pipeline CI/CD
  • Ao qualquer alteração no modelo, iniciará um teste de validação do modelo
  • Implantará o modelo ARM no Azure
  • Testará a infraestrutura implantada
  • Desmontará todos os recursos do Azure

Vamos começar!

Visão geral do projeto

Este projeto será dividido em seis seções principais. Elas são:

Preparação de recursos do Azure

Nesta seção, você aprenderá como configurar todos os recursos necessários no Azure. Aqui você vai:

  • Crie um principal de serviço do Azure para várias tarefas no pipeline
  • Configure um Azure Key Vault com segredos para o pipeline usar
  • Defina políticas de acesso apropriadas para implantações do ARM e uso do pipeline

Preparação do Azure DevOps

Depois de ter todos os recursos do Azure configurados, é hora de preparar o Azure DevOps para o seu pipeline. Nesta seção, você irá:

Visão geral do script/modelo

Há vários artefatos associados a este projeto, incluindo o modelo ARM para construir o servidor e os testes Pester. Nesta seção, abordaremos brevemente o que o modelo está provisionando e exatamente o que o Pester está testando no pipeline.

Criação do Pipeline

Nesta seção é onde a diversão real começa. Você começará a configurar o pipeline real. Aqui você aprenderá a configurar toda essa orquestração por meio de um único arquivo YAML.

Você estará construindo o pipeline usando a Experiência de Interface do Usuário do Pipeline de Vários Estágios. Até o momento desta redação, este recurso está em Preview.

Demonstração do Pipeline

Assim que o pipeline estiver construído, você precisa vê-lo em ação! Nesta seção, você aprenderá como acionar o pipeline e simplesmente observar a mágica acontecer.

Limpeza

E, finalmente, como isso é apenas uma demonstração, você terá acesso a um script para desfazer tudo construído durante o tutorial.

Parece muito? É! Mas não se preocupe, você aprenderá passo a passo, abordando cada tarefa uma de cada vez.

Se você deseja um script com todos os comandos Azure CLI usados para construir este pipeline, pode encontrá-lo no repositório GitHub ServerAutomationDemo como demo.ps1.

Pré-requisitos

Você vai aprender muito, mas também é esperado que traga algumas coisas para a mesa. Se planeja acompanhar, certifique-se de ter o seguinte:

ARM deployments allowed to access the key vault
  • Cloud Shell ou PowerShell 6+ se estiver executando localmente – Os exemplos podem funcionar no Windows PowerShell, mas não foram testados. Todos os exemplos serão executados localmente por meio de um console PowerShell, mas o Cloud Shell também funcionará igualmente bem. Você automatizará a construção do pipeline.
  • Azure CLI instalado (se estiver executando localmente) – Você aprenderá a realizar tarefas neste artigo com o Azure CLI. No entanto, os mesmos procedimentos também podem ser realizados por meio do Portal do Azure, PowerShell ou Azure SDK.

Aviso: As ações que você está prestes a realizar têm custos reais, a menos que você tenha algum crédito Azure. Os recursos mais intensivos em custos que você vai implantar no Azure são uma VM, mas apenas temporariamente.

Antes de começar

Você vai fazer muitas configurações neste tutorial. Antes de começar, certifique-se de ter os seguintes itens à mão.

  • O nome da assinatura Azure para a qual os recursos serão implantados – os exemplos usarão Adam the Automator.
  • O ID da assinatura
  • O ID do locatário do Azure AD
  • O nome da organização do DevOps – os exemplos usarão adbertram.
  • A região onde você está colocando os recursos – os exemplos usarão eastus.
  • O nome do grupo de recursos do Azure para colocar o cofre de chaves temporário – os exemplos usarão ServerAutomationDemo.
  • A password to assign to the local administrator account on a deployed VM – the examples will use “I like azure.”.
  • A URL do repositório do GitHub – os exemplos usarão https://github.com/adbertram/ServerAutomationDemo.

Fazendo login com o Azure CLI

Esteja preparado para fazer muito trabalho com o Azure CLI no artigo. Eu adoro os cmdlets do Azure PowerShell, mas o Azure CLI é atualmente capaz de realizar mais tarefas de DevOps.

Sua primeira tarefa é chegar a um console do PowerShell 6+. Uma vez no console, autentique-se no Azure usando o comando az login. Este comando abrirá uma janela do navegador e solicitará suas credenciais.

Depois de autenticado, certifique-se de definir sua assinatura como padrão. Definir como padrão evitará que você tenha que especificá-la constantemente.

az login
az account set --subscription 'Adam the Automator'

Preparando Recursos do Azure

Depois de fazer login com o Azure CLI, é hora de começar a trabalhar. Um Pipeline do Azure tem muitas dependências diferentes e vários ajustes para fazer. Nesta primeira seção, você aprenderá como fazer algumas configurações e preparar seu ambiente para o pipeline.

Instalando a Extensão Azure CLI DevOps

Você precisará de um meio para construir os vários componentes do Azure DevOps com o Azure CLI. Por padrão, ele não inclui essa funcionalidade. Para gerenciar o Azure DevOps a partir do Azure CLI, você precisará instalar a extensão DevOps.

Felizmente, instalar a extensão é uma linha única, conforme mostrado abaixo. 

az extension add --name azure-devops

Depois que a extensão for instalada, defina sua organização como padrão para evitar especificá-la repetidamente. 

az devops configure --defaults organization=https://dev.azure.com/adbertram

Criando o Grupo de Recursos

Embora o pipeline vá criar um grupo de recursos temporário, você também deve criar um para quaisquer recursos implementados nesta demonstração. Mais especificamente, este grupo de recursos é onde você criará um Azure Key Vault. 

az group create --location "eastus" --name "ServerAutomationDemo"

Criando o Azure Service Principal

A próxima tarefa é criar um principal de serviço Azure. Você precisará de um principal de serviço Azure para autenticar no Azure Key Vault. Você também usará esse principal de serviço para autenticar uma conexão de serviço. Crie o principal de serviço tanto para o key vault quanto para a eventual implantação do ARM, conforme mostrado abaixo.

$spIdUri = "http://ServerAutomationDemo"
$sp = az ad sp create-for-rbac --name $spIdUri | ConvertFrom-Json

Neste ponto, seria uma boa ideia salvar o valor de $sp.appId em algum lugar. Quando você chegar a construir o pipeline mais tarde, você precisará disso!

Você notará alguns comandos PowerShell nos exemplos, por exemplo, ConvertFrom-Json. Como o Azure CLI retorna apenas strings JSON, é mais fácil referenciar propriedades se convertidas para um objeto PowerShell.

Construindo o Key Vault

O pipeline neste tutorial precisa referenciar algumas senhas. Em vez de armazenar senhas em texto claro, vamos fazer do jeito certo. Todas as informações sensíveis serão armazenadas em um Azure Key Vault.

Para criar o key vault, use o comando az keyvault create conforme mostrado abaixo. Este comando cria o key vault no grupo de recursos criado anteriormente. Observe também a opção enabled-for-template-deployment. Isso altera a política de acesso do key vault para permitir que a futura implantação do ARM acesse o key vault.

az keyvault create --location $region --name "ServerAutomationDemo-KV" --resource-group "ServerAutomationDemo" --enabled-for-template-deployment true
Allowing ARM to access the keyvault

Criando Segredos no Key Vault

Assim que o cofre de chaves for criado, é hora de criar os segredos. Para esta demonstração, crie dois segredos chamados ServerAutomationDemo-AppPw e StandardVmAdminPassword. A senha AppPw é a senha para o principal do serviço. A senha da VM será atribuída à conta de administrador local na VM implantada.

az keyvault secret set --name "ServerAutomationDemo-AppPw" --value $sp.password --vault-name "ServerAutomationDemo-KV"
az keyvault secret set --name StandardVmAdminPassword --value "I like azure." --vault-name "ServerAutomationDemo-KV"

Observe que você está usando variáveis do PowerShell definidas anteriormente neste exemplo. Aqui você está fornecendo a senha do principal do serviço ($sp.password) obtida anteriormente.

Permitindo o Pipeline Acessar o Cofre de Chaves

Em seguida, o pipeline precisa de permissão para acessar o cofre de chaves. Relaxe um pouco a política de acesso ao cofre de chaves. Forneça ao principal do serviço criado permissões para obter e listar segredos do cofre de chaves.

az keyvault set-policy --name "ServerAutomationDemo-KV" --spn $spIdUri --secret-permissions get list

Preparando o Azure DevOps

Agora você concluiu toda a preparação de recursos do Azure. É hora de fazer algum trabalho de preparação no Azure DevOps.

Instalando a Extensão Pester

A primeira tarefa a ser realizada é instalar a extensão PesterRunner do Azure DevOps. O pipeline vai executar dois conjuntos de testes Pester para garantir que a implantação da ARM da VM tenha sido bem-sucedida. Uma das maneiras mais fáceis de executar testes Pester é com a extensão PesterRunner.

Instale a extensão usando o comando abaixo.

az devops extension install --extension-id PesterRunner --publisher-id Pester

Criando o Projeto Azure DevOps

É hora de criar o projeto no qual o pipeline será configurado. Criar um pipeline do Azure DevOps é fácil com o Azure CLI. Basta executar os comandos abaixo para criar o projeto e definir o projeto como padrão.

az devops project create --name "ServerAutomationDemo"
az devops configure --defaults project=ServerAutomationDemo

Criando as Conexões de Serviço

Seu pipeline precisa autenticar dois serviços – ARM e seu repositório GitHub. Para fazer isso, duas conexões de serviço devem ser criadas.

Primeiro, crie o ponto de extremidade de serviço ARM. O comando abaixo solicitará a senha do principal de serviço. Certifique-se de exibi-la primeiro no console e copie-a para a área de transferência.

Preencha o ID da assinatura, o ID do locatário e substitua o nome da assinatura abaixo.

## Execute $sp.password e copie para a área de transferência
$sp.Password

## Crie o ponto de extremidade de serviço
az devops service-endpoint azurerm create --azure-rm-service-principal-id $sp.appId --azure-rm-subscription-id "YOURSUBSCRIPTIONIDHERE" --azure-rm-subscription-name 'Adam the Automator' --azure-rm-tenant-id $tenantId --name 'ARM'

Em seguida, crie uma conexão de serviço para o GitHub. Como o pipeline será acionado por um commit do Git, ele precisará poder ler o repositório.

Neste ponto, é onde o token de acesso pessoal do GitHub se torna útil. Abaixo, você também precisará colar a senha do principal de serviço novamente. Você está usando o mesmo principal de serviço para ambas as conexões de serviço.

$gitHubServiceEndpoint = az devops service-endpoint github create --github-url 'https://github.com/adbertram/ServerAutomationDemo' --name 'GitHub' | ConvertFrom-Json

## Cole o token do GitHub quando solicitado

Criando o Grupo de Variáveis

O pipeline fará referência a segredos do cofre de chaves para duas senhas. Para fazer isso de forma segura, você deve criar um grupo de variáveis e vinculá-lo ao cofre de chaves.

Primeiro, crie o grupo de variáveis conforme mostrado abaixo.

az pipelines variable-group create --name "ServerAutomationDemo" --authorize true --variables foo=bar

Observe a variável foo=bar? Isso não é usado, mas uma única variável é necessária para criar o grupo de variáveis.

Vinculando o Grupo de Variáveis a um Cofre de Chaves

Neste ponto, infelizmente, você terá que ir para o portal do Azure DevOps. No momento em que este texto foi escrito, o Azure CLI não tem como vincular um cofre de chaves a um grupo de variáveis.

Navegue até o projeto do Azure DevOps e clique em Biblioteca. Você deve então ver o grupo de variáveis ServerAutomationDemo como mostrado abaixo. Clique no grupo de variáveis ServerAutomationDemo.

Available variable group

Uma vez no grupo de variáveis, clique em Vincular segredos de um cofre de chaves do Azure como variáveis. Quando fizer isso, você será avisado de que apagará todas as variáveis e clique em Confirmar. Você verá como fazer isso abaixo. Essa ação é aceitável, já que a variável foo era temporária desde o início.

Linking variable group to pipeline

Uma vez confirmado, selecione a conexão de serviço ARM e o cofre de chaves ServerAutomationDemo-KV criado anteriormente como mostrado abaixo. Clique em Adicionar.

Setting the service connection

Agora marque ambos os segredos criados anteriormente como mostrado abaixo e clique em OK e Salvar para salvar as alterações.

Selecting keyvault secrets for the pipeline to use

Visão Geral dos Arquivos do Projeto

Se você chegou até aqui, parabéns! Agora você está pronto para começar a construir o pipeline. Mas espere… há mais!

Para tornar a criação de um Azure Pipeline mais realista, este tutorial constrói um pipeline completo com testes “unitários” e “de aceitação”. Isso torna o tutorial mais interessante, mas também justifica alguma explicação adicional sobre o que está acontecendo.

No repositório do GitHub para este tutorial, você encontrará alguns arquivos, conforme mostrado abaixo. Agora seria um bom momento para clonar este repositório ou construir o seu próprio a partir dos arquivos.

GitHub files list
  • azure-pipelines.yml – O pipeline YAML final
  • connect-azure.ps1 – Script PowerShell para autenticar em uma assinatura do Azure
  • server.infrastructure.tests.ps1 – Um teste Pester simples para confirmar que a configuração da VM está boa
  • server.json – Um modelo ARM do Azure para provisionar uma VM
  • server.parameters.json – Um modelo de parâmetros ARM do Azure que fornece valores de parâmetros para o modelo ARM.

Certifique-se de substituir o ID da sua assinatura e o nome do cofre de chaves para o cofre de chaves IT no arquivo server.parameters.json.

  • server.templates.tests.ps1 – Testes “unitários” Pester para confirmar que o modelo ARM é válido

Você verá como cada um desses arquivos se encaixa no pipeline em breve.

Criando o Pipeline

Assumindo que você clonou meu repositório no GitHub ou configurou um por conta própria, é hora de criar o pipeline! Para fazer isso, execute o comando az pipelines create. O comando abaixo cria um pipeline chamado ServerAutomationDemo usando o repositório do GitHub fornecido como acionador. Ele irá observar o branch master e usar a conexão de serviço construída anteriormente.

az pipelines create --name "ServerAutomationDemo" --repository "https://github.com/adbertram/ServerAutomationDemo" --branch master --service-connection $gitHubServiceEndpoint.id --skip-run

Dependendo se você tem o arquivo azure-pipelines.yml em seu repositório do GitHub, você pode ou não receber feedback como abaixo. De qualquer forma, seu console terá uma aparência semelhante. Certifique-se de ter seu token de acesso pessoal do GitHub pronto!

Creating the Azure DevOps pipeline with the Azure CLI

Revisão do Pipeline YAML

Neste ponto, seu pipeline está pronto para ser executado, mas é importante primeiro entender o pipeline YAML. Dê uma olhada no arquivo azure-pipelines.yml. Este arquivo é o pipeline ao usar o recurso de pipeline YAML de vários estágios.

Vamos analisar os vários componentes que compõem este pipeline YAML.

O Acionador

Como você está construindo um pipeline CI que é executado automaticamente, você precisa de um acionador. O acionador abaixo instrui o pipeline a ser executado quando uma confirmação é detectada no branch master do Git.

Observe também a seção de paths. Por padrão, se você não incluir ou excluir especificamente arquivos ou diretórios em uma compilação CI, o pipeline será executado quando uma confirmação for feita em qualquer arquivo. Como este projeto é todo construído em torno de um modelo ARM, você não quer executar o pipeline se, por exemplo, fez um ajuste em um teste Pester.

trigger:
  branches:
    include:
      - master
  paths:
    include:
      - server.json
      - server.parameters.json

O Pool

Cada compilação precisa de um agente. Cada agente de compilação precisa ser executado em uma VM. Neste caso, a VM está usando a imagem da VM ubuntu-latest. Esta imagem é a imagem padrão que foi definida quando a compilação foi originalmente criada. Não foi alterada devido à “simplicidade” deste pipeline.

pool:
  vmImage: "ubuntu-latest"

Variáveis

Em seguida, temos todas as variáveis e o grupo de variáveis. As várias tarefas neste pipeline requerem a leitura de valores como o ID da assinatura do Azure, ID do locatário e o ID do aplicativo para o principal de serviço e assim por diante. Em vez de replicar valores estáticos em cada tarefa, eles são definidos como variáveis.

Observe também o elemento group. Este elemento está fazendo referência ao grupo de variáveis que você criou anteriormente. Certifique-se de substituir o subscription_id e o tenant_id neste momento.

Lembre-se de que na seção Criando o Principal de Serviço do Azure você foi lembrado de salvar o valor de $sp.appId em algum lugar? Aqui é onde você vai precisar dele. Atribua o valor desse ID de aplicativo principal de serviço para application_id conforme mostrado abaixo.

variables:
    - group: ServerAutomationDemo
    - name: azure_resource_group_name
      value: "ServerProvisionTesting-$(Build.BuildId)"
    - name: subscription_id
      value: "XXXXXXXXXXXXX"
    - name: application_id
      value: "XXXXXXXXXXXXX"
    - name: tenant_id
      value: "XXXXXXXXXXXX"

Observe o valor da variável azure_resource_group_name. Dentro desse valor, você verá $(Build.BuildId). Esta é uma variável do sistema que representa o ID da compilação do trabalho atual. Neste contexto, está sendo usada para garantir que o grupo de recursos temporário criado seja único.

Tarefas de Preparação do PowerShell

O próximo conjunto de tarefas invoca código PowerShell. Este exemplo de pipeline usa o PowerShell para criar e remover um grupo de recursos temporário para fins de teste. Nessas tarefas de implantação, você verá dois exemplos de invocação de código PowerShell.

A primeira tarefa invoca um script chamado connect-azure.ps1 que existe no repositório do GitHub. Essa tarefa autentica na assinatura Azure para a execução posterior dos comandos do Azure PowerShell.

Esta tarefa de conexão do Azure PowerShell está chamando o script e passando um valor de segredo do key vault (ServerAutomationDemo-AppPw) e as variáveis do pipeline subscription_id, application_id e tenant_id.

A segunda tarefa está executando código PowerShell em linha, ou seja, um script não existe previamente. Em vez disso, o código PowerShell é definido no próprio YAML do pipeline usando o valor da variável do pipeline azure_resource_group_name.

- task: PowerShell@2
  inputs:
    filePath: "connect-azure.ps1"
    arguments: '-ServicePrincipalPassword "$(ServerAutomationDemo-AppPw)" -SubscriptionId $(subscription_id) -ApplicationId $(application_id) -TenantId $(tenant_id)'
- task: PowerShell@2
  inputs:
    targetType: "inline"
    script: New-AzResourceGroup -Name $(azure_resource_group_name) -Location eastus -Force

Teste de Modelo Pester

A seguir, temos o primeiro teste Pester. Em um pipeline CI/CD como este, é importante ter várias camadas de testes diferentes. Se estivesse criando um pipeline para um projeto de software, poderia criar vários testes unitários.

Desde que este exemplo de pipeline é construído em torno de uma única implantação de VM ARM, os primeiros testes “unitários” serão para testar a validade do modelo JSON. Dentro do arquivo server.templates.tests.ps1 é onde você pode adicionar quantos testes diferentes no próprio arquivo de modelo ARM desejar.

Observe abaixo que o pipeline está utilizando várias variáveis de sistema. Essas variáveis estão fazendo referência à localização do arquivo uma vez que eles chegam no agente de compilação.

A tarefa PesterRunner está enviando os resultados dos testes para um arquivo XML que será lido posteriormente no pipeline.

- task: Pester@0
  inputs:
    scriptFolder: "@{Path='$(System.DefaultWorkingDirectory)/server.template.tests.ps1'; Parameters=@{ResourceGroupName='$(azure_resource_group_name)'}}"
    resultsFile: "$(System.DefaultWorkingDirectory)/server.template.tests.XML"
    usePSCore: true
    run32Bit: False

A Implantação de VM ARM

Agora chegamos à implantação ARM. Como todo o pipeline é construído em torno da capacidade de implantar uma VM, esta é importante! Esta tarefa realiza a implantação do modelo ARM fornecendo todos os atributos necessários para que isso aconteça.

Observe o atributo deploymentOutputs: arm_output. No próximo passo, uma tarefa precisa se conectar à VM que foi implantada. Uma ótima maneira de obter o nome DNS ou o endereço IP desta VM é retorná-lo via implantação ARM. A opção deploymentOutputs cria uma variável de pipeline que pode ser referenciada em outras tarefas.

- task: AzureResourceManagerTemplateDeployment@3
  inputs:
    deploymentScope: "Resource Group"
    azureResourceManagerConnection: "ARM"
    subscriptionId: "1427e7fb-a488-4ec5-be44-30ac10ca2e95"
    action: "Create Or Update Resource Group"
    resourceGroupName: $(azure_resource_group_name)
    location: "East US"
    templateLocation: "Linked artifact"
    csmFile: "server.json"
    csmParametersFile: "server.parameters.json"
    deploymentMode: "Incremental"
    deploymentOutputs: "arm_output"

Teste de “Aceitação” do Pester

Depois que a VM foi implantada, você precisa garantir que ela tenha sido implantada corretamente com um teste de “integração” ou “aceitação”. Esta tarefa PesterRunner está invocando o Pester e executando outro conjunto de testes relacionados à infraestrutura para garantir que a VM tenha sido implantada com sucesso.

Observe que estamos passando o valor de saída da implantação do ARM por meio do parâmetro ArmDeploymentJsonOutput. O arquivo de script de teste do Pester tem um parâmetro definido que recebe o valor e lê o nome do host DNS da VM.

 - task: Pester@0
    inputs:
      scriptFolder: "@{Path='$(System.DefaultWorkingDirectory)/server.infrastructure.tests.ps1'; Parameters=@{ArmDeploymentJsonOutput='$(arm_output)'}}"
      resultsFile: "$(System.DefaultWorkingDirectory)/server.infrastructure.tests.XML"
      usePSCore: true
      run32Bit: False

Você pode ver abaixo como é o script PowerShell server.infrastructure.tests.ps1. Observe que ele está lendo o nome do host DNS da VM para executar uma verificação simples de porta aberta.

$ArmDeploymentOutput = $ArmDeploymentJsonOutput | convertfrom-json

## Executar os testes
describe 'Network Connnectivity' {
    it 'the VM has RDP/3389 open' {
        Test-Connection -TCPPort 3389 -TargetName $ArmDeploymentOutput.hostname.value -Quiet | should -Be $true
    }
}

“Acceptance” Limpeza dos testes

O único motivo pelo qual o pipeline implantou qualquer infraestrutura foi para testar a validade do modelo do ARM. Como essa infraestrutura é apenas temporária, ela precisa ser limpa. Na última tarefa do PowerShell, o pipeline está removendo o grupo de recursos criado anteriormente e tudo o que está nele.

- task: PowerShell@2
  inputs:
    targetType: "inline"
    script: Get-AzResourceGroup -Name $(azure_resource_group_name) | Remove-AzResourceGroup -Force

Publicação dos Testes do Pester

E finalmente, chegamos ao último conjunto de tarefas. O Azure Pipelines tem uma tarefa chamada Publicar Resultados dos Testes. Essa tarefa lê um arquivo XML no agente de build e exibe os resultados dos testes no Azure DevOps. Esta é uma maneira prática de visualizar facilmente os resultados de todos os testes executados.

- task: PublishTestResults@2
  inputs:
    testResultsFormat: "NUnit"
    testResultsFiles: "$(System.DefaultWorkingDirectory)/server.infrastructure.tests.XML"
    failTaskOnFailedTests: true

- task: PublishTestResults@2
  inputs:
    testResultsFormat: "NUnit"
    testResultsFiles: "$(System.DefaultWorkingDirectory)/server.template.tests.XML"
    failTaskOnFailedTests: true
The Tests section of a pipeline run

Usando o Pipeline do Azure DevOps

Por fim, estamos prontos para executar o pipeline e ver como ele funciona. Na interface do usuário do Azure DevOps, certifique-se de estar no projeto ServerAutomationDemo. Uma vez aqui, clique em Pipelines e então você deverá ver o pipeline ServerAutomationDemo.

Uma maneira de executar o pipeline é clicar nos três pontos à direita, conforme mostrado abaixo. Em seguida, clique em Executar pipeline. Isso iniciará a automação.

Running a pipeline

O pipeline seguirá adiante e executará cada tarefa conforme instruído. No final, você deverá ver todos os marcadores de seleção verde para cada tarefa realizada pelo trabalho, conforme mostrado abaixo.

Successful job task execution

Limpeza

Depois de ter mexido no pipeline e ter feito tudo o que foi realizado aqui, você deve limpar as coisas. Afinal, isso foi apenas destinado a ser um tutorial e não uma tarefa de produção!

Abaixo, você encontrará alguns comandos para limpar tudo o que foi construído neste artigo. Este código remove o principal de serviço, a aplicação Azure AD, o grupo de recursos e tudo o que estiver dentro dele e o projeto Azure DevOps.

$spId = ((az ad sp list --all | ConvertFrom-Json) | ? { '<https://ServerAutomationDemo>' -in $_.serviceprincipalnames }).objectId
az ad sp delete --id $spId

## Remover o grupo de recursos
az group delete --name "ServerAutomationDemo" --yes --no-wait

## remover projeto
$projectId = ((az devops project list | convertfrom-json).value | where { $_.name -eq 'ServerAutomationDemo' }).id
az devops project delete --id $projectId --yes

Sumário

Este tutorial tinha como objetivo oferecer-lhe um vislumbre sobre a construção de um verdadeiro pipeline de automação de infraestrutura Azure DevOps. Mesmo que existam inúmeras outras maneiras de construir pipelines como este, as habilidades que você aprendeu neste tutorial devem ajudá-lo em muitas configurações diferentes.

Agora saia e comece a automatizar mais!

Source:
https://adamtheautomator.com/azure-devops/