Déployer un schéma avec DACPAC et SqlPackage sur beaucoup de bases
Extract, publish, profils de publication, blocage sur perte de données, rapports de dérive, déploiement parallèle par pool et intégration au pipeline.
Quand le même schéma doit exister dans des dizaines ou des milliers de bases, les scripts de migration écrits à la main ne passent pas à l'échelle. Un DACPAC décrit l'état voulu d'un schéma ; SqlPackage le compare à une cible et calcule les changements. Je m'en sers pour déployer des schémas de référence et pour bâtir un processus de livraison répétable sur beaucoup de bases Azure SQL.
Les briques
| Action | Rôle |
|---|---|
Extract |
lit une base et écrit un .dacpac (schéma, et données avec /p:ExtractAllTableData=true) |
Publish |
applique un .dacpac à une cible : crée ou modifie les objets pour qu'ils correspondent |
Script |
même comparaison, mais écrit le T-SQL au lieu de l'exécuter |
DeployReport |
écrit un rapport XML de ce qu'une publication ferait |
DriftReport |
compare une base enregistrée avec le schéma dont elle provient |
Un DACPAC est un fichier zip. Il porte le modèle, pas une sauvegarde : ne pas le confondre avec un BACPAC, qui sert à l'export et l'import schéma plus données.
Extract et publish
# Extraction, avec données (petits schémas de référence)
sqlpackage /Action:Extract /SourceConnectionString:"$srcCs" `
/TargetFile:"refer.dacpac" /p:ExtractAllTableData=true
# Publication avec un profil
sqlpackage /Action:Publish /SourceFile:"refer.dacpac" `
/TargetServerName:"sql-contoso-prd.database.windows.net" /TargetDatabaseName:"AppDb" `
/AccessToken:"$token" /Profile:"prd.publish.xml"
Pour Azure SQL, je passe un jeton (/AccessToken) obtenu depuis l'identité managée : aucun mot de passe dans le pipeline.
Profils de publication
Un profil est un fichier XML qui contient les options ; chaque exécution utilise donc des réglages identiques et le fichier est relu dans git comme du code.
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<BlockOnPossibleDataLoss>True</BlockOnPossibleDataLoss>
<DropObjectsNotInSource>False</DropObjectsNotInSource>
<IgnorePermissions>True</IgnorePermissions>
<ScriptDatabaseOptions>False</ScriptDatabaseOptions>
<ExcludeObjectTypes>Users;RoleMembership;Permissions</ExcludeObjectTypes>
</PropertyGroup>
</Project>
Les options les plus importantes :
BlockOnPossibleDataLoss:truepar défaut. SqlPackage s'arrête quand un changement pourrait perdre des données (par exemple une colonne passéeNOT NULLsur des lignes existantes, ou une table dont la définition change de façon incompatible). À garder activé. Ne le désactiver que pour une cible que l'on va remplir de nouveau.DropObjectsNotInSource: laisserfalsesur les bases partagées. Avectrue, tout ce qui n'est pas dans le DACPAC disparaît, y compris d'autres schémas, tables de maintenance ou objets de réplication.ExcludeObjectTypesetIgnorePermissions: garder utilisateurs, rôles et permissions hors des déploiements de schéma si un autre processus gère les accès.ScriptDatabaseOptions=false: ne pas modifier les options de niveau base, souvent restreintes sur Azure SQL.
Regarder avant de publier
Toujours générer d'abord le rapport et le relire dans une étape de validation :
sqlpackage /Action:DeployReport /SourceFile:"app.dacpac" `
/TargetConnectionString:"$cs" /OutputPath:"report.xml" /Profile:"prd.publish.xml"
Le XML liste chaque opération et chaque alerte (perte de données, par exemple). Le pipeline peut le publier en artefact et exiger une approbation avant la vraie publication. Script donne le T-SQL généré dans le même but.
La dérive
Les bases changent en dehors du pipeline : un index ajouté à la main, un correctif urgent. Pour le détecter, publier avec /p:RegisterDataTierApplication=true afin que la cible mémorise son schéma source, puis lancer DriftReport :
sqlpackage /Action:DriftReport /TargetConnectionString:"$cs" /OutputPath:"drift.xml"
Planifié et envoyé par mail, c'est un moyen peu coûteux de découvrir que la production ne correspond plus à ce que dit git.
Déployer sur beaucoup de bases
Pour un parc, la forme est : une liste de cibles (issue d'une table d'inventaire), regroupée par pool élastique, et une boucle parallèle.
$byPool = $targets | Group-Object PoolName
$byPool | ForEach-Object -Parallel {
$_.Group | ForEach-Object -Parallel {
# une publication par base
} -ThrottleLimit 2
} -ThrottleLimit 8
Les bases d'un même pool partagent CPU et IO, donc je limite la concurrence dans un pool (deux à la fois) et je parallélise entre pools. L'échec d'une base ne doit pas arrêter les autres : on la compte en échec, on continue, et on sort en erreur à la fin. J'enregistre la version déployée par base dans l'inventaire et je ne sélectionne que les bases pas encore à cette version : relancer la même commande reprend le travail.
Intégration au pipeline
Un pipeline type : construire le DACPAC depuis le projet SQL, lancer DeployReport sur une cible de test, publier hors production, attendre l'approbation, puis déployer le parc la nuit en production. SqlPackage est installé sur l'agent ou fourni comme outil .NET. Le DACPAC reste l'unique artefact, promu tel quel d'un environnement au suivant ; le reconstruire par environnement ruine l'intérêt.
Pièges
- Un DACPAC avec données et un changement de définition de table : vider l'ancien contenu avant la publication peut être nécessaire ; un blocage pour perte de données est alors attendu, pas un bug.
- Les erreurs transitoires Azure SQL (délais, limitation) méritent une nouvelle tentative bornée ; les échecs de connexion et de permission, non.
- Vérifier après publication : comptes de lignes ou table de version prouvent que le résultat est celui attendu.
- Ne jamais lancer deux déploiements simultanés sur la même cible.