Construire un inventaire (CMDB) d'un parc Azure SQL avec Resource Graph
Resource Graph pour serveurs, pools, bases et groupes de basculement, collecte SQL dans chaque base, base centrale et gestion du retard d'inventaire.
Quand on gère quelques serveurs Azure SQL, on connaît tout par cœur. Quand on en gère des dizaines, avec des pools élastiques, des groupes de basculement et des bases qui apparaissent et disparaissent chaque semaine, il faut un inventaire central : une petite base de données (une CMDB) qui répond à « quelles bases existent, sur quel serveur, dans quel pool, qui est primaire ? » sans ouvrir le portail. Voici comment je la construis.
Deux sources complémentaires
Aucune source unique ne suffit :
| Source | Ce qu'elle sait | Ce qu'elle ne sait pas |
|---|---|---|
| Azure Resource Graph (ARM) | Serveurs, pools, bases, groupes de basculement, SKU, tailles max, emplacement | Ce qu'il y a dans les bases |
| Requête SQL dans chaque base | Taille réellement utilisée, utilisateurs, rôles, objets | Ce qui n'existe pas côté base (pool, groupe de basculement) |
La première donne le squelette de l'infrastructure, la seconde l'intérieur. Les deux alimentent des tables d'une base centrale.
flowchart LR
A["Azure Resource Graph"] --> B["Script planifié (nuit)"]
C["Connexion SQL à chaque base"] --> B
B --> D[("Base CMDB centrale")]
D --> E["Vues : rôles géo, capacité"]
E --> F["Autres scripts d'exploitation"]
E --> G["Rapport quotidien"]
Les requêtes Resource Graph
Resource Graph interroge tous les abonnements en une fois, sans boucler sur les groupes de ressources. Quelques requêtes à moi :
// Serveurs logiques
resources
| where type =~ "microsoft.sql/servers"
| project subscriptionId, resourceGroup, serverName = name, location,
version = tostring(properties.version)
// Bases (hors master), avec leur pool éventuel
resources
| where type =~ "microsoft.sql/servers/databases"
| where name !endswith "/master"
| extend serverName = tostring(split(name, "/")[0]),
dbName = tostring(split(name, "/")[1]),
poolId = tostring(properties.elasticPoolId)
| project subscriptionId, resourceGroup, serverName, dbName, location,
sku = tostring(sku.name), maxBytes = tolong(properties.maxSizeBytes), poolId
// Pools élastiques
resources
| where type =~ "microsoft.sql/servers/elasticpools"
| extend serverName = tostring(split(name, "/")[0]),
poolName = tostring(split(name, "/")[1])
| project subscriptionId, resourceGroup, serverName, poolName,
sku = tostring(sku.name), maxBytes = tolong(properties.maxSizeBytes)
// Groupes de basculement et rôle courant
resources
| where type =~ "microsoft.sql/servers/failovergroups"
| extend serverName = tostring(split(name, "/")[0]),
fogName = tostring(split(name, "/")[1])
| project subscriptionId, resourceGroup, serverName, fogName,
role = tostring(properties.replicationRole)
Côté PowerShell, Search-AzGraph -Query $q -First 1000 suffit, avec -SkipToken pour paginer au-delà. Le nom d'une base y apparaît sous la forme serveur/base : d'où les split.
La collecte SQL dans chaque base
Pour ce qu'ARM ne voit pas, le script se connecte à chaque base primaire avec une identité managée (jeton Entra, aucun mot de passe) et exécute une requête courte :
SELECT DB_NAME() AS db_name,
CAST(SUM(size) * 8.0 / 1024 AS decimal(18,1)) AS allocated_mb,
CAST(SUM(CAST(FILEPROPERTY(name, 'SpaceUsed') AS bigint)) * 8.0 / 1024 AS decimal(18,1)) AS used_mb
FROM sys.database_files
WHERE type_desc = 'ROWS';
Même principe pour les utilisateurs et rôles (sys.database_principals, sys.database_role_members). On saute les secondaires géo : elles sont en lecture seule et portent le même nom que sur le partenaire.
Stockage : staging, puis fusion
Chaque collecteur écrit dans une table temporaire (staging), puis une étape unique fait un MERGE vers les tables définitives. Les lignes absentes de la collecte ne sont pas supprimées : elles reçoivent un drapeau IsDeleted et une date. L'historique reste, et une collecte partielle ne vide pas l'inventaire. Garde-fou utile : si plus de la moitié des serveurs semblent avoir disparu, on ne marque rien et on alerte, car c'est presque sûrement un problème d'accès.
Le retard d'inventaire
Une CMDB n'est jamais en temps réel. Avec une collecte nocturne, elle a jusqu'à un jour de retard. Conséquences concrètes :
- Un serveur supprimé dans la journée est encore « vivant » dans la CMDB jusqu'à la nuit suivante ; un traitement lancé entre-temps échoue avec « introuvable ».
- Une base créée à midi est invisible pour les traitements de l'après-midi.
- Un basculement de groupe change le rôle primaire en quelques secondes.
Comment je vis avec :
- Séparer les rythmes. Inventaire lourd la nuit ; rôles géo (primaire/secondaire) rafraîchis toutes les 15 minutes dans une vue dédiée, car c'est ce qui change vite.
- Stocker l'heure de dernière collecte à côté de chaque ligne, et l'afficher dans les rapports.
- Traiter « introuvable » comme un signal de retard, pas comme un bug : avant d'ouvrir un incident, vérifier dans ARM si la ressource existe encore.
- Ne jamais décider d'une suppression à partir de la seule CMDB.
Retour d'expérience
- Les requêtes Resource Graph sont rapides et peu coûteuses ; la collecte SQL base par base est le goulot. Paralléliser par serveur, rester séquentiel dans un pool pour ne pas le saturer.
- Exclure explicitement certaines bases (table d'exclusions) évite de polluer les journaux d'erreurs.
- Un échec de connexion sur une base ne doit pas arrêter les autres : journaliser, continuer, résumer à la fin.
- Garder une purge : 180 jours d'archives et 90 jours d'états de collecte suffisent.