Delen via

Zelfstudie: Een SQL-project maken en implementeren

  • Artikel

van toepassing op:SQL ServerAzure SQL DatabaseAzure SQL Managed InstanceSQL-database in Microsoft Fabric

Met de ontwikkelingscyclus van een SQL-databaseproject kan databaseontwikkeling worden geïntegreerd in een CI/CD-werkstroom (continue integratie en continue implementatie) die bekend zijn als een aanbevolen procedure voor ontwikkeling. Hoewel de implementatie van een SQL-databaseproject handmatig kan worden uitgevoerd, is het raadzaam om een implementatiepijplijn te gebruiken om het implementatieproces te automatiseren, zodat doorlopende implementaties worden uitgevoerd op basis van uw continue lokale ontwikkeling zonder extra inspanning.

In dit artikel wordt stapsgewijs uitgelegd hoe u een nieuw SQL-project maakt, objecten toevoegt aan het project en een pijplijn voor continue implementatie instelt voor het bouwen en implementeren van het project met GitHub-acties. De zelfstudie is een superset van de inhoud van het Aan de slag met SQL-databaseprojecten-artikel. Hoewel in de zelfstudie de implementatiepijplijn in GitHub-acties wordt geïmplementeerd, zijn dezelfde concepten van toepassing op Azure DevOps, GitLab en andere automatiseringsomgevingen.

In deze zelfstudie gaat u het volgende doen:

  1. Een nieuw SQL-project maken
  2. Objecten toevoegen aan het project
  3. Het project lokaal bouwen
  4. Het project controleren in broncodebeheer
  5. Een projectbuildstap toevoegen aan een pijplijn voor continue implementatie
  6. Een .dacpac-implementatiestap toevoegen aan een pijplijn voor continue implementatie

Als u de stappen om aan de slag te gaan met SQL Database-projecten al hebt voltooid, kunt u doorgaan naar stap 4. Aan dit einde van deze zelfstudie bouwt en implementeert uw SQL-project automatisch wijzigingen in een doeldatabase.

Voorwaarden

# install SqlPackage CLI
dotnet tool install -g Microsoft.SqlPackage

# install Microsoft.Build.Sql.Templates
dotnet new install Microsoft.Build.Sql.Templates

Zorg ervoor dat u de volgende items hebt om de installatie van de pijplijn in GitHub te voltooien:

Notitie

Als u de implementatie van een SQL-databaseproject wilt voltooien, hebt u toegang nodig tot een Azure SQL- of SQL Server-exemplaar. U kunt lokaal gratis ontwikkelen met SQL Server Developer Edition in Windows of in containers.

Stap 1: Een nieuw project maken

We beginnen ons project door een nieuw SQL-databaseproject te maken voordat we er handmatig objecten aan toevoegen. Er zijn andere manieren om een project te maken waarmee het project direct kan worden gevuld met objecten uit een bestaande database, zoals het gebruik van de hulpprogramma's voor schemavergelijking.

Selecteer Bestand, Nieuw, en Project.

Gebruik in het dialoogvenster Nieuw project de term SQL Server- in het zoekvak. Het bovenste resultaat moet worden SQL Server Database Project.

Schermafbeelding van het dialoogvenster 'Nieuw project'.

Selecteer Volgende om door te gaan naar de volgende stap. Geef een projectnaam op die niet overeenkomt met een databasenaam. Controleer en wijzig de projectlocatie indien nodig.

Selecteer maken om het project te maken. Het lege project wordt geopend en is zichtbaar in de Solution Explorer om te bewerken.

Selecteer Bestand, Nieuween Project.

Gebruik in het dialoogvenster Nieuw project de term SQL Server- in het zoekvak. Het bovenste resultaat moet SQL Server Database-project, SDK-stijl (voorbeeld).

schermopname van het dialoogvenster Nieuw project.

Selecteer Volgende om door te gaan naar de volgende stap. Geef een projectnaam op die niet overeenkomt met een databasenaam. Controleer en wijzig de projectlocatie indien nodig.

Selecteer om het project te maken. Het lege project wordt geopend en is zichtbaar in de Solution Explorer om te bewerken.

Selecteer in de databaseprojecten weergave van VS Code of Azure Data Studio de knop Nieuw project.

Schermopname van nieuwe viewlet.

De eerste prompt bepaalt welke projectsjabloon moet worden gebruikt, voornamelijk op basis van of het doelplatform SQL Server of Azure SQL is. Als u wordt gevraagd om een specifieke versie van SQL te selecteren, kiest u de versie die overeenkomt met de doeldatabase, maar als de doeldatabaseversie onbekend is, kiest u de meest recente versie, omdat de waarde later kan worden gewijzigd.

Voer een projectnaam in de tekstinvoer in die wordt weergegeven. Deze naam hoeft niet overeen te komen met een databasenaam.

Selecteer in het dialoogvenster "Een map selecteren" dat wordt weergegeven een directory voor de projectmap, het .sqlproj-bestand en andere inhoud, waar zij zich zullen bevinden.

Wanneer u wordt gevraagd of u een SDK-project wilt maken, selecteert u Ja.

Zodra het project is voltooid, wordt het lege project geopend en zichtbaar in de databaseprojecten weergave voor bewerking.

Als de .NET-sjablonen voor Microsoft.Build.Sql-projecten zijn geïnstalleerd, kunt u vanaf de opdrachtregel een nieuw SQL-databaseproject maken. De -n-optie geeft de naam van het project op en de -tp optie geeft het projectdoelplatform op.

Gebruik de optie -h om alle beschikbare opties weer te geven.

# install Microsoft.Build.Sql.Templates
dotnet new sqlproject -n MyDatabaseProject

Stap 2: Objecten toevoegen aan het project

Klik in Solution Explorermet de rechtermuisknop op het projectknooppunt en selecteer toevoegen en Tabel. Het dialoogvenster Nieuw item toevoegen wordt weergegeven, waarin u de tabelnaam kunt opgeven. Selecteer toevoegen om de tabel in het SQL-project te maken.

De tabel wordt geopend in de ontwerpfunctie voor Visual Studio-tabellen met de sjabloontabeldefinitie, waar u kolommen, indexen en andere tabeleigenschappen kunt toevoegen. Sla het bestand op wanneer u klaar bent met het maken van de eerste bewerkingen.

U kunt meer databaseobjecten toevoegen via het dialoogvenster Nieuw item toevoegen, zoals weergaven, opgeslagen procedures en functies. Open het dialoogvenster door met de rechtermuisknop op het projectknooppunt in Solution Explorer te klikken en Toevoegente selecteren en vervolgens het gewenste objecttype te selecteren. Bestanden in het project kunnen worden ingedeeld in mappen via de optie Nieuwe map onder Toevoegen.

Klik in Solution Explorer-met de rechtermuisknop op het projectknooppunt en selecteer toevoegen en nieuw item. Het dialoogvenster Nieuw item toevoegen wordt weergegeven, selecteer Alle sjablonen weergeven en tabel. Geef de tabelnaam op als bestandsnaam en selecteer Toevoegen om de tabel in het SQL-project te maken.

De tabel wordt geopend in de Visual Studio-queryeditor met de sjabloon voor tabeldefinitie, waar u kolommen, indexen en andere tabeleigenschappen kunt toevoegen. Sla het bestand op wanneer u klaar bent met het maken van de eerste bewerkingen.

U kunt meer databaseobjecten toevoegen via het dialoogvenster Nieuw item toevoegen, zoals weergaven, opgeslagen procedures en functies. Open het dialoogvenster door met de rechtermuisknop op het projectknooppunt in Solution Explorer te klikken en toevoegen te selecteren en vervolgens het gewenste objecttype na Alle sjablonen weergeven. Bestanden in het project kunnen worden ingedeeld in mappen via de optie Nieuwe map onder Toevoegen.

Klik in de databaseprojecten weergave van VS Code of Azure Data Studio met de rechtermuisknop op het projectknooppunt en selecteer Tabel toevoegen. Geef in het dialoogvenster dat wordt weergegeven de tabelnaam op.

De tabel wordt geopend in de teksteditor met de tabeldefinitie van het sjabloon, waar u kolommen, indexen en andere tabeleigenschappen kunt toevoegen. Sla het bestand op wanneer u klaar bent met het maken van de eerste bewerkingen.

Meer databaseobjecten kunnen worden toegevoegd via het contextmenu op het projectknooppunt, zoals weergaven, opgeslagen procedures en functies. Open het dialoogvenster door met de rechtermuisknop te klikken op het projectknooppunt in Database Projects weergave van VS Code of Azure Data Studio en vervolgens het gewenste objecttype. Bestanden in het project kunnen worden ingedeeld in mappen via de optie Nieuwe map onder Toevoegen.

Bestanden kunnen aan het project worden toegevoegd door ze te maken in de projectmap of geneste mappen. De bestandsextensie moet worden .sql en organisatie op objecttype of schema en objecttype wordt aanbevolen.

De basissjabloon voor een tabel kan worden gebruikt als uitgangspunt voor het maken van een nieuw tabelobject in het project:

CREATE TABLE [dbo].[Table1]
(
    [Id] INT NOT NULL PRIMARY KEY
);

Stap 3: Het project bouwen

Het buildproces valideert de relaties tussen objecten en de syntaxis voor het doelplatform dat is opgegeven in het projectbestand. De artefactuitvoer van het buildproces is een .dacpac-bestand, dat kan worden gebruikt om het project te implementeren in een doeldatabase en het gecompileerde model van het databaseschema bevat.

Klik in Solution Explorermet de rechtermuisknop op het projectknooppunt en selecteer Build.

Het uitvoervenster wordt automatisch geopend om het buildproces weer te geven. Als er fouten of waarschuwingen zijn, worden deze weergegeven in het uitvoervenster. Bij een geslaagde build wordt het buildartefact (.dacpac-bestand) gemaakt en wordt de locatie ervan opgenomen in de build-uitvoer (standaard is bin\Debug\projectname.dacpac).

Klik in Solution Explorermet de rechtermuisknop op het projectknooppunt en selecteer Build.

Het uitvoervenster wordt automatisch geopend om het buildproces weer te geven. Als er fouten of waarschuwingen zijn, worden deze weergegeven in het uitvoervenster. Bij een geslaagde build wordt het buildartefact (.dacpac-bestand) gemaakt en wordt de locatie ervan opgenomen in de build-uitvoer (standaard is bin\Debug\projectname.dacpac).

Klik in de databaseprojecten weergave van VS Code of Azure Data Studio met de rechtermuisknop op het projectknooppunt en selecteer Build.

Het uitvoervenster wordt automatisch geopend om het buildproces weer te geven. Als er fouten of waarschuwingen zijn, worden deze weergegeven in het uitvoervenster. Bij een geslaagde build wordt het buildartefact (.dacpac-bestand) gemaakt en wordt de locatie ervan opgenomen in de build-uitvoer (standaard is bin/Debug/projectname.dacpac).

SQL-databaseprojecten kunnen worden gebouwd vanaf de opdrachtregel met behulp van de opdracht dotnet build.

dotnet build

# optionally specify the project file
dotnet build MyDatabaseProject.sqlproj

De build-uitvoer bevat eventuele fouten of waarschuwingen en de specifieke bestanden en regelnummers waar ze optreden. Bij een geslaagde build wordt het buildartefact (.dacpac-bestand) gemaakt en wordt de locatie ervan opgenomen in de build-uitvoer (standaard is bin/Debug/projectname.dacpac).

Stap 4: Het project controleren in broncodebeheer

We initialiseren ons project als een Git-opslagplaats en voeren de projectbestanden door naar broncodebeheer. Deze stap is nodig om het project te kunnen delen met anderen en om te worden gebruikt in een pijplijn voor continue implementatie.

  1. Selecteer in het Git- menu in Visual Studio Git-opslagplaats maken.

    Schermopname van de optie Git-opslagplaats maken in het Git-menu in Visual Studio.

  2. Kies in het dialoogvenster Een Git-opslagplaats maken, in de sectie Push naar een nieuwe externe, GitHub.

  3. Voer in het Een nieuwe GitHub-opslagplaats maken sectie van het dialoogvenster Een Git-opslagplaats maken de naam in van de opslagplaats die u wilt maken. (Als u zich nog niet hebt aangemeld bij uw GitHub-account, kunt u dit ook doen via dit scherm.)

    Schermopname van het dialoogvenster Git-opslagplaats maken in Visual Studio met de GitHub-selectie gemarkeerd.

    Onder Initialiseer een lokale Git-opslagplaats, moet u de .gitignore-sjabloon optie gebruiken om opzettelijk niet-bijgehouden bestanden op te geven die door Git moeten worden genegeerd. Voor meer informatie over .gitignore, zie Bestanden negeren. Zie Licentieverlening voor een opslagplaatsvoor meer informatie over licenties.

  4. Nadat u zich hebt aangemeld en uw opslagplaatsgegevens hebt ingevoerd, selecteert u de knop Maken en pushen om uw opslagplaats te maken en uw app toe te voegen.

Klik in Solution Explorermet de rechtermuisknop op het projectknooppunt en selecteer Publiceren....

Het publicatiedialoogvenster wordt geopend, waar u de doeldatabaseverbinding tot stand brengt. Als u geen bestaand SQL-exemplaar hebt voor implementatie, wordt LocalDB ((localdb)\MSSQLLocalDB) geïnstalleerd met Visual Studio en kan worden gebruikt voor testen en ontwikkelen.

Geef een databasenaam op en selecteer Publiceren om het project te implementeren in de doeldatabase of Script genereren om een script te genereren dat moet worden beoordeeld voordat u het uitvoert.

U kunt de opslagplaats initialiseren en lokaal publiceren naar GitHub vanuit VS Code of Azure Data Studio. Met deze actie maakt u een nieuwe opslagplaats in uw GitHub-account en pusht u uw lokale codewijzigingen in de externe opslagplaats in één stap.

Gebruik de knop Publiceren naar GitHub in de weergave Broncodebeheer in VS Code of Azure Data Studio. Vervolgens wordt u gevraagd om een naam en beschrijving voor de opslagplaats op te geven en of u deze openbaar of privé wilt maken.

Schermopname van het dialoogvenster Git-opslagplaats maken in Visual Studio met de GitHub-selectie gemarkeerd.

U kunt ook een lokale opslagplaats initialiseren en naar GitHub pushen door de stappen te volgen die worden gegeven wanneer u een lege opslagplaats maakt op GitHub.

Initialiseer een nieuwe Git-opslagplaats in de projectmap en voer de projectbestanden door naar broncodebeheer.

git init
git add .
git commit -m "Initial commit"

Maak een nieuwe opslagplaats op GitHub en push de lokale opslagplaats naar de externe opslagplaats.

git remote add origin <repository-url>
git push -u origin main

Stap 5: Een projectbuildstap toevoegen aan een pijplijn voor continue implementatie

SQL-projecten worden ondersteund door een .NET-bibliotheek en als gevolg hiervan worden de projecten gebouwd met de opdracht dotnet build. Deze opdracht is een essentieel onderdeel van zelfs de eenvoudigste pijplijnen voor continue integratie en implementatie (CI/CD). De buildstap kan worden toegevoegd aan een pijplijn voor continue implementatie die we maken in GitHub Actions.

  1. Maak in de hoofdmap van de opslagplaats een nieuwe map met de naam .github/workflows. Deze map bevat het werkstroombestand dat de pijplijn voor continue implementatie definieert.

  2. Maak in de map .github/workflows een nieuw bestand met de naam sqlproj-sample.yml.

  3. Voeg de volgende inhoud toe aan het sqlproj-sample.yml-bestand en bewerk de projectnaam zodat deze overeenkomt met de naam en het pad van uw project:

    name: sqlproj-sample

on:
  push:
    branches: [ "main" ]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v4

    - name: Setup .NET
      uses: actions/setup-dotnet@v4
      with:
        dotnet-version: 8.0.x

    - name: Build
      run: dotnet build MyDatabaseProject.sqlproj

  4. Voer het werkstroombestand door naar de opslagplaats en push de wijzigingen naar de externe opslagplaats.

  5. Navigeer in GitHub.com naar de hoofdpagina van de opslagplaats. Selecteer onder uw opslagplaatsnaam Acties. Selecteer in de linkerzijbalk de werkstroom die u zojuist hebt gemaakt. Een recente uitvoering van de werkstroom moet worden weergegeven in de lijst met werkstroomuitvoeringen vanaf het moment dat u het werkstroombestand naar de opslagplaats hebt gepusht.

Meer informatie over de basisprincipes van het maken van uw eerste GitHub Actions-workflow is beschikbaar in de GitHub Actions quickstart .

Stap 6: Een .dacpac implementatiestap toevoegen aan een pijplijn voor continue implementatie

Het gecompileerde model van een databaseschema in een .dacpac-bestand kan worden geïmplementeerd in een doeldatabase met behulp van het SqlPackage opdrachtregelprogramma of andere implementatiehulpprogramma's. Het implementatieproces bepaalt de benodigde stappen om de doeldatabase bij te werken zodat deze overeenkomt met het schema dat is gedefinieerd in het .dacpac, het maken of wijzigen van objecten indien nodig op basis van de objecten die al in de database aanwezig zijn. Als u bijvoorbeeld een .dacpac-bestand wilt implementeren in een doeldatabase op basis van een verbindingsreeks:

sqlpackage /Action:Publish /SourceFile:bin/Debug/MyDatabaseProject.dacpac /TargetConnectionString:{yourconnectionstring}

Schermopname van het dacfx-bron- en doelvergelijkingsproces vóór de implementatie.

Het implementatieproces is idempotent, wat betekent dat het meerdere keren kan worden uitgevoerd zonder problemen te veroorzaken. De pijplijn die we maken, bouwt en implementeert ons SQL-project telkens wanneer een wijziging wordt ingecheckt in de main vertakking van onze opslagplaats. In plaats van de SqlPackage opdracht rechtstreeks in onze implementatiepijplijn uit te voeren, kunnen we een implementatietaak gebruiken die de opdracht abstraheert en aanvullende functies biedt, zoals logboekregistratie, foutafhandeling en taakconfiguratie. De implementatietaak GitHub sql-action kan worden toegevoegd aan een pijplijn voor continue implementatie in GitHub-acties.

Notitie

Voor het uitvoeren van een implementatie vanuit een automatiseringsomgeving moet u de database en omgeving zodanig configureren dat de implementatie de database kan bereiken en kan verifiëren. In Azure SQL Database of SQL Server op een VIRTUELE machine moet u mogelijk een firewallregel instellen om de automatiseringsomgeving verbinding te laten maken met de database en een verbindingsreeks met de benodigde referenties op te geven. Richtlijnen vindt u in de documentatie GitHub sql-action.

  1. Open het sqlproj-sample.yml bestand in de map .github/workflows.

  2. Voeg de volgende stap toe aan het sqlproj-sample.yml-bestand na de buildstap:

    - name: Deploy
  uses: azure/sql-action@v2
  with:
    connection-string: ${{ secrets.SQL_CONNECTION_STRING }}
    action: 'publish'
    path: 'bin/Debug/MyDatabaseProject.dacpac'

  3. Voordat u de wijzigingen doorvoert, voegt u een geheim toe aan de opslagplaats die de verbindingsreeks bevat voor de doeldatabase. Navigeer in de opslagplaats op GitHub.com naar Instellingenen Geheimen. Selecteer Nieuwe repository-geheim en voeg een geheim toe met de naam SQL_CONNECTION_STRING met de waarde van de verbindingsreeks voor de doeldatabase.

    Schermopname van de instellingen van de GitHub-opslagplaats met de knop Nieuw opslagplaatsgeheim gemarkeerd.

  4. Voer de wijzigingen van sqlproj-sample.yml door naar de opslagplaats en push de wijzigingen naar de externe opslagplaats.

  5. Ga terug naar de werkstroomgeschiedenis op GitHub.com en selecteer de meest recente uitvoering van de werkstroom. De implementatiestap moet zichtbaar zijn in de lijst met stappen voor de uitvoering van de werkstroom en de werkstroom retourneert een geslaagde code.

  6. Controleer de implementatie door verbinding te maken met de doeldatabase en te controleren of de objecten in het project aanwezig zijn in de database.

GitHub-implementaties kunnen verder worden beveiligd door een omgevingsrelatie in een werkstroom tot stand te brengen en goedkeuring te vereisen voordat een implementatie wordt uitgevoerd. Meer informatie over milieubescherming en de bescherming van geheimen is beschikbaar in de documentatie van GitHub Actions .

Hulp krijgen

Verwante inhoud