LLI Wiki — My Digital Knowledge Base

Pipelines YAML Azure DevOps : construire et déployer des applications PowerShell sur Azure Batch

Stages build, package et deploy, environnements dev/acc/prd avec approbations, variable groups liés à Key Vault et service connection en workload identity federation.

Une application PowerShell de DBA qui tourne sur Azure Batch ne doit pas être déployée « à la main » depuis un poste. Je la construis et la déploie avec un pipeline YAML Azure DevOps : le même code, le même chemin, dans trois environnements. Voici comment je l'organise.

Le flux

flowchart LR
    A["Dépôt Git (main)"] --> B["Stage Build : tests + lint"]
    B --> C["Stage Package : ZIP + version"]
    C --> D["Artefact de pipeline"]
    D --> E["Deploy dev"]
    E --> F["Deploy acc (approbation)"]
    F --> G["Deploy prd (approbation)"]
    G --> H["Azure Batch : application + version par défaut"]
    KV["Key Vault"] -.-> VG["Variable group"]
    VG -.-> E
    VG -.-> F
    VG -.-> G
    SC["Service connection (WIF)"] -.-> H

Trois stages, un rôle chacun

Stage Rôle Sortie
Build PSScriptAnalyzer, Pester, validation des manifestes résultats de tests
Package assemble le ZIP (application + modules partagés), calcule la version artefact package
Deploy publie le ZIP comme version d'application Batch et la met par défaut version active

Le point clé : on construit une seule fois. Le ZIP produit au stage Package est l'artefact qui traverse dev, acc puis prd. On ne reconstruit jamais pour la production, sinon on ne déploie plus ce qu'on a testé.

Le YAML, version simplifiée

trigger:
  branches: { include: [ main ] }
  paths:    { include: [ apps/export/** ] }

parameters:
  - name: forceRedeploy
    type: boolean
    default: false

stages:
  - stage: Build
    jobs:
      - job: Test
        steps:
          - template: templates/steps-test.yml

  - stage: Package
    dependsOn: Build
    jobs:
      - job: Zip
        steps:
          - pwsh: ./batch/build-package.ps1 -OutputPath "$(Build.ArtifactStagingDirectory)"
          - publish: $(Build.ArtifactStagingDirectory)
            artifact: package

  - ${{ each env in split('dev,acc,prd', ',') }}:
    - stage: Deploy_${{ env }}
      dependsOn: Package
      variables:
        - group: vg-dba-${{ env }}
      jobs:
        - deployment: Batch
          environment: ${{ env }}
          strategy:
            runOnce:
              deploy:
                steps:
                  - template: templates/steps-deploy-batch.yml
                    parameters: { environment: '${{ env }}' }

Les trois stages de déploiement s'enchaînent : Deploy_acc dépend de Deploy_dev, et Deploy_prd de Deploy_acc (je l'ai omis ici pour la lisibilité). Un deployment job rattaché à un environment est ce qui permet d'accrocher des approbations.

Environnements et approbations

Les environnements dev, acc et prd sont créés dans Azure DevOps (Pipelines > Environments). Sur acc et prd, j'ajoute une approbation : la personne désignée doit valider avant que le stage ne démarre. Le YAML ne contient aucune règle d'approbation, elle vit sur l'environnement, ce qui évite qu'un développeur la retire en modifiant le fichier.

Variable groups liés à Key Vault

Chaque environnement a son variable group (vg-dba-dev, etc.), lié à un Key Vault : les secrets sont lus à l'exécution, jamais copiés dans le dépôt. Les valeurs non secrètes (nom du compte Batch, groupe de ressources, compte de stockage) vivent dans le même groupe. Le pipeline ne connaît que des noms de variables.

Service connection et workload identity federation

Le pipeline s'authentifie à Azure par une service connection de type Azure Resource Manager configurée en workload identity federation : plus de secret client à faire tourner, Azure DevOps présente un jeton OIDC de courte durée. Le principal associé n'a que les droits nécessaires sur le compte Batch et son stockage.

- task: AzureCLI@2
  inputs:
    azureSubscription: sc-dba-prd
    scriptType: pscore
    scriptLocation: inlineScript
    inlineScript: |
      az batch application package create `
        --resource-group $(batchRg) --name $(batchAccount) `
        --application-name dba-export --version-name $(version) `
        --package-file "$(Pipeline.Workspace)/package/dba-export-$(version).zip"
      az batch application set `
        --resource-group $(batchRg) --name $(batchAccount) `
        --application-name dba-export --default-version $(version)

Retour d'expérience

Mastodon LLIMastodon SocialFosstodon