Övning – Lägga till en Bicep-distributionsåtgärd i arbetsflödet

  • 4 minuter

Du har skapat ett grundläggande arbetsflöde och du har konfigurerat dina Azure- och GitHub-miljöer för att ansluta. Nu är du redo att implementera Bicep-filen för din webbplats till Azure via ditt arbetsflöde.

I den här övningen ska du:

  • Lägg till en Bicep-fil på lagringsplatsen.
  • Lägg till ett arbetsflödessteg för att ladda ned lagringsplatsens källkod till löparens filsystem.
  • Lägg till ett arbetsflödessteg för att logga in på Azure.
  • Lägg till ett arbetsflödessteg för att distribuera Bicep-filen.
  • Kör ditt arbetsflöde igen och kontrollera att det framgångsrikt har driftsatt din webbplats.

Lägg till webbplatsens Bicep-fil till GitHub-lagringsplatsen

Du har redan förberett webbplatsens Bicep-fil, som du kan använda för att distribuera olika konfigurationer av webbplatsresurserna beroende på miljö och konfiguration. Här lägger du till din Bicep-fil på lagringsplatsen.

  1. Öppna Visual Studio Code Explorer.

  2. Skapa en deploy-mapp i roten av ditt arkiv.

  3. I mappen distribuera skapar du en ny fil med namnet main.bicep. Se till att du skapar filen i mappen distribuera:

    Skärmbild av Visual Studio Code Explorer, med huvud-bicepfilen markerad och återfinns i deploy-mappen.

  4. Kopiera följande kod till filen 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. Spara ändringarna i filen.

  6. I Visual Studio Code-terminalen kör du den här koden för att mellanlagra ändringarna, checka in ändringarna och skicka ändringarna till lagringsplatsen:

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

Ersätt arbetsflödesstegen

Uppdatera sedan arbetsflödesdefinitionen för att distribuera Bicep-filen till Azure.

  1. Öppna filen .github/workflows/workflow.yml i Visual Studio Code.

  2. Lägg till ett permissions: avsnitt överst i filen mellan on: och jobs:.

    name: deploy-toy-website

on: [workflow_dispatch]

permissions:
  id-token: write
  contents: read

jobs:

    Med den här ändringen kan arbetsflödet använda en arbetsbelastningsidentitet.

  3. Byt namn på det say-hello jobbet till deploy:

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

  4. Ta bort placeholder steget från arbetsflödesdefinitionen genom att ta bort de två nedersta raderna i filen.

  5. Som ett första steg lägger du till en uppgift för att kolla in koden i löparens filsystem. Lägg till ett nytt steg längst ned i filen:

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

    Anteckning

    Det är en bra idé att skriva den här koden själv i stället för att kopiera och klistra in den från den här modulen. Var uppmärksam på filens indrag. Om indraget inte är korrekt är YAML-filen inte giltig. Visual Studio Code anger fel genom att visa vågiga rader.

  6. Under det steg som du nyss lade till lägger du till en uppgift för att logga in i Din Azure-miljö. Den här uppgiften använder hemligheterna som du definierade tidigare för att logga in med hjälp av en arbetsbelastningsidentitet:

    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. Under steget som du precis lade till lägger du till ytterligare ett steg för att utföra Bicep-distributionen:

    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 }}

    Observera att den här uppgiften använder github.run_number standardmiljövariabel för att namnge distributionen i Azure. Den använder också miljövariabler för resursgruppens namn och för parametern environmentType i Bicep-filen.

  8. Lägg till dessa variabler och deras värden överst i arbetsflödesfilen, mellan permissions: och jobs:

    name: deploy-toy-website

on: [workflow_dispatch]

permissions:
  id-token: write
  contents: read

env:
    AZURE_RESOURCEGROUP_NAME: ToyWebsite
    ENVIRONMENT: nonprod

jobs:

  9. Spara ändringarna i filen. Filen bör se ut så här:

    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. I Visual Studio Code-terminalen mellanlagrar du ändringarna, committar dem till lagret och pushar dem till Azure Repos.

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

Kör arbetsflödet

Nu är du redo att köra arbetsflödet!

  1. Öppna arbetsflödet i webbläsaren genom att välja Actions>deploy-toy-website.

  2. Välj Kör arbetsflöde>Kör arbetsflöde.

  3. En ny körning av ditt arbetsflöde kommer att visas i listan över körningar. Om den inte visas uppdaterar du webbläsarsidan.

  4. Välj arbetsflödet som körs för att visa information om körningen.

    Vänta tills körningen är klar.

  5. Välj distribuera jobb.

    Skärmbild av GitHub-gränssnittet som visar körningssidan med distributionsjobbet markerat.

  6. Välj Kör azure/arm-deploy@v1. Detta visar uppgiftsinformationen.

  7. Välj Kör azure/arm-deploy@v1 i uppgiftsdetaljerna.

    Skärmbild av GitHub-gränssnittet som visar arbetsflödesloggen med miljövariablerna markerade.

    Observera att det här steget använder de miljövariabler som du har lagt till i arbetsflödesfilen.

  8. Granska resten av arbetsflödets utdata.

    Arbetsflödet visar en lyckad utbyggnad.

Verifiera driftsättningen

  1. Gå till Azure-portalen.

  2. I den vänstra menyn väljer du Resursgrupper.

  3. Välj ToyWebsite.

  4. I Översiktvisar du distributionsstatus. Du kan se att en implementering lyckades.

    Skärmbild av Azure-portalen som visar resursgruppen med en lyckad distribution.

  5. Välj länken 1 Succeeded för att se information om utplaceringen.

    Skärmbild av Azure-portalen som visar resursgruppens distributionshistorik med distributionen markerad.

    Observera att namnet på distributionen matchar arbetsflödets körningsnummer i GitHub Actions, eftersom du använde github.run_number miljövariabeln för att namnge distributionen.

  6. Om du vill se vilka resurser som har distribuerats väljer du distributionen. Om du vill expandera distributionen och se mer information väljer du Distributionsinformation. I det här fallet finns det ett lagringskonto, en Azure App Service-plan och en app.

    Skärmbild av Azure-portalen som visar information om resursgruppens distribution med App Service-resurserna markerade.