Exercício – Publicar um módulo em um registro

  • 5 minutos

Em sua empresa de brinquedos, você costuma publicar os módulos Bicep em um registro. Você está executando o processo de publicação manualmente em seu computador. Agora, você quer criar um pipeline para lidar com o processo de publicação.

Neste exercício, você vai:

  • Criar um registro de contêiner para os módulos Bicep.
  • Adicionar uma fase de lint ao pipeline.
  • Adicionar uma fase do pipeline para publicar o módulo no registro.
  • Verificar se o pipeline é executado com êxito.
  • Verificar o módulo publicado no registro.

Criar um registro de contêiner

Para publicar os módulos, você precisa criar um registro para a organização usar. Aqui, você usará o portal do Azure para criar um registro.

  1. No navegador, crie um registro de contêiner no portal do Azure.

  2. Na guia Informações básicas, selecione a assinatura de destino e o grupo de recursos ToyReusable que você criou anteriormente.

  3. Insira um nome para o registro e uma localização próxima de você.

    Importante

    O nome do registro deve ser exclusivo no Azure e conter de 5 a 50 caracteres alfanuméricos. Uma marca de seleção ao lado do nome do registro indica que o nome escolhido está disponível.

  4. Em SKU, selecione Básico.

    Deixe os valores padrão para as outras definições de configuração.

  5. Selecione Examinar + criar.

    Captura de tela do portal do Azure mostrando a página de criação do Registro de Contêiner.

  6. Examine as configurações que exibem Validação aprovada e selecione Criar.

    Aguarde até que a implantação seja concluída, o que geralmente leva de um a dois minutos.

  7. Quando a mensagem de Implantação bem-sucedida for exibida, selecione Acessar recurso para abrir o registro de contêiner.

    Captura de tela do portal do Azure mostrando a implantação do Registro de Contêiner, com o botão para acessar um recurso realçado.

  8. Na área Visão geral do registro de contêiner, anote o valor da configuração Servidor de logon. Será algo como seunomederegistro.azurecr.io.

    Captura de tela do portal do Azure mostrando os detalhes do registro de contêiner, com o servidor de logon realçado.

    Você precisará desse valor em breve.

Adicionar um arquivo de metadados de módulo

Na unidade anterior, você aprendeu como é importante ter uma estratégia de controle de versão para os módulos. Você também aprendeu a usar arquivos de metadados de módulo para especificar o número de versão principal e secundária do módulo em um pipeline. Aqui, você vai adicionar um arquivo de metadados para o módulo de conta de armazenamento.

  1. No Visual Studio Code, expanda a pasta modules/storage-account na raiz do repositório.

  2. Crie um arquivo chamado metadata.json.

    Captura de tela do Visual Studio Code mostrando o local do arquivo de metadados J S O N.

  3. Adicione o seguinte conteúdo ao arquivo:

    {
  "version": {
    "major": 1,
    "minor": 2
  }
}

    Observe que, no arquivo de metadados, você define separadamente os números de versão principal e secundária. Sempre que é executado, o pipeline combina esses números, juntamente com o número de build do pipeline, formando um número de versão completo.

  4. Salve as alterações no arquivo.

Atualizar a definição do pipeline e adicionar uma fase de lint

O repositório contém um rascunho de um pipeline que você pode usar como ponto de partida.

  1. Abra o arquivo pipeline.yml na pasta modules/storage-account.

  2. Atualize o valor da variável de ambiente ModuleRegistryServer para o nome do servidor do registro de contêiner. Você já copiou esse nome neste exercício.

    Por exemplo, se o servidor de logon do registro for yourregistryname.azurecr.io, ele terá esta aparência:

    - name: ModuleRegistryServer
  value: yourregistryname.azurecr.io

  3. Na parte inferior do arquivo, no comentário # To be added com a seguinte definição de fase de lint:

    stages:

- stage: Lint
  jobs:
  - job: LintCode
    displayName: Lint code
    steps:
      - script: |
          az bicep build --file $(ModuleFilePath)
        name: LintBicepCode
        displayName: Run Bicep linter

Adicionar uma fase de publicação ao pipeline

Agora, você pode adicionar uma segunda fase para publicar o módulo no registro de contêiner.

  1. Na parte inferior do arquivo pipeline.yml, defina a fase Publicar, adicione uma etapa para ler o número de versão do arquivo metadata.json do módulo e defina-o como uma variável do pipeline.

    - stage: Publish
  jobs:
  - job: Publish
    steps:
      - script: |
          majorMinorVersionNumber=$(jq '(.version.major | tostring) + "." + (.version.minor | tostring)' $(ModuleMetadataFilePath) -r )
          versionNumber="$majorMinorVersionNumber.$(Build.BuildNumber)"
          echo "##vso[task.setvariable variable=ModuleVersion;]$versionNumber"
        name: GetModuleVersionNumber
        displayName: Get module version number

    A etapa executa um script que usa o aplicativo de linha de comando jq para analisar o arquivo JSON.

  2. Abaixo da etapa que você criou, adicione uma etapa para publicar o módulo no registro.

    - task: AzureCLI@2
  name: Publish
  displayName: Publish module
  inputs:
    azureSubscription: $(ServiceConnectionName)
    scriptType: 'bash'
    scriptLocation: 'inlineScript'
    inlineScript: |
      az bicep publish \
        --target 'br:$(ModuleRegistryServer)/$(ModuleName):$(ModuleVersion)' \
        --file $(ModuleFilePath)

    Observe que essa etapa cria o valor do argumento --target dinamicamente. Ela combina o valor do servidor de registro, o nome do módulo e o número de versão.

  3. Salve as alterações no arquivo.

Verificar a definição de pipeline e fazer commit dela

  1. Verifique se o arquivo storage_account_module.yml é semelhante ao seguinte exemplo:

    trigger:
  batch: true
  branches:
    include:
    - main
  paths:
    include:
    - 'modules/storage-account/**'

variables: 
- name: ServiceConnectionName
  value: ToyReusable
- name: ModuleName
  value: storage-account
- name: ModuleRegistryServer
  value: yourregistryname.azurecr.io
- name: ModuleFilePath
  value: modules/storage-account/main.bicep
- name: ModuleMetadataFilePath
  value: modules/storage-account/metadata.json

pool:
  vmImage: ubuntu-latest

stages:

- stage: Lint
  jobs:
  - job: LintCode
    displayName: Lint code
    steps:
      - script: |
          az bicep build --file $(ModuleFilePath)
        name: LintBicepCode
        displayName: Run Bicep linter

- stage: Publish
  jobs:
  - job: Publish
    steps:
      - script: |
          majorMinorVersionNumber=$(jq '(.version.major | tostring) + "." + (.version.minor | tostring)' $(ModuleMetadataFilePath) -r )
          versionNumber="$majorMinorVersionNumber.$(Build.BuildNumber)"
          echo "##vso[task.setvariable variable=ModuleVersion;]$versionNumber"
        name: GetModuleVersionNumber
        displayName: Get module version number
      - task: AzureCLI@2
        name: Publish
        displayName: Publish module
        inputs:
          azureSubscription: $(ServiceConnectionName)
          scriptType: 'bash'
          scriptLocation: 'inlineScript'
          inlineScript: |
            az bicep publish \
              --target 'br:$(ModuleRegistryServer)/$(ModuleName):$(ModuleVersion)' \
              --file $(ModuleFilePath)

    Caso contrário, atualize-o para corresponder a este exemplo e salve-o.

  2. Faça commit e efetue push das alterações no repositório Git executando os seguintes comandos no terminal do Visual Studio Code:

    git add .
git commit -m "Add lint and publish stages to storage account module pipeline"
git push

    Imediatamente após o push, o Azure Pipelines iniciará uma nova execução de pipeline.

Monitorar o Pipeline

  1. No navegador, selecione Pipelines>Pipelines.

  2. Selecione a execução de pipeline ativa.

  3. A execução de pipeline é exibida.

    Aguarde a conclusão da execução de pipeline. O módulo Bicep é publicado no registro de contêiner.

  4. Observe o número de build do pipeline, que inclui a data de hoje e um número de revisão exclusivo.

Examinar o módulo no registro

Você também pode ver o módulo publicado no portal do Azure.

  1. No navegador, acesse o portal do Azure.

  2. Acesse o grupo de recursos ToyReusable.

  3. Selecione o registro de contêiner que você criou.

  4. Selecione o painel Repositórios no menu. Depois, selecione o repositório modules\storage-account que representa o módulo que o pipeline publicou.

    Captura de tela do portal do Azure que mostra um módulo do Bicep no Registro de Contêiner.

    Observe que há uma só marca, que corresponde ao número de versão do módulo que o pipeline publicou. A versão principal (1) e a versão secundária (2) correspondem aos números de versão que você definiu no arquivo metadata.json. O número de revisão (20230407.3) corresponde ao número de build do pipeline.

Limpar os recursos

Agora que você concluiu o exercício, remova os recursos para não ser cobrado por eles.

No terminal do Visual Studio Code, execute o seguinte comando:

az group delete --resource-group ToyReusable --yes --no-wait

O grupo de recursos é excluído em segundo plano.

Remove-AzResourceGroup -Name ToyReusable -Force

Você também pode remover a conexão de serviço e o projeto do Azure DevOps.

  • Conexão de serviço

    1. No projeto do Azure DevOps, selecione Configurações do projeto>Conexões de serviço.
    2. Selecione ToyReusable.
    3. No canto superior direito, selecione os três pontos para Mais ações.
    4. Selecione Excluir e confirme a exclusão.

  • Registro de Aplicativo Azure

    1. Na página inicial do portal, pesquise Microsoft Entra ID e selecione-o na lista de Serviços.
    2. Acesse Gerenciar>Registros de aplicativo.
    3. Em Aplicativos excluídos, selecione toy-reusable.
    4. Selecione Excluir permanentemente e siga os prompts.

  • Projeto do Azure DevOps

    1. No projeto do Azure DevOps, selecioneConfigurações do projeto>Visão geral.
    2. Em Excluir projeto, selecione Excluir.
    3. Insira o nome do projeto e confirme a exclusão.