LLI Wiki — My Digital Knowledge Base

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 :

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

Mastodon LLIMastodon SocialFosstodon