Oefening: lint toevoegen en taken valideren in uw werkstroom

3 minuten

U hebt met uw team gesproken en besloten om uw implementaties verder te automatiseren met behulp van een werkstroom. U wilt meer vertrouwen opbouwen in wat u implementeert.

In deze oefening voegt u validatietaken toe aan uw werkstroom. Vervolgens voert u de linter en de preflight-validatie uit voor elke implementatie.

Tijdens het proces voert u de volgende taken uit:

Werk uw bestaande werkstroom bij om twee nieuwe taken toe te voegen aan lint en uw Bicep-code te valideren.
Voer uw werkstroom uit.
Los eventuele problemen op die door uw werkstroom worden gedetecteerd.

Lint- en validatietaken toevoegen aan uw werkstroom

Open in Visual Studio Code het bestand workflow.yml in de map .github/workflows .
Wijzig in de sectie de env: waarde van de AZURE_RESOURCEGROUP_NAME variabele in ToyWebsiteTest:
```
env:
  AZURE_RESOURCEGROUP_NAME: ToyWebsiteTest
  ENVIRONMENT_TYPE: Test
```
Voeg onder de jobs: regel, boven de deploy taak, een nieuwe linttaak toe:
```
jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - name: Run Bicep linter
      run: az bicep build --file deploy/main.bicep
```
Deze taak definieert een stap voor het uitchecken van de code en een stap waarmee de az bicep build opdracht wordt uitgevoerd om het Bicep-bestand te linten.

Tip

YAML-bestanden zijn gevoelig voor inspringing. Controleer of de inspringing juist is, ongeacht of u deze code typt of plakt. Verderop in deze oefening ziet u de volledige YAML-werkstroomdefinitie, zodat u kunt controleren of het bestand overeenkomt.

Voeg onder de regels die u zojuist hebt toegevoegd en boven de implementatietaak een validatietaak toe:

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

Deze taak definieert stappen voor het uitchecken van de code, het aanmelden bij uw Azure-omgeving en het gebruik van de azure/arm-deploy actie met de Validate implementatiemodus.

Uw werkstroomdefinitie heeft nu drie taken. De eerste linten uw Bicep-bestand, de tweede voert een voorbereidende validatie uit en het derde voert de implementatie uit naar Azure.

Voeg onder de runs-on regel in de deploy taak een needs instructie toe:
```
deploy:
  runs-on: ubuntu-latest
  needs: [lint, validate]
  steps:
  - uses: actions/checkout@v3
  - uses: azure/login@v1
    name: Sign in to Azure
```
De needs instructie geeft aan dat de implementatietaak afhankelijk is van het lint en dat taken worden gevalideerd die zijn voltooid voordat deze kunnen worden uitgevoerd.

U ziet ook dat zowel de valideren als implementeren van taken zich aanmelden bij Azure en dat alle taken de code uit de opslagplaats uitchecken. Deze stappen zijn nodig omdat voor elke taak een nieuwe GitHub-runner wordt gebruikt.
Sla het bestand op.

De linter configureren

Bicep linter biedt standaard een waarschuwing wanneer er een probleem met uw bestand wordt gedetecteerd. GitHub Actions behandelt linterwaarschuwingen niet als problemen die uw werkstroom moeten stoppen. Als u dit gedrag wilt aanpassen, maakt u een bicepconfig.json-bestand waarmee de linter opnieuw wordt geconfigureerd.

Voeg een nieuw bestand toe aan de implementatiemap en geef het bicepconfig.json een naam.

Kopieer en plak de volgende code in het bestand:

{
  "analyzers": {
    "core": {
      "enabled": true,
      "verbose": true,
      "rules": {
        "adminusername-should-not-be-literal": {
          "level": "error"
        },
        "max-outputs": {
          "level": "error"
        },
        "max-params": {
          "level": "error"
        },
        "max-resources": {
          "level": "error"
        },
        "max-variables": {
          "level": "error"
        },
        "no-hardcoded-env-urls": {
          "level": "error"
        },
        "no-unnecessary-dependson": {
          "level": "error"
        },
        "no-unused-params": {
          "level": "error"
        },
        "no-unused-vars": {
          "level": "error"
        },
        "outputs-should-not-contain-secrets": {
          "level": "error"
        },
        "prefer-interpolation": {
          "level": "error"
        },
        "secure-parameter-default": {
          "level": "error"
        },
        "simplify-interpolation": {
          "level": "error"
        },
        "protect-commandtoexecute-secrets": {
          "level": "error"
        },
        "use-stable-vm-image": {
          "level": "error"
        }
      }
    }
  }
}

Sla het bestand op.

De implementatietaak configureren voor gebruik met de linter

Wanneer u een aangepaste linterconfiguratie gebruikt, schrijft Bicep logboekgegevens die GitHub Actions als een fout interpreteert. Als u dit gedrag wilt uitschakelen, configureert u de arm-deploy taak om de standaardfoutlogboekstroom (stderr) te negeren.

Open het bestand workflow.yml .

Stel in de teststap Implementatiewebsite van de deploy taak de failOnStdErr eigenschap falsein op:

deploy:
  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: Deploy website
    with:
      failOnStdErr: false
      deploymentName: ${{ github.run_number }}
      resourceGroupName: ${{ env.AZURE_RESOURCEGROUP_NAME }}
      template: ./deploy/main.bicep
      parameters: environmentType=${{ env.ENVIRONMENT_TYPE }}

Sla het bestand op.

Uw werkstroomdefinitie controleren en doorvoeren

Controleer of uw workflow.yml-bestand eruitziet als de volgende code:

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

  deploy:
    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: Deploy website
      with:
        failOnStdErr: false
        deploymentName: ${{ github.run_number }}
        resourceGroupName: ${{ env.AZURE_RESOURCEGROUP_NAME }}
        template: ./deploy/main.bicep
        parameters: environmentType=${{ env.ENVIRONMENT_TYPE }}

Als uw bestand er anders uitziet, werkt u het bij zodat het overeenkomt met dit voorbeeld en slaat u het op.

Voer uw wijzigingen door en push deze naar uw Git-opslagplaats door de volgende opdrachten uit te voeren in de Visual Studio Code-terminal:
```
git add .
git commit -m "Add lint and validation jobs"
git push
```
Deze doorvoering is de eerste keer dat u naar deze opslagplaats hebt gepusht, dus u wordt mogelijk gevraagd u aan te melden.

Typ in Windows 1 om te verifiëren met behulp van een webbrowser en selecteer Enter.

Selecteer Autoriseren in macOS.
Er wordt een browservenster geopend. Mogelijk moet u zich opnieuw aanmelden bij GitHub. Selecteer Autoriseren.

Direct nadat u een push hebt uitgevoerd, start GitHub Actions een nieuwe werkstroomuitvoering.

De werkstroomuitvoering weergeven

Ga in uw browser naar Acties.

De eerste uitvoering van uw werkstroom, met het label Eerste doorvoer, wordt weergegeven als een fout. GitHub heeft de werkstroom automatisch uitgevoerd toen u de opslagplaats maakte. Het is mislukt omdat de geheimen op dat moment niet gereed waren. U kunt deze fout negeren.
Selecteer de meest recente uitvoering van uw werkstroom.

U ziet dat in de werkstroom nu de drie taken worden weergegeven die u hebt gedefinieerd in het YAML-bestand. De lint- en validatietaken worden parallel uitgevoerd voordat de implementatietaak wordt gestart.
Als de werkstroom nog steeds wordt uitgevoerd, wacht u totdat deze is voltooid. Hoewel werkstromen de pagina automatisch bijwerken met de meest recente status, is het een goed idee om uw pagina af en toe te vernieuwen.

U ziet dat de lint- en validatietaken zijn mislukt.
Selecteer de linttaak om de details ervan weer te geven.
Selecteer de stap Bicep linter uitvoeren om het werkstroomlogboek weer te geven.

De fout in het werkstroomlogboek bevat een linter-foutbericht:
```
Error no-unused-params: Parameter "storageAccountNameParam" is declared but never used.
```
Dit foutbericht geeft aan dat de linter een regelschending heeft gevonden in uw Bicep-bestand.

De linter-fout oplossen

Nu u het probleem hebt geïdentificeerd, kunt u dit oplossen in uw Bicep-bestand.

Open in Visual Studio Code het bestand main.bicep in de implementatiemap .
U ziet dat bicep linter ook heeft gedetecteerd dat de storageAccountNameParam parameter niet wordt gebruikt. In Visual Studio Code wordt een golvende lijn weergegeven onder de parameter. Normaal gesproken is de lijn geel om een waarschuwing aan te geven. Maar omdat u het bicepconfig.json-bestand hebt aangepast, behandelt de linter de code als een fout en wordt de regel rood weergegeven.
```
param storageAccountNameParam string = uniqueString(resourceGroup().id)
```
Verwijder de storageAccountNameParam parameter.
Sla het bestand op.
Voer uw wijzigingen door en push deze naar uw Git-opslagplaats door de volgende opdrachten uit te voeren in de Visual Studio Code-terminal:
```
git add .
git commit -m "Remove unused parameter"
git push
```
GitHub Actions activeert opnieuw automatisch een nieuwe uitvoering van uw werkstroom.

De werkstroom opnieuw weergeven

Ga in uw browser naar uw werkstroom.
Selecteer de meest recente uitvoering.

Wacht totdat de uitvoering van de werkstroom is voltooid. Hoewel GitHub Actions de pagina automatisch bijwerken met de meest recente status, is het een goed idee om uw pagina af en toe te vernieuwen.
U ziet dat de linttaak is voltooid, maar dat de validatietaak nog steeds mislukt.
Selecteer de validatietaak om de details ervan weer te geven.
Selecteer de stap Voorbereidende validatie uitvoeren om het werkstroomlogboek weer te geven.

De fout die in het werkstroomlogboek wordt weergegeven, bevat het volgende bericht:
```
mystorageresourceNameSuffix is not a valid storage account name. Storage account name must be between 3 and 24 characters in length and use numbers and lower-case letters only.
```
Deze fout geeft aan dat de naam van het opslagaccount niet geldig is.

De validatiefout oplossen

U hebt een ander probleem aangetroffen in het Bicep-bestand. Hier lost u het probleem op.

Open in Visual Studio Code het bestand main.bicep in de implementatiemap .

Bekijk de definitie van de storageAccountName variabele:

var appServiceAppName = 'toy-website-${resourceNameSuffix}'
var appServicePlanName = 'toy-website'
var logAnalyticsWorkspaceName = 'workspace-${resourceNameSuffix}'
var applicationInsightsName = 'toywebsite'
var storageAccountName = 'mystorageresourceNameSuffix'

Er lijkt een typefout te zijn en de tekenreeksinterpolatie is niet juist geconfigureerd.

Werk de storageAccountName variabele bij om tekenreeksinterpolatie correct te gebruiken:
```
var storageAccountName = 'mystorage${resourceNameSuffix}'
```
Sla het bestand op.
Voer uw wijzigingen door en push deze naar uw Git-opslagplaats door de volgende opdrachten uit te voeren in de Visual Studio Code-terminal:
```
git add .
git commit -m "Fix string interpolation"
git push
```

De geslaagde werkstroomuitvoering weergeven

Ga in uw browser naar uw werkstroom.
Selecteer de meest recente uitvoering.

Wacht totdat de uitvoering van de werkstroom is voltooid. Hoewel GitHub Actions de pagina automatisch bijwerken met de meest recente status, is het een goed idee om uw pagina af en toe te vernieuwen.
U ziet dat alle drie de taken in de werkstroom zijn voltooid:

Sommige waarschuwingen worden weergegeven in het deelvenster Aantekeningen . Deze waarschuwingen worden weergegeven vanwege de manier waarop Bicep informatieve berichten naar het werkstroomlogboek schrijft. U kunt deze waarschuwingen negeren.

U hebt nu een werkstroom die fouten in uw Bicep-code vroeg in uw implementatieproces detecteert en vervolgens in Azure implementeert als er geen fouten zijn.