Construa pipelines do Azure DevOps do mundo real para modelos ARM

Tutoriais
DevOps

Quando você pesquisa online, encontrará vários posts de blog, documentação 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 simplicidade ou um produto final que essencialmente não faz nada. Vamos mudar isso.

Neste artigo/tutorial, você vai aprender passo a passo como construir um pipeline de release do real Azure DevOps que automatiza a infraestrutura. Mais especificamente, você aprenderá como usar o Azure DevOps para criar um pipeline de implantação contínua para provisionar máquinas virtuais do Azure.

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

  • Construirá um grupo de recursos temporário do Azure
  • Provisionará uma VM do Azure por meio de um modelo ARM
  • Configurará o mencionado modelo ARM em um pipeline CI/CD
  • Ao ocorrer qualquer alteração no modelo, iniciará um teste de validação do modelo
  • Implantará o modelo ARM no Azure
  • Testará a infraestrutura implantada
  • Derrubará todos os recursos do Azure

Vamos direto ao assunto!

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 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 ARM e uso do pipeline

Preparação do Azure DevOps

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

Visão geral do script/modelo

Existem 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 esta orquestração através de um único arquivo YAML.

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

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 o que foi construído durante o tutorial.

Parece muito? É! Mas não se preocupe, você aprenderá passo a passo, abordando cada tarefa 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 você traga algumas coisas para a mesa. Se você 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á muito bem. Você automatizará a construção do pipeline.
  • Azure CLI instalado (se estiver executando localmente) – Você aprenderá a executar tarefas neste artigo com o Azure CLI. No entanto, os mesmos procedimentos também podem ser executados por meio do Portal do Azure, PowerShell ou do Azure SDK.

Aviso: As ações que você está prestes a executar têm um custo real, a menos que você tenha algum crédito Azure. Os recursos que mais consomem custos que você 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, verifique se você tem os seguintes itens à mão.

  • O nome da assinatura do Azure em que 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 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 para o repositório do GitHub – os exemplos usarão https://github.com/adbertram/ServerAutomationDemo.

Entrando com o Azure CLI

Esteja preparado para fazer muito trabalho com o Azure CLI no artigo. Eu amo os cmdlets do Azure PowerShell, mas o Azure CLI atualmente é capaz de fazer 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. Defini-la como padrão evitará que você precise especificá-la constantemente.

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

Preparando Recursos do Azure

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

Instalando a Extensão do Azure CLI para o DevOps

Você precisará de uma maneira de construir os vários componentes do Azure DevOps com o Azure CLI. Por padrão, isso não está incluído. Para gerenciar o Azure DevOps a partir do Azure CLI, será necessário instalar a extensão DevOps.

Felizmente, a instalação da extensão é feita em uma única linha, como mostrado abaixo.

az extension add --name azure-devops

Depois de instalar a extensão, defina sua organização como padrão para evitar ter que 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 gerados 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 serviço principal no Azure. Você precisará de um serviço principal no Azure para autenticar no Azure Key Vault. Você também usará esse serviço principal para autenticar uma conexão de serviço. Crie o serviço principal 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 chegar à construção do pipeline mais tarde, você precisará disso!

Você notará alguns comandos PowerShell nos exemplos, como ConvertFrom-Json. Como o Azure CLI retorna apenas strings JSON, é mais fácil fazer referência a propriedades se convertidas em um objeto PowerShell.

Construindo o Key Vault

O pipeline neste tutorial precisa fazer referência a algumas senhas. Em vez de armazenar senhas em texto claro, vamos fazer da maneira correta. Todas as informações confidenciais serão armazenadas em um Azure Key Vault.

Para criar o key vault, use o comando az keyvault create conforme mostrado abaixo. Esse 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

Uma vez que o cofre de chaves é 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 previamente definidas 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 de obter e listar para gerenciar os 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 do Pester para garantir que o deployment ARM da VM tenha sido bem-sucedido. Uma das maneiras mais fáceis de executar testes do 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 em que o pipeline será desenvolvido. Criar um pipeline Azure DevOps é muito 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 para a área de transferência.

Não se esqueça de preencher seu ID de assinatura, ID de locatário e substituir 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 meio de um commit 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 novamente a senha do principal de serviço. 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 como mostrado abaixo.

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

Perceba a variável foo=bar? Ela não é usada, 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, a CLI do Azure não tem maneira de vincular um cofre de chaves a um grupo de variáveis.

Acesse o projeto do Azure DevOps e clique em Biblioteca. Você 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. Em seguida, você será avisado de que todos os valores das variáveis serão apagados e clique em Confirmar. Você verá como fazer isso abaixo. Essa ação é aceitável, pois a variável foo era temporária desde o início.

Linking variable group to pipeline

Depois de confirmar, 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 os dois 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! Você está agora pronto para começar a construir o pipeline. Mas espere… há mais!

Para tornar a construção de um Azure Pipeline mais prática, este tutorial cria 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 deste 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 Azure
  • server.infrastructure.tests.ps1 – Um teste Pester simples para confirmar que a configuração da VM está boa
  • server.json – Um modelo Azure ARM para provisionar uma VM
  • server.parameters.json – Um modelo de parâmetros ARM 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 pelo 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

Supondo que você tenha clonado meu repositório GitHub ou configurado 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 GitHub fornecido como acionador. Ele irá observar o branch master e usar a conexão de serviço criada 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 GitHub, você pode ou não receber feedback como abaixo. De qualquer forma, seu console parecerá 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

Já que você está construindo um pipeline de 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 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, fizer um ajuste em um teste Pester.

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

O Pool

Toda compilação precisa de um agente. Todo 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. Ela 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 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 de Criação do Principal de Serviço do Azure você foi lembrado de salvar o valor de $sp.appId em algum lugar? É aqui que você vai precisar dele. Atribua o valor da ID do aplicativo do principal de serviço a application_id como 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 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 do Azure para que os comandos subsequentes do Azure PowerShell possam ser executados.

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

A segunda tarefa está executando código PowerShell inline, o que significa que um script ainda não existe. Em vez disso, o código PowerShell é definido no próprio YAML do pipeline usando o valor da variável de 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 do Pester. Em um pipeline CI/CD como este, é importante ter algumas camadas diferentes de testes. Se você estivesse criando um pipeline para um projeto de software, poderia criar vários testes unitários.

Uma vez 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 arquivo de modelo ARM desejar.

Observe abaixo que o pipeline está usando várias variáveis de sistema. Essas variáveis estão referenciando a localização do arquivo nos arquivos assim que eles são transferidos para o 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. Uma vez que todo o pipeline é construído em torno da capacidade de implantar uma VM, esta etapa é 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. Na próxima etapa, 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” Pester

Depois que a VM for implantada, é necessário 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 da saída da implantação ARM por meio do parâmetro ArmDeploymentJsonOutput. O arquivo do script de teste Pester tem um parâmetro definido que recebe esse 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 se parece. Note que ele está lendo o nome do host DNS da VM para executar uma simples verificação de porta aberta.

$ArmDeploymentOutput = $ArmDeploymentJsonOutput | convertfrom-json

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

Limpeza dos Testes “Acceptance”

A única razão pela qual o pipeline implantou qualquer infraestrutura foi testar a validade do modelo ARM. Como essa infraestrutura é temporária, é necessário limpá-la. Na última tarefa do PowerShell, o pipeline está removendo o grupo de recursos criado anteriormente e tudo dentro dele.

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

Publicação dos Testes Pester

E, finalmente, chegamos ao último conjunto de tarefas. O Azure Pipelines tem uma tarefa chamada Publicar Resultados dos Testes. Esta tarefa lê um arquivo XML no agente de compilação e exibe os resultados dos testes no Azure DevOps. Esta é uma maneira prática de ver 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

Finalmente, estamos prontos para executar o pipeline e ver como ele funciona. Na interface web 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 no canto direito, como mostrado abaixo. Em seguida, clique em Executar pipeline. Isso iniciará a automação.

Running a pipeline

O pipeline continuará funcionando e executará cada tarefa conforme instruído. No final, você deverá ver todos os marcadores de verificação verdes para cada tarefa executada pelo trabalho, conforme mostrado abaixo.

Successful job task execution

Limpeza

Depois de mexer no pipeline e ter realizado tudo 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 construído neste artigo. Este código remove o principal de serviço, aplicativo do Azure AD, o grupo de recursos e tudo nele, e o projeto do 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

Resumo

Este tutorial tinha como objetivo dar a você um vislumbre de como construir um pipeline de automação de infraestrutura real do 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/