Exercício – Adicionar uma ação de implantação do Bicep ao fluxo de trabalho

  • 4 minutos

Você criou um fluxo de trabalho básico e configurou seus ambientes do GitHub para se conectarem. Agora você está pronto para implantar o arquivo Bicep referente ao seu site no Azure oriundo do seu fluxo de trabalho.

Neste exercício, você vai:

  • Adicione um arquivo Bicep ao seu repositório.
  • Adicione uma etapa de fluxo de trabalho para baixar o código-fonte do repositório no sistema de arquivos do executor.
  • Adicione uma etapa de fluxo de trabalho para entrar no Azure.
  • Adicione uma etapa de fluxo de trabalho para implantar o arquivo Bicep.
  • Execute o fluxo de trabalho novamente e verifique se ele implantou seu site com êxito.

Adicionar o arquivo Bicep do seu site ao repositório do GitHub

Você já preparou o arquivo Bicep do seu site, que pode usar para implantar configurações diferentes dos recursos do site, dependendo do ambiente e da configuração. Aqui, você adicionará o arquivo Bicep ao seu repositório.

  1. Abra o Visual Studio Code Explorer.

  2. Na raiz do seu repositório, crie uma pasta implantar.

  3. Na pasta deploy, crie um arquivo chamado main.bicep. Crie o arquivo dentro da pasta deploy:

    Screenshot of the Visual Studio Code Explorer, with the main dot bicep file highlighted and located in the deploy folder.

  4. Copie o seguinte código para o arquivo main.bicep:

    @description('The Azure region into which the resources should be deployed.')
param location string = resourceGroup().location

@description('The type of environment. This must be nonprod or prod.')
@allowed([
  'nonprod'
  'prod'
])
param environmentType string

@description('A unique suffix to add to resource names that need to be globally unique.')
@maxLength(13)
param resourceNameSuffix string = uniqueString(resourceGroup().id)

var appServiceAppName = 'toy-website-${resourceNameSuffix}'
var appServicePlanName = 'toy-website-plan'
var toyManualsStorageAccountName = 'toyweb${resourceNameSuffix}'

// Define the SKUs for each component based on the environment type.
var environmentConfigurationMap = {
  nonprod: {
    appServicePlan: {
      sku: {
        name: 'F1'
        capacity: 1
      }
    }
    toyManualsStorageAccount: {
      sku: {
        name: 'Standard_LRS'
      }
    }
  }
  prod: {
    appServicePlan: {
      sku: {
        name: 'S1'
        capacity: 2
      }
    }
    toyManualsStorageAccount: {
      sku: {
        name: 'Standard_ZRS'
      }
    }
  }
}

var toyManualsStorageAccountConnectionString = 'DefaultEndpointsProtocol=https;AccountName=${toyManualsStorageAccount.name};EndpointSuffix=${environment().suffixes.storage};AccountKey=${toyManualsStorageAccount.listKeys().keys[0].value}'

resource appServicePlan 'Microsoft.Web/serverfarms@2023-12-01' = {
  name: appServicePlanName
  location: location
  sku: environmentConfigurationMap[environmentType].appServicePlan.sku
}

resource appServiceApp 'Microsoft.Web/sites@2023-12-01' = {
  name: appServiceAppName
  location: location
  properties: {
    serverFarmId: appServicePlan.id
    httpsOnly: true
    siteConfig: {
      appSettings: [
        {
          name: 'ToyManualsStorageAccountConnectionString'
          value: toyManualsStorageAccountConnectionString
        }
      ]
    }
  }
}

resource toyManualsStorageAccount 'Microsoft.Storage/storageAccounts@2023-05-01' = {
  name: toyManualsStorageAccountName
  location: location
  kind: 'StorageV2'
  sku: environmentConfigurationMap[environmentType].toyManualsStorageAccount.sku
}

  5. Salve as alterações no arquivo.

  6. No terminal do Visual Studio Code, execute este código para preparar as alterações, confirmá-las e efetuar push delas para o repositório:

    git add deploy/main.bicep
git commit -m 'Add Bicep file'
git push

Substituir as etapas do fluxo de trabalho

Em seguida, atualize a definição do seu fluxo de trabalho para implantar o seu arquivo Bicep no Azure.

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

  2. Na parte superior do arquivo, entre on: e jobs:, adicione uma seção permissions:.

    name: deploy-toy-website

on: [workflow_dispatch]

permissions:
  id-token: write
  contents: read

jobs:

    Essa alteração permite que o fluxo de trabalho use uma identidade de carga de trabalho.

  3. Renomeie o trabalho say-hello como deploy:

    jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:

  4. Para remover a etapa placeholder da definição do fluxo de trabalho, exclua as duas linhas inferiores do arquivo.

  5. Como uma primeira etapa, você adicionará uma tarefa para verificar o código no sistema de arquivos do executor. Adicione uma nova etapa na parte inferior do arquivo:

    jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3

    Observação

    Uma boa ideia é digitar esse código em vez de copiar e colar do módulo. Preste atenção ao recuo do arquivo. Se o recuo não estiver correto, o arquivo YAML não será válido. O Visual Studio Code indica erros exibindo linhas onduladas.

  6. Abaixo da etapa que você acabou de adicionar, adicione uma tarefa para entrar em seu ambiente do Azure. Essa tarefa usa os segredos que você definiu anteriormente para entrar usando uma identidade de carga de trabalho:

    jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - uses: azure/login@v1
      with:
        client-id: ${{ secrets.AZURE_CLIENT_ID }}
        tenant-id: ${{ secrets.AZURE_TENANT_ID }}
        subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}

  7. Abaixo da etapa que você acabou de adicionar, adicione outra etapa para executar a implantação do Bicep:

    jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - uses: azure/login@v1
      with:
        client-id: ${{ secrets.AZURE_CLIENT_ID }}
        tenant-id: ${{ secrets.AZURE_TENANT_ID }}
        subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
    - uses: azure/arm-deploy@v1
      with:
        deploymentName: ${{ github.run_number }}
        resourceGroupName: ${{ env.AZURE_RESOURCEGROUP_NAME }}
        template: ./deploy/main.bicep
        parameters: environmentType=${{ env.ENVIRONMENT }}

    Observe que esta tarefa usa a variável de ambiente padrão github.run_number para nomear a implantação no Azure. Ela também usa variáveis de ambiente para o nome do grupo de recursos e para o parâmetro environmentType no arquivo do Bicep.

  8. Adicione essas variáveis e os valores na parte superior do arquivo de fluxo de trabalho, entre permissions: e jobs:

    name: deploy-toy-website

on: [workflow_dispatch]

permissions:
  id-token: write
  contents: read

env:
    AZURE_RESOURCEGROUP_NAME: ToyWebsite
    ENVIRONMENT: nonprod

jobs:

  9. Salve as alterações no arquivo. Seu arquivo deve ser semelhante a este exemplo:

    name: deploy-toy-website

on: [workflow_dispatch]

permissions:
  id-token: write
  contents: read

env:
    AZURE_RESOURCEGROUP_NAME: ToyWebsite
    ENVIRONMENT: nonprod

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - uses: azure/login@v1
      with:
        client-id: ${{ secrets.AZURE_CLIENT_ID }}
        tenant-id: ${{ secrets.AZURE_TENANT_ID }}
        subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
    - uses: azure/arm-deploy@v1
      with:
        deploymentName: ${{ github.run_number }}
        resourceGroupName: ${{ env.AZURE_RESOURCEGROUP_NAME }}
        template: ./deploy/main.bicep
        parameters: environmentType=${{ env.ENVIRONMENT }}

  10. No terminal do Visual Studio Code, prepare suas alterações, confirme-as em seu repositório e efetue push delas para o Azure Repos:

    git add .
git commit -m 'Add Azure CLI tasks to workflow'
git push

Executar o fluxo de trabalho

Agora você já pode executar seu fluxo de trabalho!

  1. No navegador, abra o fluxo de trabalho selecionando Ações>deploy-toy-website.

  2. Selecione Executar o fluxo de trabalho>Executar o fluxo de trabalho.

  3. Uma nova execução do fluxo de trabalho será exibida na lista de execuções. Se ela não aparecer, atualize a página do navegador.

  4. Selecione o fluxo de trabalho em execução para exibir os detalhes da execução.

    Aguarde a conclusão da execução.

  5. Selecione o trabalho de implantação.

    Screenshot of the GitHub interface showing the run page, with the deploy job highlighted.

  6. Selecione Executar azure/arm-deploy@v1. Isso exibe os detalhes da tarefa.

  7. Selecione Executar azure/arm-deploy@v1 nos detalhes da tarefa.

    Screenshot of the GitHub interface showing the workflow log, with the 'environment variables' highlighted.

    Observe que essa etapa usa as variáveis de ambiente que você adicionou ao arquivo do fluxo de trabalho.

  8. Inspecione o restante da saída do fluxo de trabalho.

    O fluxo de trabalho mostra uma implantação bem-sucedida.

Verificar a implantação

  1. Vá para o Portal do Azure.

  2. No menu esquerdo, selecione Grupo de recursos.

  3. Selecione ToyWebsite.

  4. Em Visão geral, veja o status da implantação. Você pode ver que a implantação foi bem-sucedida.

    Screenshot of the Azure portal that shows the resource group with one successful deployment.

  5. Selecione o link 1 Êxito para ver os detalhes da implantação.

    Screenshot of the Azure portal that shows the resource group deployment history, with the deployment highlighted.

    Observe que o nome da implantação corresponde ao número de run do fluxo de trabalho GitHub Actions, pois você usou a variável de ambiente github.run_number para nomear sua implantação.

  6. Para ver quais recursos foram implantados, selecione a implantação. Para expandir a implantação e ver mais detalhes, selecione Detalhes da implantação. Nesse caso, há uma conta de armazenamento, um plano do Serviço de Aplicativo e um aplicativo.

    Screenshot of the Azure portal that shows the resource group deployment details, with the App Service resources highlighted.