Esercizio - Pubblicare una specifica di modello

4 minuti

Il team ha alcuni file Bicep con protezione avanzata conformi al nuovo modello di governance dell'azienda. Uno dei file Bicep con protezione avanzata distribuisce un'app servizio app di Azure basata su Linux. In questo esercizio si usa una pipeline di distribuzione per pubblicare il file Bicep come specifica di modello.

Durante il processo, si eseguiranno queste operazioni:

Aggiungere una fase lint alla pipeline.
Aggiungere una fase pipeline per pubblicare la specifica di modello.
Verificare che la pipeline venga avviata e completata correttamente.
Controllare la specifica del modello pubblicata in Azure.

Aggiungere una fase lint alla pipeline

Il repository contiene una bozza di una definizione di pipeline che è possibile usare come punto di partenza.

In Visual Studio Code espandere la cartella template-specs/linux-app-service nella radice del repository.
Aprire il file pipeline.yml.
Nella parte inferiore del file, sostituire # To be added con la definizione della fase lint seguente:
```
stages:

- stage: Lint
  jobs:
  - job: LintCode
    displayName: Lint code
    steps:
      - script: |
          az bicep build --file $(TemplateSpecFilePath)
        name: LintBicepCode
        displayName: Run Bicep linter
```
Il repository contiene un file bicepconfig.json che configura il linter per generare errori anziché avvisi. Eventuali errori durante la fase lint causano l'esito negativo della pipeline.

Suggerimento

I file YAML sono sensibili al rientro. Se si digita o si incolla questo codice, assicurarsi che il rientro sia corretto. Più avanti in questo esercizio verrà visualizzata la definizione completa della pipeline YAML in modo da verificare la corrispondenza del file.

Aggiungere una fase di pubblicazione alla pipeline

È ora possibile aggiungere una seconda fase per pubblicare la specifica del modello in Azure.

Aggiungere il codice seguente alla fine del file pipeline.yml:

- stage: Publish
  jobs:
  - job: Publish
    steps:
      - task: AzureCLI@2
        name: Publish
        displayName: Publish template spec
        inputs:
          azureSubscription: $(ServiceConnectionName)
          scriptType: 'bash'
          scriptLocation: 'inlineScript'
          inlineScript: |
            az ts create \
              --resource-group $(AzureResourceGroupName) \
              --name $(TemplateSpecName) \
              --version $(Build.BuildNumber) \
              --template-file $(TemplateSpecFilePath) \
              --location $(AzureRegion) \
              --yes

Questa fase estrae il codice dal repository e accede ad Azure usando la connessione al servizio creata. Esegue quindi il comando az ts create per pubblicare la specifica del modello in Azure.

Suggerimento

Per semplificare le cose, la pipeline usa il numero di compilazione della pipeline come numero di versione della specifica del modello. Nell'unità successiva si apprenderà uno schema di controllo delle versioni più complesso.

Salvare le modifiche apportate al file .

Verificare ed eseguire il commit della definizione della pipeline

Verificare che il file pipelines.yml sia simile all'esempio seguente:

trigger:
  batch: true
  branches:
    include:
    - main
  paths:
    include:
    - 'template-specs/linux-app-service/**'

variables:
- name: ServiceConnectionName
  value: ToyReusable
- name: AzureResourceGroupName
  value: ToyReusable
- name: AzureRegion
  value: westus3
- name: TemplateSpecName
  value: linux-app-service
- name: TemplateSpecFilePath
  value: template-specs/linux-app-service/main.bicep

pool:
  vmImage: ubuntu-latest

stages:

- stage: Lint
  jobs:
  - job: LintCode
    displayName: Lint code
    steps:
      - script: |
          az bicep build --file $(TemplateSpecFilePath)
        name: LintBicepCode
        displayName: Run Bicep linter

- stage: Publish
  jobs:
  - job: Publish
    steps:
      - task: AzureCLI@2
        name: Publish
        displayName: Publish template spec
        inputs:
          azureSubscription: $(ServiceConnectionName)
          scriptType: 'bash'
          scriptLocation: 'inlineScript'
          inlineScript: |
            az ts create \
              --resource-group $(AzureResourceGroupName) \
              --name $(TemplateSpecName) \
              --version $(Build.BuildNumber) \
              --template-file $(TemplateSpecFilePath) \
              --location $(AzureRegion) \
              --yes

In caso contrario, aggiornarlo in modo che corrisponda a questo esempio e salvarlo.

Eseguire il commit e il push delle modifiche nel repository Git eseguendo i comandi seguenti nel terminale di Visual Studio Code:
```
git add .
git commit -m "Add lint and publish stages to Linux App Service template spec pipeline"
git push
```
Subito dopo il push, Azure Pipelines avvia una nuova esecuzione della pipeline.

Monitorare la pipeline

Nel browser selezionare Pipelines>Pipelines.
Selezionare l'esecuzione della pipeline attiva.
Verrà visualizzata l'esecuzione della pipeline.

Attendere il completamento dell'esecuzione della pipeline. Al termine, la specifica del modello viene pubblicata in Azure.
Si noti il numero di compilazione della pipeline, che include la data odierna e un numero di revisione univoco. Nello screenshot di esempio il numero di build è 20230407.1.

Esaminare la specifica di modello in Azure

È anche possibile visualizzare la specifica di modello pubblicata nel portale di Azure.

Nel browser passare al portale di Azure.
Passare al gruppo di risorse ToyReusable e selezionare la specifica di modello linux-app-service.
Esaminare i dettagli della specifica di modello.

Si noti che il numero di Versione più recente e Versione corrisponde al numero di compilazione della pipeline. La pipeline usa il numero di compilazione per il numero di versione della specifica di modello.