Esercizio - Usare parametri Bicep con più ambienti

  • 5 minuti

Ora che il flusso di lavoro viene distribuito in entrambi gli ambienti, è possibile eseguire l'integrazione con l'API di terze parti per le revisioni dei prodotti.

Il team del sito Web ha fornito le chiavi API e gli URL che il sito Web deve usare per accedere al servizio. Esistono valori diversi per gli ambienti di test e produzione da usare. In questa unità si aggiornerà il flusso di lavoro per configurare ognuno degli ambienti con le impostazioni corrette per l'API di revisione del prodotto.

Durante il processo, si eseguiranno queste operazioni:

  • Creare segreti per le chiavi API di revisione per ognuno degli ambienti.
  • Aggiornare il flusso di lavoro con i valori di input e segreto corretti per ogni ambiente.
  • Aggiornare il file Bicep per propagare le impostazioni necessarie per l'API di revisione del prodotto.
  • Esaminare i risultati del flusso di lavoro e le modifiche apportate all'ambiente di Azure.

Aggiungere segreti

Si decide di archiviare le chiavi API nei segreti GitHub, per assicurarsi che siano adeguatamente protetti.

  1. Nel browser passare a Impostazioni>Segreti e variabili>Azioni.

    Screenshot di GitHub che mostra la voce di menu Secrets nella categoria Settings.

  2. Selezionare il pulsante New repository secret (Nuovo segreto del repository).

  3. Immettere REVIEW_API_KEY_TEST come nome segreto e sandboxsecretkey come valore.

    Screenshot di GitHub che mostra un nuovo segreto.

  4. Selezionare Aggiungi segreto.

  5. Ripetere il processo per aggiungere un altro segreto denominato REVIEW_API_KEY_PRODUCTION come nome segreto e productionsecretkey come valore. Selezionare Aggiungi segreto.

Aggiornare il file deploy.yml per usare le nuove impostazioni

  1. In Visual Studio Code aprire il file deploy.yml.

  2. Aggiornare il trigger del flusso di lavoro per includere nuovi valori per le impostazioni 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

    Si noti che gli URL delle API vengono inclusi come input perché non sono valori segreti.

  3. Nel processo validate aggiornare i passaggi per includere i nuovi parametri di distribuzione:

    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. Aggiornare il processo deploy per includere i nuovi parametri di distribuzione:

    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. Salvare le modifiche apportate al file .

Aggiornare il file workflow.yml per fornire le nuove impostazioni

  1. In Visual Studio Code aprire il file workflow.yml.

  2. Aggiungere gli input reviewApiUrl e i segreti reviewApiKey per ogni 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. Salvare le modifiche apportate al file .

Aggiornare il file Bicep

  1. Aprire il file main.bicep.

  2. Sotto i parametri già presenti nel file, aggiungere i parametri seguenti per la nuova API di revisione:

    @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. Aggiornare la definizione della risorsa appServiceApp per fornire l'URL dell'API di revisione e la chiave all'applicazione, in modo che il codice del sito Web possa usarli:

    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. Salvare le modifiche apportate al file .

  5. Eseguire il commit e il push delle modifiche nel repository Git usando i comandi seguenti:

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

Revisionare i risultati della distribuzione

  1. Nel browser andare alle esecuzioni dei flussi di lavoro.

  2. Selezionare l'esecuzione più recente.

  3. Selezionare l'esecuzione più recente del flusso di lavoro.

    Attendere che il flusso di lavoro venga sospeso prima del processo deploy-production / deploy. Potrebbero essere necessari alcuni minuti prima che il flusso di lavoro raggiunga questo punto.

  4. Approvare la distribuzione nell'ambiente di produzione selezionando Review deployments (Revisiona le distribuzioni), quindi selezionando Production (Production) e selezionando Approve and deploy (Approva e distribuisci).

    Attendere il completamento dell'esecuzione del flusso di lavoro.

  5. Selezionare Code (Codice) e quindi selezionare l'ambiente Production (Produzione).

    Si noti che ora vengono visualizzate più distribuzioni nella cronologia dell'ambiente.

  6. Nel browser passare al portale di Azure.

  7. Passare al gruppo di risorse ToyWebsiteProduction.

  8. Nell'elenco delle risorse aprire l'app Servizio app di Azure.

    Seleziona Configurazione.

    Screenshot del portale di Azure che mostra l'app del Servizio app e la voce di menu Configurazione.

  9. Selezionare Show values (Mostra valori).

    Screenshot del portale di Azure che mostra le impostazioni dell'app del Servizio app e il pulsante per visualizzare i valori.

  10. Si noti che i valori per le impostazioni ReviewApiKey e ReviewApiUrl sono impostati sui valori configurati per l'ambiente di produzione.

    Screenshot del portale di Azure che mostra le impostazioni dell'app del Servizio app e le impostazioni di configurazione.

  11. Confrontare i valori correnti con le impostazioni di configurazione per l'app Servizio app nel gruppo di risorse ToyWebsiteTest. Si noti che i valori sono diversi.

Pulire le risorse

Ora che l'esercizio è stato completato, è possibile rimuovere le risorse per evitare che vengano fatturate.

Nel terminale di Visual Studio Code eseguire i comandi seguenti:

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

Il gruppo di risorse viene eliminato in background.

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