Exercício - Adicione fiapos e valide estágios ao seu pipeline

  • 3 minutos

Você conversou com sua equipe e decidiu automatizar ainda mais suas implantações usando um pipeline. Você quer construir mais confiança no que implanta.

Neste exercício, você adicionará estágios de validação ao seu pipeline. Em seguida, você executará a validação de linter e comprovação antes de cada implantação.

Durante o processo, você:

  • Atualize seu pipeline existente para adicionar dois novos estágios ao lint e validar seu código Bicep.
  • Execute os seus pipelines.
  • Corrija todos os problemas detetados pelo pipeline.

Atualize seu pipeline para se preparar para os estágios

Primeiro, você precisa atualizar seu arquivo de pipeline para definir um estágio. O Azure Pipelines cria automaticamente um único estágio para você, mas como você adicionará mais estágios em breve, precisará atualizar seu pipeline para definir explicitamente os estágios.

  1. No Visual Studio Code, abra o arquivo azure-pipelines.yml na pasta deploy .

  2. Remova tudo no arquivo da linha 14 para a parte inferior do arquivo. Certifique-se também de remover a jobs: linha.

  3. Na parte inferior do arquivo, adicione o seguinte código:

    
- stage: Lint
  jobs:
  - job: Deploy
    steps:
      - task: AzureResourceManagerTemplateDeployment@3
        name: Deploy
        displayName: Deploy to Azure
        inputs:
          connectedServiceName: $(ServiceConnectionName)
          deploymentName: $(Build.BuildNumber)
          location: $(DeploymentDefaultLocation)
          resourceGroupName: $(ResourceGroupName)
          csmFile: deploy/main.bicep
          overrideParameters: >
            -environmentType $(EnvironmentType)

    Gorjeta

    Os arquivos YAML são sensíveis ao recuo. Quer escreva ou cole este código, certifique-se de que o recuo está correto. Mais adiante neste exercício, você verá a definição completa do pipeline YAML para que possa verificar se o arquivo corresponde.

  4. Substitua a configuração do pool na linha 7 por esta linha:

    pool: Default

Adicione fiapos e estágios de validação ao seu pipeline

  1. Abaixo da stages: linha, adicione um estágio de fiapos:

    jobs:
- job: LintCode
  displayName: Lint code
  steps:
    - script: |
        az bicep build --file deploy/main.bicep
      name: LintBicepCode
      displayName: Run Bicep linter

    Esta etapa define uma única etapa que executa o az bicep build comando para lint o arquivo Bicep.

  2. Abaixo das linhas que você acabou de adicionar, adicione uma etapa de validação:

    jobs:
- job: ValidateBicepCode
  displayName: Validate Bicep code
  steps:
    - task: AzureResourceManagerTemplateDeployment@3
      name: RunPreflightValidation
      displayName: Run preflight validation
      inputs:
        connectedServiceName: $(ServiceConnectionName)
        location: $(deploymentDefaultLocation)
        deploymentMode: Validation
        resourceGroupName: $(ResourceGroupName)
        csmFile: deploy/main.bicep
        overrideParameters: >
          -environmentType $(EnvironmentType)

    Esta etapa define uma única etapa que executa a validação de comprovação. Observe que esta etapa inclui uma referência à sua conexão de serviço. Essa referência é necessária porque o processo de validação prévia requer comunicação com o Azure.

    Sua definição de pipeline agora tem três estágios. O primeiro executa o linter em seu arquivo Bicep, o segundo executa uma validação de comprovação e o terceiro executa a implantação no Azure.

  3. Guarde o ficheiro.

Configurar o linter

Por padrão, o linter Bicep fornece um aviso quando deteta um problema em um arquivo. O Azure Pipelines não trata os avisos linter como problemas que devem parar seu pipeline. Para personalizar esse comportamento, crie um arquivo bicepconfig.json que reconfigure o linter.

  1. Adicione um novo arquivo na pasta deploy e nomeie-o bicepconfig.json.

    Captura de tela do Visual Studio Code Explorer. O novo arquivo é mostrado na pasta deploy.

  2. Copie o seguinte código para o arquivo:

    {
  "analyzers": {
    "core": {
      "enabled": true,
      "verbose": true,
      "rules": {
        "adminusername-should-not-be-literal": {
          "level": "error"
        },
        "max-outputs": {
          "level": "error"
        },
        "max-params": {
          "level": "error"
        },
        "max-resources": {
          "level": "error"
        },
        "max-variables": {
          "level": "error"
        },
        "no-hardcoded-env-urls": {
          "level": "error"
        },
        "no-unnecessary-dependson": {
          "level": "error"
        },
        "no-unused-params": {
          "level": "error"
        },
        "no-unused-vars": {
          "level": "error"
        },
        "outputs-should-not-contain-secrets": {
          "level": "error"
        },
        "prefer-interpolation": {
          "level": "error"
        },
        "secure-parameter-default": {
          "level": "error"
        },
        "simplify-interpolation": {
          "level": "error"
        },
        "protect-commandtoexecute-secrets": {
          "level": "error"
        },
        "use-stable-vm-image": {
          "level": "error"
        }
      }
    }
  }
}

  3. Guarde o ficheiro.

Verificar e confirmar sua definição de pipeline

  1. Verifique se o arquivo azure-pipelines.yml se parece com o seguinte arquivo:

    trigger:
  batch: true
  branches:
    include:
    - main

pool: Default

variables:
  - name: deploymentDefaultLocation
    value: westus3

stages:

- stage: Lint
  jobs:
  - job: LintCode
    displayName: Lint code
    steps:
      - script: |
          az bicep build --file deploy/main.bicep
        name: LintBicepCode
        displayName: Run Bicep linter

- stage: Validate
  jobs:
  - job: ValidateBicepCode
    displayName: Validate Bicep code
    steps:
      - task: AzureResourceManagerTemplateDeployment@3
        name: RunPreflightValidation
        displayName: Run preflight validation
        inputs:
          connectedServiceName: $(ServiceConnectionName)
          location: $(deploymentDefaultLocation)
          deploymentMode: Validation
          resourceGroupName: $(ResourceGroupName)
          csmFile: deploy/main.bicep
          overrideParameters: >
            -environmentType $(EnvironmentType)

- stage: Deploy
  jobs:
  - job: Deploy
    steps:
      - task: AzureResourceManagerTemplateDeployment@3
        name: Deploy
        displayName: Deploy to Azure
        inputs:
          connectedServiceName: $(ServiceConnectionName)
          deploymentName: $(Build.BuildNumber)
          location: $(DeploymentDefaultLocation)
          resourceGroupName: $(ResourceGroupName)
          csmFile: deploy/main.bicep
          overrideParameters: >
            -environmentType $(EnvironmentType)

    Se não tiver a mesma aparência, atualize-a para corresponder a este exemplo e salve-a.

  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 validation stages"
git push

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

Exibir a execução do pipeline

  1. No Azure DevOps, vá para Pipelines.

  2. Selecione a execução mais recente do seu pipeline.

    Captura de ecrã do Azure DevOps. O link para a última execução do pipeline é destacado.

    Se o pipeline ainda estiver em execução, aguarde até que seja concluído. Embora o Azure Pipelines atualize automaticamente a página com o status mais recente, é uma boa ideia atualizá-la ocasionalmente.

  3. Observe que a execução do pipeline agora mostra os três estágios que você definiu no arquivo YAML. Observe também que a etapa Lint falhou.

    Captura de tela de um pipeline executado no Azure DevOps. O estágio Lint está relatando um fracasso.

  4. Selecione o palco Lint para ver mais detalhes.

    Captura de écran de uma execução de pipeline no Azure DevOps. O nome da etapa Lint está destacado.

  5. Selecione o passo Executar o linter Bicep para ver o log do pipeline.

    Captura de tela do log do pipeline para o estágio Lint. O passo para executar um linter Bicep é destacado.

    Observe que o erro exibido é semelhante a este:

    Erro no-unused-params: O parâmetro "storageAccountNameParam" é declarado, mas nunca usado.

    Este erro indica que o linter encontrou uma violação de regra no seu arquivo Bicep.

Corrigir o erro linter

Agora que você identificou o problema, você pode corrigi-lo em seu arquivo Bicep.

  1. No Visual Studio Code, abra o arquivo main.bicep na pasta deploy .

  2. Observe que o linter do Bíceps também detetou que o storageAccountNameParam parâmetro não é usado. Visual Studio Code indica o parâmetro não utilizado com uma linha ondulada. Normalmente, a linha seria amarela para indicar um aviso. Mas como você personalizou o arquivo bicepconfig.json , o linter trata o código como um erro e exibe a linha em vermelho. Aqui está a linha de código:

    param storageAccountNameParam string = uniqueString(resourceGroup().id)

  3. Exclua o storageAccountNameParam parâmetro.

  4. Guarde o ficheiro.

  5. 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 "Remove unused parameter"
git push

    Mais uma vez, o Azure Pipelines aciona automaticamente uma nova execução do seu pipeline.

Exibir a execução do pipeline novamente

  1. Em Azure DevOps, vá para o seu pipeline.

  2. Selecione a execução mais recente.

    Aguarde até que a execução do pipeline seja concluída. Embora o Azure Pipelines atualize automaticamente a página com o status mais recente, é uma boa ideia atualizá-la ocasionalmente.

  3. Observe que o estágio Lint terminou com sucesso, mas agora o estágio Validate falhou.

    Captura de ecrã da execução do pipeline. O estágio Lint relata sucesso e o estágio Validate relata falha.

  4. Selecione o estágio Validar para ver mais detalhes.

  5. Selecione a etapa Executar validação preliminar para exibir o log do pipeline.

    Captura de ecrã do log de pipeline para a etapa de validação. A etapa para executar a validação preliminar é destacada.

    Observe que o erro exibido no log inclui a seguinte mensagem:

    mystorageresourceNameSuffix não é um nome de conta de armazenamento válido. O nome da conta de armazenamento deve ter entre 3 e 24 caracteres e usar apenas números e letras minúsculas.

    Este erro indica que o nome da conta de armazenamento não é válido.

Corrigir o erro de validação

Você encontrou outro problema no arquivo Bicep. Aqui, você corrigirá o problema.

  1. No Visual Studio Code, abra o arquivo main.bicep na pasta deploy .

  2. Veja a definição da storageAccountName variável:

    var appServiceAppName = 'toy-website-${resourceNameSuffix}'
var appServicePlanName = 'toy-website'
var applicationInsightsName = 'toywebsite'
var logAnalyticsWorkspaceName = 'workspace-${resourceNameSuffix}'
var storageAccountName = 'mystorageresourceNameSuffix'

    A interpolação de cadeia de caracteres não foi configurada corretamente.

  3. Atualize a variável para usar corretamente a storageAccountName interpolação de cadeia de caracteres:

    var storageAccountName = 'mystorage${resourceNameSuffix}'

  4. Guarde o ficheiro.

  5. Confirme e envie as alterações para o repositório Git executando os seguintes comandos no terminal do Visual Studio Code:

    git add .
git commit -m "Fix string interpolation"
git push

Exibir a execução bem-sucedida do pipeline

  1. Em Azure DevOps, vá para o seu pipeline.

  2. Selecione a execução mais recente.

    Aguarde até que a execução do pipeline seja concluída. Embora o Azure Pipelines atualize automaticamente a página com o status mais recente, é uma boa ideia atualizá-la ocasionalmente.

    Observação

    Se você receber um erro informando que precisa registrar o provedor de recursos Microsoft.Insights, consulte Resolver erros para registro do provedor de recursos.

  3. Observe que todos os três estágios do pipeline foram concluídos com êxito:

    Captura de tela do pipeline executado no Azure DevOps, com todos os três estágios relatando o sucesso.

Agora você tem um pipeline que deteta erros com êxito no código do Bicep no início do processo de implantação e, em seguida, implanta no Azure se não houver erros.