LLI Wiki — My Digital Knowledge Base

Configuration par environnement pour des scripts PowerShell : JSON, Key Vault, App Configuration

Fichiers config-env.json, chargeur de type Set-Parameters, contrôle de cohérence entre environnements, secrets dans Key Vault et Azure App Configuration en option.

Le même job PowerShell tourne contre la préproduction et la production. Le code doit être identique ; seules les données changent : noms de serveurs, abonnement, identité, seuils. La façon de stocker et de charger ces données décide si un changement d'environnement est un paramètre ou un incident. Voici le schéma que j'utilise, des simples fichiers JSON jusqu'à un service de configuration central.

Des fichiers par environnement

Chaque application a un dossier config/ :

config/
├── config-common.json   # valeurs communes
├── config-stg.json      # surcharges préproduction
└── config-prd.json      # surcharges production

Common contient ce qui ne change pas d'un environnement à l'autre : nombre de retries, délais, interrupteurs de fonctionnalités. Les fichiers d'environnement contiennent le reste, groupé par fonctionnalité :

{
  "sqlAdmin": {
    "server": "sql-contoso-prd.database.windows.net",
    "database": "AppDb"
  },
  "identity": { "name": "uami-dba-batch", "clientId": "00000000-0000-0000-0000-000000000000" },
  "keyVault": { "name": "kv-dba-contoso", "smtpSecretName": "smtp-api-key" }
}

L'environnement est un paramètre validé du script d'entrée ([ValidateSet('stg','prd')]) : une faute de frappe ne peut jamais charger une config fausse ou vide.

Un chargeur façon Set-Parameters

Une seule fonction charge la config, toujours, et chaque script l'appelle. Aucun script ne parse le JSON à la main. Elle renvoie l'objet résultat habituel pour que l'appelant gère l'échec.

function Set-Parameters {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory)][ValidateSet('stg','prd')][string]$Env,
        [Parameter(Mandatory)][string]$ConfigFilePath
    )
    try {
        $merged = @{}
        foreach ($name in "config-common.json", "config-$Env.json") {
            $file = Join-Path $ConfigFilePath $name
            if (-not (Test-Path $file)) { throw "Missing $name" }
            $json = Get-Content $file -Raw | ConvertFrom-Json
            foreach ($p in $json.PSObject.Properties) { $merged[$p.Name] = $p.Value }
        }
        @{ IsValid = $true; Data = $merged; Reason = $null }
    }
    catch { @{ IsValid = $false; Data = $null; Reason = $_.Exception.Message } }
}

Le fichier d'environnement l'emporte sur common car il est fusionné en dernier. Attention à la forme obtenue : la racine est une hashtable ($config['retryAttempts'] ou ContainsKey) alors que les groupes imbriqués sont des objets issus de ConvertFrom-Json (notation pointée, $config.sqlAdmin.server). Indexer un objet imbriqué avec des crochets lève une erreur, surprise classique. La fusion est superficielle : un groupe d'environnement remplace entièrement le groupe common, ce que je préfère à une fusion profonde car c'est prévisible.

Détecter où le script tourne

Un même job peut tourner depuis un poste d'admin, un agent de pipeline ou un noeud batch, chacun avec sa propre identité. Je garde un bloc d'identité par contexte dans la config et je détecte le contexte via l'environnement (les agents de pipeline définissent TF_BUILD, les noeuds Azure Batch AZ_BATCH_NODE_ID), avec un paramètre de forçage explicite. Ne nommez pas la variable $ExecutionContext : c'est une variable automatique réservée.

Vérifier la cohérence entre environnements

Deux fichiers de config dérivent en silence. Une clé ajoutée en production et oubliée en préproduction rend votre test de préproduction sans valeur. Je lance un contrôle, en local et en CI, qui compare les fichiers :

$stg = Get-Content config-stg.json -Raw | ConvertFrom-Json -AsHashtable
$prd = Get-Content config-prd.json -Raw | ConvertFrom-Json -AsHashtable
function Get-KeyPath($h, $prefix = '') {
    foreach ($k in $h.Keys) {
        $p = "$prefix$k"
        if ($h[$k] -is [hashtable]) { Get-KeyPath $h[$k] "$p." } else { $p }
    }
}
Compare-Object (Get-KeyPath $stg) (Get-KeyPath $prd) | Format-Table

Au-delà des clés, je vérifie des valeurs qui doivent concorder : un nom d'abonnement cohérent avec le serveur associé, un nom de secret identique dans les deux environnements, aucune valeur qui ressemble à un secret.

Secrets : Key Vault

Les fichiers de config sont versionnés, ils ne contiennent donc jamais de secret. Ils contiennent le nom du secret, et le code récupère la valeur à l'exécution avec l'identité managée du job :

$secret = Get-AzKeyVaultSecret -VaultName $config.keyVault.name `
          -Name $config.keyVault.smtpSecretName -AsPlainText -ErrorAction Stop

Une règle de revue vaut la peine : tout fichier de config contenant un préfixe de clé connu ou un motif de chaîne de connexion est une revue en échec. Ne loguez jamais la valeur récupérée.

Azure App Configuration en option

Fichiers JSON dans le dépôt Azure App Configuration
Changer une valeur Commit et déploiement Changement dans le service, sans déploiement
Historique et revue Git Instantanés et étiquettes du service
Environnements Un fichier par environnement Étiquettes ou un magasin par environnement
Secrets Nom seulement, Key Vault Références Key Vault
Hors ligne / en CI Oui Exige l'accès au magasin
Complexité Minimale Une ressource et une permission de plus
flowchart LR
    A["Script d'entrée"] --> L["Chargeur Set-Parameters"]
    L --> C["config-common.json"]
    L --> E["config-env.json"]
    L -. option .-> AC["App Configuration"]
    A --> KV["Key Vault"]
    A --> ID["Identité managée"]
    ID --> KV

Pour une poignée de jobs planifiés, je reste sur des fichiers : versionnés avec le code, relus dans la même pull request, testables hors ligne. App Configuration devient intéressant quand des non-développeurs doivent changer des valeurs sans release, ou quand beaucoup d'applications partagent les mêmes réglages. Si vous l'adoptez, gardez le contrat du chargeur : les appelants ne doivent pas voir d'où viennent les valeurs.

Retour d'expérience

Mastodon LLIMastodon SocialFosstodon