Exercício - Publicar um módulo num registo

  • 5 minutos

Na sua empresa de brinquedos, você tem publicado seus módulos Bicep em um registro. Tem estado a executar o processo de publicação manualmente a partir do seu próprio computador. Agora, você deseja criar um fluxo de trabalho para lidar com o processo de publicação.

Neste exercício, irá:

  • Crie um registro de contêiner para seus módulos Bicep.
  • Adicione um trabalho lint ao fluxo de trabalho.
  • Adicione um trabalho de fluxo de trabalho para publicar o módulo no seu registro.
  • Verifique se o fluxo de trabalho é executado com êxito.
  • Verifique o módulo publicado no seu registo.

Criar um registo de contentores

Antes de publicar módulos, você precisa criar um registro para sua organização usar. Aqui, você usa o portal do Azure para criar um registro.

  1. Em seu navegador, crie um novo registro de contêiner no portal do Azure.

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

  3. Introduza um nome para o seu registo e uma localização perto de si.

    Importante

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

  4. Para SKU, selecione Básico.

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

  5. Selecione Rever + criar.

    Screenshot of the Azure portal that shows the container registry creation page.

  6. Revise as configurações, exiba Validação passada e selecione Criar.

    Aguarde até que a implantação termine, o que geralmente leva de 1 a 2 minutos.

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

    Screenshot of the Azure portal that shows the container registry deployment, with the button for going to a resource highlighted.

  8. Na área Visão geral do registro de contêiner, observe o valor da configuração do servidor de login. O nome é como yourregistryname.azurecr.io.

    Screenshot of the Azure portal that shows the container registry's details, with the login server highlighted.

    Você precisará desse valor em breve.

Adicionar um arquivo de metadados do módulo

Na unidade anterior, você aprendeu sobre a importância de ter uma estratégia de versionamento para seus módulos. Você também aprendeu como usar arquivos de metadados do módulo para especificar o número da versão principal e secundária do seu módulo em um fluxo de trabalho. Aqui, você adiciona 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 novo arquivo chamado metadata.json.

    Screenshot of Visual Studio Code that shows the location of the metadata dot J S O N file.

  3. Adicione o seguinte conteúdo ao ficheiro:

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

    Observe que, no arquivo de metadados, você define separadamente os números de versão principal e secundária. Seu fluxo de trabalho combina esses números com o número de execução do fluxo de trabalho, em um número de versão completo, cada vez que o fluxo de trabalho é executado.

  4. Guarde as alterações ao ficheiro.

Atualize sua definição de fluxo de trabalho e adicione um trabalho lint

Seu 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 .

    Screenshot of Visual Studio Code that shows the location of the workflow definition file.

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

    Por exemplo, se o servidor de login do seu registro estiver yourregistryname.azurecr.io, seu código será como 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 A ser adicionado , 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 seu fluxo de trabalho

Agora, você pode adicionar um segundo trabalho para publicar o módulo no seu 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 etapas fazem check-out do código do seu repositório e entram no Azure.

  2. Abaixo do código que você acabou de adicionar, adicione uma etapa para ler o número da versão do arquivo metadata.json do módulo e defina-o 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 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 }}

    Observe que esta etapa constrói o valor do --target argumento dinamicamente. Ele combina o valor do servidor de registro, o nome do módulo e o número da versão.

  4. Guarde as alterações ao ficheiro.

Verificar e confirmar sua definição de fluxo de trabalho

  1. Verifique se o arquivo module-storage-account.yml se parece com o exemplo a seguir:

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

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

  2. Confirme e envie suas alterações para o 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

Acionar o fluxo de trabalho

  1. No seu navegador, vá para o repositório GitHub e selecione a guia Ações .

  2. Selecione o fluxo de trabalho módulo-armazenamento-conta .

    Observe que uma execução de fluxo de trabalho já está em andamento. O gatilho de push disparou porque você modificou o arquivo metadata.json dentro da pasta do módulo.

  3. Selecione a última execução na lista.

    Screenshot of GitHub that highlights the latest run of the module's workflow.

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

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

Rever o módulo no registo

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

  1. No browser, aceda ao Portal do Azure.

  2. Vá para o grupo de recursos ToyReusable .

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

  4. Selecione o painel Repositórios no menu. Em seguida, selecione o repositório modules\storage-account, que representa o módulo que seu fluxo de trabalho publicou.

    Screenshot of the Azure portal that shows a Bicep module in the container registry.

    Observe que há uma única tag, que corresponde ao número da versão do módulo que seu fluxo de trabalho publicou. A versão principal (1) e a versão secundária (2) correspondem aos números de versão definidos no arquivo metadata.json . O número de revisão (3) corresponde ao número de execução do fluxo de trabalho.

Limpar os recursos

Agora que concluiu o exercício, pode remover os recursos para não ser cobrado por eles.

No terminal de código do Visual Studio, 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, vá para Configurações>Segredos e variáveis>Ações.
    2. Selecione Remover segredo para cada segredo do repositório e siga as instruções.

  • Repositório do GitHub

    1. Vá para Configurações>Gerais
    2. Selecione Excluir este repositório e siga as instruções.

  • Credenciais federadas e entidade de serviço do registro do Aplicativo do Azure.

    1. Na home page do portal, procure o Azure Ative Directory e selecione-o na lista de Serviços.
    2. Aceda a Gerir>registos de aplicações.
    3. Em Aplicativos próprios, selecione brinquedo-reutilizável.
    4. Selecione Excluir e siga as instruções.
    5. Selecione Aplicativos excluídos para excluir permanentemente o registro do aplicativo.

    Importante

    É possível ter registro de aplicativo duplicado e nomes principais de serviço. É recomendável verificar a ID do aplicativo para garantir que você esteja excluindo o recurso correto.