Exercício – Usar parâmetros Bicep com vários ambientes

  • 5 minutos

Agora que seu fluxo de trabalho é implantado em ambos os ambientes, você está pronto para integrar-se à API de terceiros para revisões de produtos.

Sua equipe de site forneceu as chaves de API e as URLs que seu site deve usar para acessar o serviço. Há valores diferentes para os ambientes de teste e de produção usarem. Nesta unidade, você vai atualizar seu fluxo de trabalho para configurar cada um dos ambientes com as configurações corretas para a API de análise de produto.

Durante o processo, você vai:

  • Crie segredos para as chaves de API de revisão para cada um dos seus ambientes.
  • Atualize o fluxo de trabalho com os valores de entrada e segredo corretos para cada ambiente.
  • Atualize o arquivo Bicep para propagar as configurações de que você precisa para a API de análise de produto.
  • Examine os resultados do fluxo de trabalho e as alterações no ambiente do Azure.

Adicionar segredos

Você decide armazenar as chaves de API em segredos do GitHub, para garantir que elas estejam protegidas adequadamente.

  1. No navegador, acesse Configurações>Segredos e variáveis>Ações.

    Captura de tela do GitHub que mostra o item do menu Segredos na categoria Configurações.

  2. Selecione o botão Novo segredo do repositório.

  3. Insira REVIEW_API_KEY_TEST como o nome do segredo e sandboxsecretkey como o valor.

    Captura de tela do GitHub mostrando um novo segredo.

  4. Selecione Adicionar segredo.

  5. Repita o processo para adicionar outro segredo chamado REVIEW_API_KEY_PRODUCTION como o nome do segredo e productionsecretkey como o valor. Selecione Adicionar segredo.

Atualizar o arquivo deploy.yml para usar as novas configurações

  1. No Visual Studio Code, abra o arquivo deploy.yml.

  2. Atualize o gatilho de fluxo de trabalho para incluir novos valores para as configurações inputs e secrets:

    on:
  workflow_call:
    inputs:
      environmentType:
        required: true
        type: string
      resourceGroupName:
        required: true
        type: string
      reviewApiUrl:
        required: true
        type: string
    secrets:
      AZURE_CLIENT_ID:
        required: true
      AZURE_TENANT_ID:
        required: true
      AZURE_SUBSCRIPTION_ID:
        required: true
      reviewApiKey:
        required: true

    Observe que você inclui as URLs de API como entradas porque elas não são valores secretos.

  3. No trabalho validate, atualize as etapas para incluir os novos parâmetros de implantação:

    jobs:
  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 }}
     - if: inputs.environmentType != 'Production'
       uses: azure/arm-deploy@v1
       name: Run preflight validation
       with:
         deploymentName: ${{ github.run_number }}
         resourceGroupName: ${{ inputs.resourceGroupName }}
         template: ./deploy/main.bicep
         parameters: >
           environmentType=${{ inputs.environmentType }}
           reviewApiUrl=${{ inputs.reviewApiUrl }}
           reviewApiKey=${{ secrets.reviewApiKey }}
         deploymentMode: Validate
     - if: inputs.environmentType == 'Production'
       uses: azure/arm-deploy@v1
       name: Run what-if
       with:
         failOnStdErr: false
         resourceGroupName: ${{ inputs.resourceGroupName }}
         template: ./deploy/main.bicep
         parameters: >
           environmentType=${{ inputs.environmentType }}
           reviewApiUrl=${{ inputs.reviewApiUrl }}
           reviewApiKey=${{ secrets.reviewApiKey }}
         additionalArguments: --what-if

  4. Atualize o trabalho deploy para incluir os novos parâmetros de implantação:

    deploy:
  needs: validate
  environment: ${{ inputs.environmentType }}
  runs-on: ubuntu-latest
  outputs:
    appServiceAppHostName: ${{ steps.deploy.outputs.appServiceAppHostName }}
  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
    id: deploy
    name: Deploy Bicep file
    with:
      failOnStdErr: false
      deploymentName: ${{ github.run_number }}
      resourceGroupName: ${{ inputs.resourceGroupName }}
      template: ./deploy/main.bicep
      parameters: >
        environmentType=${{ inputs.environmentType }}
        reviewApiUrl=${{ inputs.reviewApiUrl }}
        reviewApiKey=${{ secrets.reviewApiKey }}

  5. Salve as alterações no arquivo.

Atualizar o arquivo workflow.yml para fornecer as novas configurações

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

  2. Adicione as entradas reviewApiUrl e os segredos reviewApiKey para cada ambiente:

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

on:
  push:
    branches:
      - main
  workflow_dispatch:

permissions:
  id-token: write
  contents: read

jobs:

  # Lint the Bicep file.
  lint:
    uses: ./.github/workflows/lint.yml

  # Deploy to the test environment.
  deploy-test:
    uses: ./.github/workflows/deploy.yml
    needs: lint
    with:
      environmentType: Test
      resourceGroupName: ToyWebsiteTest
      reviewApiUrl: https://sandbox.contoso.com/reviews
    secrets:
      AZURE_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID_TEST }}
      AZURE_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}
      AZURE_SUBSCRIPTION_ID: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
      reviewApiKey: ${{ secrets.REVIEW_API_KEY_TEST }}

  # Deploy to the production environment.
  deploy-production:
    uses: ./.github/workflows/deploy.yml
    needs: deploy-test
    with:
      environmentType: Production
      resourceGroupName: ToyWebsiteProduction
      reviewApiUrl: https://api.contoso.com/reviews
    secrets:
      AZURE_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID_PRODUCTION }}
      AZURE_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}
      AZURE_SUBSCRIPTION_ID: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
      reviewApiKey: ${{ secrets.REVIEW_API_KEY_PRODUCTION }}

  3. Salve as alterações no arquivo.

Atualizar o arquivo Bicep

  1. Abra o arquivo main.bicep.

  2. Abaixo dos parâmetros que já estão no arquivo, adicione os seguintes parâmetros à nova API de revisão:

    @description('The URL to the product review API.')
param reviewApiUrl string

@secure()
@description('The API key to use when accessing the product review API.')
param reviewApiKey string

  3. Atualize a definição de recurso appServiceApp para fornecer a URL da API de revisão e a chave para o aplicativo para que o código do site possa usá-las:

    resource appServiceApp 'Microsoft.Web/sites@2022-03-01' = {
  name: appServiceAppName
  location: location
  properties: {
    serverFarmId: appServicePlan.id
    httpsOnly: true
    siteConfig: {
      appSettings: [
        {
          name: 'APPINSIGHTS_INSTRUMENTATIONKEY'
          value: applicationInsights.properties.InstrumentationKey
        }
        {
          name: 'APPLICATIONINSIGHTS_CONNECTION_STRING'
          value: applicationInsights.properties.ConnectionString
        }
        {
          name: 'ReviewApiUrl'
          value: reviewApiUrl
        }
        {
          name: 'ReviewApiKey'
          value: reviewApiKey
        }
      ]
    }
  }
}

  4. Salve as alterações no arquivo.

  5. Faça o commit e o push de suas alterações para o repositório Git usando os seguintes comandos:

    git add .
git commit -m "Add new review API settings to Bicep file and workflow"
git push

Examinar os resultados da implantação

  1. No navegador, acesse as execuções de fluxo de trabalho.

  2. Selecione a execução mais recente.

  3. Selecione a execução mais recente do fluxo de trabalho.

    Aguarde até que o fluxo de trabalho seja pausado antes do trabalho deploy-production / deploy. Pode levar alguns minutos para o pipeline chegar a esse ponto.

  4. Aprove a implantação no ambiente de produção selecionando Examinar implantações e, em seguida, selecionando Produção e Aprovar e implantar.

    Aguarde até que a execução do fluxo de trabalho seja concluída.

  5. Selecione Código e o ambiente de Produção.

    Observe que agora você vê várias implantações no histórico do ambiente.

  6. No navegador, acesse o portal do Azure.

  7. Vá para o grupo de recursos ToyWebsiteProduction.

  8. Na lista de recursos, abra o aplicativo Serviço de Aplicativo do Azure.

    Selecione Configuração.

    Captura de tela da portal do Azure que mostra o aplicativo do Serviço de Aplicativo e o item de menu Configuração.

  9. Selecione Mostrar valores.

    Captura de tela do portal do Azure que mostra as configurações do aplicativo do Serviço de Aplicativo e o botão para mostrar valores.

  10. Observe que os valores para as configurações ReviewApiKey e ReviewApiUrl são definidos com os valores configurados para o ambiente de produção.

    Captura de tela da portal do Azure que mostra as configurações de aplicativo do Serviço de Aplicativo e as definições de configuração.

  11. Compare os valores atuais com as definições de configuração do aplicativo do Serviço de Aplicativo no grupo de recursos ToyWebsiteTest. Observe que os valores são diferentes.

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 os seguintes comandos:

az group delete --resource-group ToyWebsiteTest --yes --no-wait
az group delete --resource-group ToyWebsiteProduction --yes --no-wait

O grupo de recursos é excluído em segundo plano.

Remove-AzResourceGroup -Name ToyWebsiteTest -Force
Remove-AzResourceGroup -Name ToyWebsiteProduction -Force