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 fluxo de trabalho 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 um trabalho de lint ao fluxo de trabalho.
  • Adicionar um trabalho de fluxo de trabalho para publicar o módulo no registro.
  • Verificar se o fluxo de trabalho é 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. Para Plano de preços, 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. Quando a mensagem Validação aprovada for exibida, 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. O nome é semelhante a yourregistryname.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 fluxo de trabalho. 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 J S O N de metadados.

  3. Adicione o seguinte conteúdo ao arquivo:

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

    No arquivo de metadados, você define separadamente os números de versão principal e secundária. Sempre que o fluxo de trabalho é executado, o fluxo de trabalho combina esses números com o número de execução do fluxo de trabalho para formar um número de versão completo.

  4. Salve as alterações no arquivo.

Atualizar a definição de fluxo de trabalho e adicionar um trabalho de lint

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

  1. No Visual Studio Code, expanda a pasta .github/workflows na raiz do repositório.

  2. Abra o arquivo module-storage-account.yml.

    Captura de tela do Visual Studio Code que mostra o local do arquivo de definição do fluxo de trabalho.

  3. Atualize o valor da variável de ambiente MODULE_REGISTRY_SERVER 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, o código será igual a este exemplo:

    env:
  MODULE_NAME: storage-account
  MODULE_REGISTRY_SERVER: yourregistryname.azurecr.io
  MODULE_FILE_PATH: modules/storage-account/main.bicep
  MODULE_METADATA_FILE_PATH: modules/storage-account/metadata.json

  4. Na parte inferior do arquivo, para o comentário # To be added, adicione a seguinte definição de trabalho lint:

    jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - name: Run Bicep linter
      run: az bicep build --file ${{ env.MODULE_FILE_PATH }}

Adicionar um trabalho de publicação ao fluxo de trabalho

Agora, você pode adicionar um segundo trabalho para publicar o módulo no registro de contêiner.

  1. Na parte inferior do arquivo module-storage-account.yml, adicione a primeira parte da definição do trabalho de publicação.

    publish:
  runs-on: ubuntu-latest
  needs: [ lint ]
  steps:
  - uses: actions/checkout@v3
  - uses: azure/login@v1
    name: Sign in to Azure
    with:
      client-id: ${{ secrets.AZURE_CLIENT_ID }}
      tenant-id: ${{ secrets.AZURE_TENANT_ID }}
      subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}

    As duas etapas iniciais nesta definição são verificar o código do repositório e entrar no Azure.

  2. Abaixo do código que você acabou de adicionar, adicione outra etapa que leia o número de versão do arquivo metadata.json do módulo e o defina como uma variável de ambiente.

    - name: Get module version number
  run: |
    majorMinorVersionNumber=$(jq '(.version.major | tostring) + "." + (.version.minor | tostring)' ${{ env.MODULE_METADATA_FILE_PATH }} -r )
    versionNumber="$majorMinorVersionNumber.${{ github.run_number }}"
    echo "MODULE_VERSION=$versionNumber" >> $GITHUB_ENV

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

  3. Após a etapa que você criou, adicione uma etapa final para publicar o módulo no registro.

    - uses: azure/cli@v1
  name: Publish module
  with:
    inlineScript: |
      az bicep publish \
        --target 'br:${{ env.MODULE_REGISTRY_SERVER }}/${{ env.MODULE_NAME }}:${{ env.MODULE_VERSION }}' \
        --file ${{ env.MODULE_FILE_PATH }}

    Esta etapa constrói 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.

  4. Salve as alterações no arquivo.

Verificar e fazer commit a definição do fluxo de trabalho

  1. Verifique se o arquivo module-storage_account.yml é semelhante ao seguinte exemplo:

    name: module-storage-account
concurrency: module-storage-account

on:
  workflow_dispatch:
  push:
    branches:
      - main
    paths:
      - 'modules/storage-account/**'

permissions:
  id-token: write
  contents: read

env:
  MODULE_NAME: storage-account
  MODULE_REGISTRY_SERVER: yourregistryname.azurecr.io
  MODULE_FILE_PATH: modules/storage-account/main.bicep
  MODULE_METADATA_FILE_PATH: modules/storage-account/metadata.json

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - name: Run Bicep linter
      run: az bicep build --file ${{ env.MODULE_FILE_PATH }}

  publish:
    runs-on: ubuntu-latest
    needs: [ lint ]
    steps:
    - uses: actions/checkout@v3
    - uses: azure/login@v1
      name: Sign in to Azure
      with:
        client-id: ${{ secrets.AZURE_CLIENT_ID }}
        tenant-id: ${{ secrets.AZURE_TENANT_ID }}
        subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
    - name: Get module version number
      run: |
        majorMinorVersionNumber=$(jq '(.version.major | tostring) + "." + (.version.minor | tostring)' ${{ env.MODULE_METADATA_FILE_PATH }} -r )
        versionNumber="$majorMinorVersionNumber.${{ github.run_number }}"
        echo "MODULE_VERSION=$versionNumber" >> $GITHUB_ENV
    - uses: azure/cli@v1
      name: Publish module
      with:
        inlineScript: |
          az bicep publish \
            --target 'br:${{ env.MODULE_REGISTRY_SERVER }}/${{ env.MODULE_NAME }}:${{ env.MODULE_VERSION }}' \
            --file ${{ env.MODULE_FILE_PATH }}

    Se o conteúdo do arquivo for diferente, atualize-o para corresponder a este exemplo e salve o arquivo.

  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 jobs to storage account module workflow"
git push

Disparar um fluxo de trabalho

  1. No navegador, acesse o repositório do GitHub e selecione a guia Ações.

  2. Selecione o fluxo de trabalho module-storage-account.

    Observe que uma execução de fluxo de trabalho já está em andamento. O gatilho de envio foi disparado porque você modificou o arquivo metadata.json na pasta do módulo.

  3. Selecione a execução mais recente na lista.

    Captura de tela do GitHub que realça a execução mais recente do fluxo de trabalho do módulo.

    Aguarde o fim da execução do fluxo de trabalho. O módulo Bicep é publicado no registro de contêiner.

    Anote o número da execução do fluxo de trabalho, que provavelmente é 3.

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. Em Recursos, selecione o registro de contêiner que você criou anteriormente.

  4. Selecione Repositórios de Serviços> no menu. Depois, selecione o repositório modules\storage-account que representa o módulo que o fluxo de trabalho 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 fluxo de trabalho 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 (3) corresponde ao número da execução do fluxo de trabalho.

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 os segredos e o repositório do GitHub e as identidades de carga de trabalho do Azure.

  • Segredos do GitHub

    1. No repositório GitHub, acesse Configurações>Segredos e variáveis>Ações.
    2. Para cada segredo salvo do GitHub, selecione o ícone Excluir <nome do segredo> e siga os prompts.

  • Repositório GitHub

    1. Acesse Configurações>Geral.
    2. Selecione Excluir este repositório e siga as solicitações.

  • As credenciais federadas e a entidade de serviço do registro do Azure App.

    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. Na guia Aplicativos próprios, selecione toy-reusable.
    4. Selecione Excluir e siga as solicitações.
    5. Selecione a guia Aplicativos Excluídos.
    6. Selecione toy-reusable, selecione Excluir permanentementee, em seguida, selecione Sim para excluir permanentemente o registro do aplicativo.

    Importante

    É possível ter nomes duplicados da entidade de serviço e de registro de aplicativo. Recomendamos que você verifique a ID do aplicativo para verificar se está excluindo o recurso correto.