Exercício - Adicionar um trabalho de pré-visualização ao seu fluxo de trabalho

3 minutos

Você deseja adicionar um trabalho extra ao seu fluxo de trabalho para verificar quais alterações serão feitas em seu ambiente do Azure.

Durante o processo, você fará as seguintes tarefas:

Atualize o arquivo YAML de definição de fluxo de trabalho para adicionar um novo trabalho de visualização.
Adicione um ambiente ao seu repositório GitHub.
Configure o ambiente para exigir uma revisão.
Atualize o arquivo YAML do fluxo de trabalho para usar o ambiente para o trabalho de implantação.
Exiba os resultados hipotéticos e aprove uma execução de fluxo de trabalho.

Atualizar a definição do fluxo de trabalho para adicionar um trabalho de visualização

Aqui, você adiciona um novo trabalho ao seu fluxo de trabalho que executa a operação hipotética.

No Visual Studio Code, abra o arquivo workflow.yml na pasta .github/workflows .

Entre os trabalhos de validação e implantação , adicione a seguinte definição para o trabalho de visualização :

preview:
  runs-on: ubuntu-latest
  needs: [lint, validate]
  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 }}
  - uses: azure/arm-deploy@v1
    name: Run what-if
    with:
      failOnStdErr: false
      resourceGroupName: ${{ env.AZURE_RESOURCEGROUP_NAME }}
      template: deploy/main.bicep
      parameters: >
        environmentType=${{ env.ENVIRONMENT_TYPE }}
      additionalArguments: --what-if

Observe que o trabalho de visualização depende da conclusão bem-sucedida dos trabalhos de fiapos e valide .

Atualize o trabalho de implantação para torná-lo dependente do trabalho de visualização :

deploy:
  runs-on: ubuntu-latest
  needs: preview
  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 }}
  - uses: azure/arm-deploy@v1
    name: Deploy website
    with:
      failOnStdErr: false
      deploymentName: ${{ github.run_number }}
      resourceGroupName: ${{ env.AZURE_RESOURCEGROUP_NAME }}
      template: ./deploy/main.bicep
      parameters: environmentType=${{ env.ENVIRONMENT_TYPE }}

Guarde as alterações ao ficheiro.

Adicionar um ambiente

No navegador, vá para Configurações>de Ambientes.
Selecione Novo ambiente.
Digite Website como o nome do ambiente.
Selecione Configurar ambiente.

Nas etapas de configuração deste módulo, você já criou uma credencial federada para seu fluxo de trabalho usar quando ele for implantado no ambiente.

Adicionar a regra de proteção do revisor necessária ao ambiente

Selecione a caixa Revisores necessários.
Adicione seu próprio nome de usuário do GitHub à lista de revisores.
Selecione Salvar regras de proteção.
Selecione Ambientes para sair da configuração.

Atualizar a definição do fluxo de trabalho para exigir um ambiente e um revisor

Aqui, você configura o trabalho de implantação para ser executado no ambiente do site que você criou anteriormente.

Abra o arquivo workflow.yml no Visual Studio Code.

Adicione o environment parâmetro ao trabalho de implantação . Defina o valor como Website, para corresponder ao nome do ambiente que você criou:

deploy:
  runs-on: ubuntu-latest
  environment: Website
  needs: preview
  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 }}
  - uses: azure/arm-deploy@v1
    name: Deploy website
    with:
      failOnStdErr: false
      deploymentName: ${{ github.run_number }}
      resourceGroupName: ${{ env.AZURE_RESOURCEGROUP_NAME }}
      template: ./deploy/main.bicep
      parameters: environmentType=${{ env.ENVIRONMENT_TYPE }}

Guarde o ficheiro.

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

Verifique se o arquivo workflow.yml se parece com o seguinte código:

name: deploy-toy-website-test
concurrency: toy-company

on:
  push:
    branches:
      - main

permissions:
  id-token: write
  contents: read

env:
  AZURE_RESOURCEGROUP_NAME: ToyWebsiteTest
  ENVIRONMENT_TYPE: Test

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - name: Run Bicep linter
      run: az bicep build --file deploy/main.bicep

  validate:
    runs-on: ubuntu-latest
    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 }}
    - uses: azure/arm-deploy@v1
      name: Run preflight validation
      with:
        deploymentName: ${{ github.run_number }}
        resourceGroupName: ${{ env.AZURE_RESOURCEGROUP_NAME }}
        template: ./deploy/main.bicep
        parameters: environmentType=${{ env.ENVIRONMENT_TYPE }}
        deploymentMode: Validate

  preview:
    runs-on: ubuntu-latest
    needs: [lint, validate]
    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 }}
    - uses: azure/arm-deploy@v1
      name: Run what-if
      with:
        failOnStdErr: false
        resourceGroupName: ${{ env.AZURE_RESOURCEGROUP_NAME }}
        template: deploy/main.bicep
        parameters: >
          environmentType=${{ env.ENVIRONMENT_TYPE }}
        additionalArguments: --what-if

  deploy:
    runs-on: ubuntu-latest
    environment: Website
    needs: preview
    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 }}
    - uses: azure/arm-deploy@v1
      name: Deploy website
      with:
        failOnStdErr: false
        deploymentName: ${{ github.run_number }}
        resourceGroupName: ${{ env.AZURE_RESOURCEGROUP_NAME }}
        template: ./deploy/main.bicep
        parameters: environmentType=${{ env.ENVIRONMENT_TYPE }}

Se o ficheiro tiver um aspeto diferente, atualize-o para corresponder a este exemplo e, em seguida, guarde-o.

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 preview job"
git push
```

Execute o fluxo de trabalho e revise as saídas hipotéticas

No navegador, acesse as execuções do fluxo de trabalho.
Selecione a execução mais recente do seu fluxo de trabalho.

Aguarde até que o fluxo de trabalho conclua os trabalhos de fia, valide e visualize . Embora o GitHub atualize automaticamente a página com o status mais recente, é uma boa ideia atualizá-la ocasionalmente.
Observe que o fluxo de trabalho solicita uma revisão. Dependendo de como você configurar sua conta do GitHub, você receberá um e-mail ou notificação da Web com uma solicitação para revisar o fluxo de trabalho.

Antes de aprovar a continuação do fluxo de trabalho, você analisará os resultados hipotéticos para garantir que eles correspondam às suas expectativas.
Selecione o trabalho de visualização .
Selecione a etapa Executar hipóteses para inspecionar as alterações relatadas pelo comando hipotético.

Observe que o log de fluxo de trabalho fornece resultados hipotéticos semelhantes ao código a seguir:

Resource and property changes are indicated with these symbols:
  - Delete
  + Create
  ~ Modify
  = Nochange
  * Ignore

The deployment will update the following scope:

Scope: /subscriptions/***/resourceGroups/ToyWebsiteTest

  ~ Microsoft.OperationalInsights/workspaces/workspace-abcdefghijklm [2022-10-01]
    - properties.retentionInDays: 30
    - properties.sku:

        name: "pergb2018"

    - properties.workspaceCapping:

        dailyQuotaGb: -1.0

  ~ Microsoft.Web/sites/toy-website-abcdefghijklm [2022-03-01]
    + properties.siteConfig.localMySqlEnabled:   false
    + properties.siteConfig.netFrameworkVersion: "v4.6"

  = Microsoft.Insights/components/toywebsite [2020-02-02]
  = Microsoft.Storage/storageAccounts/mystorageabcdefghijklm [2022-09-01]
  = Microsoft.Web/serverfarms/toy-website [2022-03-01]
  * microsoft.alertsmanagement/smartDetectorAlertRules/Failure Anomalies - toywebsite

Resource changes: 2 to modify, 3 no change, 1 to ignore.

A operação hipotética detetou uma alteração no espaço de trabalho de análise de log e nos recursos do site. No entanto, as alterações que detetou são ruído. Eles não representam mudanças reais no seu recurso. Com o tempo, a equipe do Azure trabalha para reduzir o ruído. Enquanto isso, você pode ignorar as alterações detetadas.

Você também pode ver um item na saída hipotética para o tipo microsoft.alertsmanagement/smartDetectorAlertRules/Failure Anomalies - toywebsitede recurso . Este é um recurso que o Application Insights cria automaticamente. O comando what-if deteta que nenhuma alteração será feita no recurso.

Aprovar a execução do fluxo de trabalho

Selecione o Resumo para retornar à visão geral da execução do fluxo de trabalho.
Selecione o botão Revisar implantações no painel de revisão.
No pop-up Revisar implantações pendentes, selecione o ambiente do site. Na caixa Deixe um comentário, insira Resultados hipotéticos revisados.
Selecione Aprovar e implantar.

Observe a implantação bem-sucedida

Depois de aprovar a execução do fluxo de trabalho, observe que o trabalho de implantação começa a ser executado.

Aguarde até que o trabalho termine.
Observe que a execução do fluxo de trabalho é concluída com êxito.