Bereitstellen von Datenbankrollenmitgliedschaften in Testumgebungen

Artikel
07/13/2023

In diesem Thema wird das Hinzufügen von Benutzerkonten zu Datenbankrollen im Rahmen einer Lösungsbereitstellung zu einer Testumgebung beschrieben.

Wenn Sie eine Projektmappe mit einem Datenbankprojekt in einer Staging- oder Produktionsumgebung bereitstellen, möchten Sie in der Regel nicht, dass der Entwickler das Hinzufügen von Benutzerkonten zu Datenbankrollen automatisiert. In den meisten Fällen weiß der Entwickler nicht, welche Benutzerkonten welchen Datenbankrollen hinzugefügt werden müssen, und diese Anforderungen können sich jederzeit ändern. Wenn Sie jedoch eine Projektmappe mit einem Datenbankprojekt in einer Entwicklungs- oder Testumgebung bereitstellen, ist die Situation in der Regel etwas anders:

Der Entwickler stellt die Lösung in der Regel regelmäßig neu bereit, oft mehrmals täglich.

Die Datenbank wird in der Regel bei jeder Bereitstellung neu erstellt. Dies bedeutet, dass Datenbankbenutzer nach jeder Bereitstellung erstellt und Rollen hinzugefügt werden müssen.

Der Entwickler hat in der Regel die volle Kontrolle über die Zielentwicklungs- oder Testumgebung.

In diesem Szenario ist es häufig von Vorteil, im Rahmen des Bereitstellungsprozesses automatisch Datenbankbenutzer zu erstellen und Datenbankrollenmitgliedschaften zuzuweisen.

Der Schlüsselfaktor ist, dass dieser Vorgang abhängig von der Zielumgebung bedingt sein muss. Wenn Sie die Bereitstellung in einer Staging- oder Produktionsumgebung durchführen, möchten Sie den Vorgang überspringen. Wenn Sie die Bereitstellung in einer Entwickler- oder Testumgebung durchführen, möchten Sie Rollenmitgliedschaften ohne weiteren Eingriff bereitstellen. In diesem Thema wird ein Ansatz beschrieben, den Sie verwenden können, um diese Herausforderung anzugehen.

Dieses Thema ist Teil einer Reihe von Tutorials, die sich auf die Unternehmensbereitstellungsanforderungen eines fiktiven Unternehmens namens Fabrikam, Inc. beziehen. In dieser Tutorialreihe wird eine Beispiellösung – die Contact Manager-Lösung – verwendet, um eine Webanwendung mit einem realistischen Maß an Komplexität darzustellen, einschließlich einer ASP.NET MVC 3-Anwendung, einem WCF-Dienst (Windows Communication Foundation) und einem Datenbankprojekt.

Die Bereitstellungsmethode im Mittelpunkt dieser Tutorials basiert auf dem unter Grundlegendes zur Projektdatei beschriebenen Ansatz für geteilte Projektdateien, bei dem der Buildprozess von zwei Projektdateien gesteuert wird– eine mit Buildanweisungen, die für jede Zielumgebung gelten, und eine mit umgebungsspezifischen Build- und Bereitstellungseinstellungen. Zur Buildzeit wird die umgebungsspezifische Projektdatei in die umgebungsunabhängige Projektdatei zusammengeführt, um einen vollständigen Satz von Buildanweisungen zu bilden.

Aufgabenübersicht

In diesem Thema wird Folgendes vorausgesetzt:

Sie verwenden den Ansatz der geteilten Projektdatei für die Projektmappenbereitstellung, wie unter Grundlegendes zur Projektdatei beschrieben.
Sie rufen VSDBCMD aus der Projektdatei auf, um Ihr Datenbankprojekt bereitzustellen, wie unter Grundlegendes zum Buildprozess beschrieben.

Um Datenbankbenutzer zu erstellen und Rollenmitgliedschaften zuzuweisen, wenn Sie ein Datenbankprojekt in einer Testumgebung bereitstellen, müssen Sie Folgendes ausführen:

Erstellen Sie ein Transact-strukturierte Abfragesprache-Skript (Transact-SQL), das die erforderlichen Datenbankänderungen vornimmt.
Erstellen Sie ein Microsoft-Build-Engine-Ziel (MSBuild), das das Hilfsprogramm sqlcmd.exe zum Ausführen des SQL-Skripts verwendet.
Konfigurieren Sie Ihre Projektdateien so, dass sie das Ziel aufrufen, wenn Sie Ihre Lösung in einer Testumgebung bereitstellen.

In diesem Thema erfahren Sie, wie Sie die einzelnen Prozeduren ausführen.

Skripterstellung für Datenbankrollenmitgliedschaften

Sie können ein Transact-SQL-Skript auf viele verschiedene Arten und an jedem von Ihnen ausgewählten Ort erstellen. Der einfachste Ansatz besteht darin, das Skript in Ihrer Projektmappe in Visual Studio 2010 zu erstellen.

So erstellen Sie ein SQL-Skript

Erweitern Sie im fenster Projektmappen-Explorer den Knoten Des Datenbankprojekts.
Klicken Sie mit der rechten Maustaste auf den Ordner Skripts , zeigen Sie auf Hinzufügen, und klicken Sie dann auf Neuer Ordner.
Geben Sie Test als Ordnernamen ein, und drücken Sie dann die EINGABETASTE.
Klicken Sie mit der rechten Maustaste auf den Ordner Test , zeigen Sie auf Hinzufügen, und klicken Sie dann auf Skript.
Geben Sie ihrem Skript im Dialogfeld Neues Element hinzufügen einen aussagekräftigen Namen (z . B. AddRoleMemberships.sql), und klicken Sie dann auf Hinzufügen.
Fügen Sie in der Datei AddRoleMemberships.sql Transact-SQL-Anweisungen hinzu:
1. Erstellen Sie einen Datenbankbenutzer für die SQL Server Anmeldung, die auf Ihre Datenbank zugreift.
2. Fügen Sie den Datenbankbenutzer allen erforderlichen Datenbankrollen hinzu.

Die Datei sollte wie folgt aussehen:

USE $(DatabaseName)
GO
CREATE USER [FABRIKAM\TESTWEB1$] FOR LOGIN[FABRIKAM\TESTWEB1$]
GO
USE [ContactManager]
GO
EXEC sp_addrolemember N'db_datareader', N'FABRIKAM\TESTWEB1$'
GO
USE [ContactManager]
GO
EXEC sp_addrolemember N'db_datawriter', N'FABRIKAM\TESTWEB1$'
GO

Speichern Sie die Datei .

Ausführen des Skripts für die Zieldatenbank

Idealerweise führen Sie alle erforderlichen Transact-SQL-Skripts als Teil eines Skripts nach der Bereitstellung aus, wenn Sie Ihr Datenbankprojekt bereitstellen. Nach der Bereitstellung können Sie jedoch keine Logik basierend auf Lösungskonfigurationen oder Buildeigenschaften ausführen. Alternativ können Sie Ihre SQL-Skripts direkt aus der MSBuild-Projektdatei ausführen, indem Sie ein Target-Element erstellen, das einen sqlcmd.exe-Befehl ausführt. Sie können diesen Befehl verwenden, um Ihr Skript für die Zieldatenbank auszuführen:

sqlcmd.exe –S [Database server] –d [Database name] –i [SQL script]

Hinweis

Weitere Informationen zu sqlcmd-Befehlszeilenoptionen finden Sie unter sqlcmd-Hilfsprogramm.

Bevor Sie diesen Befehl in ein MSBuild-Ziel einbetten, müssen Sie berücksichtigen, unter welchen Bedingungen das Skript ausgeführt werden soll:

Die Zieldatenbank muss vorhanden sein, bevor Sie ihre Rollenmitgliedschaften ändern. Daher müssen Sie dieses Skript nach der Datenbankbereitstellung ausführen.
Sie müssen eine Bedingung einschließen, damit das Skript nur für Testumgebungen ausgeführt wird.
Wenn Sie eine "Was-wäre-wenn"-Bereitstellung ausführen , d. h. wenn Sie Bereitstellungsskripts generieren, diese aber nicht ausführen, sollten Sie das SQL-Skript nicht ausführen.

Wenn Sie den unter Grundlegendes zur Projektdatei beschriebenen Ansatz für geteilte Projektdateien verwenden, wie in der Contact Manager-Beispiellösung veranschaulicht, können Sie die Buildanweisungen für Ihr SQL-Skript wie folgt aufteilen:

Alle erforderlichen umgebungsspezifischen Eigenschaften sowie die Eigenschaft, die bestimmt, ob Berechtigungen bereitgestellt werden sollen, sollten in die umgebungsspezifische Projektdatei (z. B. Env-Dev.proj) eingebunden werden.
Das MSBuild-Ziel selbst sollte zusammen mit allen Eigenschaften, die sich zwischen Zielumgebungen nicht ändern, in der universellen Projektdatei (z. B. Publish.proj) gespeichert werden.

In der umgebungsspezifischen Projektdatei müssen Sie den Datenbankservernamen, den Zieldatenbanknamen und eine boolesche Eigenschaft definieren, mit der der Benutzer angeben kann, ob Rollenmitgliedschaften bereitgestellt werden sollen.

<PropertyGroup>
   <CmTargetDatabase Condition=" '$(CmTargetDatabase)'=='' ">
      ContactManager
   </CmTargetDatabase>
   <DatabaseServer Condition=" '$(DatabaseServer)'=='' ">
      TESTDB1
   </DatabaseServer>
   <DeployTestDBRoleMemberships Condition="'$(DeployTestDBRoleMemberships)'==''">
      true
   </DeployTestDBRoleMemberships>
</PropertyGroup>

In der universellen Projektdatei müssen Sie den Speicherort der ausführbaren Sqlcmd-Datei und den Speicherort des SQL-Skripts angeben, das Sie ausführen möchten. Diese Eigenschaften bleiben unabhängig von der Zielumgebung gleich. Sie müssen auch ein MSBuild-Ziel erstellen, um den Befehl sqlcmd auszuführen.

<PropertyGroup>
   <SqlCmdExe Condition=" '$(SqlCmdExe)'=='' ">
      C:\Program Files\Microsoft SQL Server\100\Tools\Binn\sqlcmd.exe
   </SqlCmdExe>
</PropertyGroup>

<Target Name="DeployTestDBPermissions" 
        Condition=" '$(DeployTestDBRoleMemberships)'=='true' AND 
                    '$(Whatif)'!='true' ">
   <PropertyGroup>
     <SqlScript>
        $(SourceRoot)ContactManager.Database\Scripts\Test\AddRoleMemberships.sql
     </SqlScript>
     <_Cmd>"$(SqlCmdExe)" -S "$(DatabaseServer)" 
                          -d "$(CmTargetDatabase)" 
                          -i "$(SqlScript)"
     </_Cmd>
   </PropertyGroup>
   <Exec Command="$(_Cmd)" ContinueOnError="false" />
</Target>

Beachten Sie, dass Sie den Speicherort der ausführbaren Datei sqlcmd als statische Eigenschaft hinzufügen, da dies für andere Ziele nützlich sein könnte. Im Gegensatz dazu definieren Sie den Speicherort Ihres SQL-Skripts und die Syntax des sqlcmd-Befehls als dynamische Eigenschaften innerhalb des Ziels, da sie vor der Ausführung des Ziels nicht erforderlich sind. In diesem Fall wird das Ziel DeployTestDBPermissions nur ausgeführt, wenn diese Bedingungen erfüllt sind:

Die DeployTestDBRoleMemberships-Eigenschaft ist auf true festgelegt.
Der Benutzer hat kein WhatIf=true-Flag angegeben.

Vergessen Sie nicht, das Ziel aufzurufen. In der Datei Publish.proj können Sie dies tun, indem Sie das Ziel der Abhängigkeitsliste für das Standardziel FullPublish hinzufügen. Sie müssen sicherstellen, dass das DeployTestDBPermissions-Ziel erst ausgeführt wird, wenn das PublishDbPackages-Ziel ausgeführt wurde.

<Project ToolsVersion="4.0" 
         DefaultTargets="FullPublish" 
         xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   ...
   <PropertyGroup>
      <FullPublishDependsOn>
         Clean;
         BuildProjects;
         GatherPackagesForPublishing;
         PublishDbPackages;
         DeployTestDBPermissions;
         PublishWebPackages;
      </FullPublishDependsOn>
   </PropertyGroup>
   <Target Name="FullPublish" DependsOnTargets="$(FullPublishDependsOn)" />
</Project>

Zusammenfassung

In diesem Thema wurde eine Möglichkeit beschrieben, wie Sie Datenbankbenutzer und Rollenmitgliedschaften als Aktion nach der Bereitstellung hinzufügen können, wenn Sie ein Datenbankprojekt bereitstellen. Dies ist in der Regel nützlich, wenn Sie eine Datenbank in einer Testumgebung regelmäßig neu erstellen. Dies sollte jedoch in der Regel vermieden werden, wenn Sie Datenbanken in Staging- oder Produktionsumgebungen bereitstellen. Daher sollten Sie sicherstellen, dass Sie die erforderliche bedingte Logik verwenden, damit Datenbankbenutzer und Rollenmitgliedschaften nur erstellt werden, wenn dies angemessen ist.

Weitere Informationen

Weitere Informationen zur Verwendung von VSDBCMD zum Bereitstellen von Datenbankprojekten finden Sie unter Bereitstellen von Datenbankprojekten. Anleitungen zum Anpassen von Datenbankbereitstellungen für verschiedene Zielumgebungen finden Sie unter Anpassen von Datenbankbereitstellungen für mehrere Umgebungen. Weitere Informationen zur Verwendung benutzerdefinierter MSBuild-Projektdateien zum Steuern des Bereitstellungsprozesses finden Sie unter Grundlegendes zur Projektdatei und Grundlegendes zum Buildprozess. Weitere Informationen zu sqlcmd-Befehlszeilenoptionen finden Sie unter sqlcmd-Hilfsprogramm.

Zurück Weiter

Share via