Zelfstudie: Een ASP.NET Core-app en -database implementeren in Azure Container Apps met behulp van GitHub Actions

In deze zelfstudie leert u hoe u een ASP.NET Core-app en SQL Database implementeert in Azure Container Apps met behulp van Visual Studio en GitHub Actions. U leert ook hoe u Entity Framework-migraties en -updates beheert in GitHub Actions, hoewel de concepten ook kunnen worden toegepast op andere CI/CD-hulpprogramma's en omgevingen.

Voorwaarden

U hebt Visual Studio 2022 geïnstalleerd met de ASP.NET en webontwikkelingsworkload en de Azure ontwikkelingsworkload.

Als u Visual Studio al hebt geïnstalleerd:

• Installeer de meest recente updates in Visual Studio door Help>Controleren op updateste selecteren.
• Controleer of de ASP.NET en webontwikkeling en Azure-ontwikkelworkloads zijn geïnstalleerd door Tools>Hulpprogramma's en onderdelen ophalente selecteren.

De voorbeeld-app lokaal instellen

Gebruik de TODO-voorbeeld-app om deze tutorial te volgen. Kloon de app vanuit GitHub met behulp van de volgende opdracht:

git clone https://github.com/Azure-Samples/msdocs-app-service-sqldb-dotnetcore.git
cd msdocs-app-service-sqldb-dotnetcore

Navigeer naar de projectmap en open vervolgens de DotNetCoreSqlDb.sln-oplossing in Visual Studio.

De TODO-toepassing is klaar, maar u moet een verbinding tot stand brengen met de localdb SQL Server die beschikbaar is in Visual Studio. Als u verbinding maakt met localdb, kunt u de app uitvoeren en todos behouden terwijl u lokaal werkt.

1. Klik met de rechtermuisknop op het knooppunt Connected Services in Visual Studio Solution Explorer en selecteer SQL Server Database toevoegen >.
2. In het dialoogvenster Verbinding maken met afhankelijkheid selecteer je SQL Server Express LocalDB (Lokaal) en selecteer vervolgens Volgende.
3. Stel in het dialoogvenster Verbinding maken met SQL Server Express LocalDB (lokaal) de volgende waarden in:
   • naam van de verbindingsreeks: laat de standaardwaarde staan.
   • verbindingsreekswaarde: laat de standaardwaarde staan.
   • verbindingsreekswaarde opslaan in: Selecteer Geen.
   • Selecteer Volgende
4. Laat in het Overzicht van wijzigingen scherm de instellingen op de standaardwaarden staan en selecteer Voltooien om de werkstroom te voltooien.

Visual Studio geeft een samenvatting weer van de serviceafhankelijkheden, inclusief de verbinding met LocalDB.

Vervolgens moet u een eerste migratie maken en deze gebruiken om de lokale database bij te werken met het juiste schema voor de TODO-app.

1. Selecteer het pictogram ... aan de rechterkant van de lijst met serviceafhankelijkheden naast de LocalDB-verbinding en kies Migratie-toevoegen.
2. Wacht in het dialoogvenster Entity Framework Migrations even tot visual Studio de DbContext klasse vindt die in het project is opgenomen. Nadat de waarden zijn geladen, selecteert u Voltooien.
3. Visual Studio genereert een Migrations map in het project en maakt een eerste migratieklasse. Deze klasse kan worden gebruikt om de database bij te werken met het juiste schema.
4. Selecteer het ... pictogram naast de LocalDB-service en selecteer Database bijwerken.
5. Wacht in het dialoogvenster Entity Framework Migrations even totdat Visual Studio de DbContext-klasse opnieuw heeft gevonden en kies vervolgens Voltooien. Visual Studio voert de migratie uit en maakt het schema voor de database op de LocalDB-server.

Start het project door boven aan Visual Studio de knop DotNetCoreSqlDb uitvoeren te selecteren.

Wanneer de app wordt geladen, controleert u of de database correct werkt door een nieuwe takenlijst in te voeren. De takenlijst wordt weergegeven in de hoofdlijstweergave op de startpagina van de app.

De opstartconfiguratie van de app verkennen

De voorbeeld-app bevat de volgende code in het bestand Program.cs:

if(builder.Environment.IsDevelopment())
{
    builder.Services.AddDbContext<MyDatabaseContext>(options =>
        options.UseSqlServer(builder.Configuration.GetConnectionString("Default")));
}
else
{
    builder.Services.AddDbContext<MyDatabaseContext>(options =>
        options.UseSqlServer(Environment.GetEnvironmentVariable("AZURE_SQL_CONNECTIONSTRING")));
}

Met deze code worden de volgende configuraties toegepast:

• Wanneer de app lokaal wordt uitgevoerd, wordt de localdb verbindingsreeks opgehaald uit het appsettings.json-bestand en geleverd aan Entity Framework. Met deze configuratie kan de localdb verbindingsreeks worden ingecheckt bij broncodebeheer, zodat andere ontwikkelaars tijdens de ontwikkeling eenvoudig verbinding kunnen maken met een lokale database. Ook kunnen Entity Framework-migraties lokaal worden uitgevoerd. Entity Framework detecteert standaard geen verbindingsreeksen die zijn opgeslagen in de omgevingsvariabele bij het uitvoeren van migraties.
• Wanneer de app wordt uitgevoerd in GitHub Actions-werkstromen of in Productie, wordt de verbindingsreeks opgehaald uit omgevingsvariabelen. Omgevingsvariabelen kunnen voorkomen dat beveiligde verbindingsreeksen voor productie worden ingecheckt in broncodebeheer of worden opgenomen in configuratiebestanden.

De Azure-services maken

Voor de app moeten de volgende Azure-services worden gemaakt voor een geslaagde implementatie:

• Container App: Vereist voor het hosten en uitvoeren van de geïmplementeerde toepassing.
• Container Registry: slaat het opgebouwde image-artifact van de containerapp op.
• SQL Database: een Azure SQL-database om de gegevens van de app op te slaan.

De publicatiefuncties van Visual Studio kunnen deze resources voor u afhandelen.

De Azure Container App en Azure Container Registry maken

1. Klik in Visual Studio Solution Explorer met de rechtermuisknop op het projectknooppunt op het hoogste niveau en selecteer Publiceren.

2. Selecteer in het publicatiedialoogvenster Azure als het implementatiedoel en selecteer vervolgens Volgende.

3. Selecteer voor het specifieke doel Azure Container Apps (Linux)en selecteer vervolgens Volgende.

4. Maak een nieuwe container-app om in te implementeren. Selecteer de knop + Nieuwe maken om een nieuw dialoogvenster te openen en voer de volgende waarden in:

   

   • container-appnaam: laat de standaardwaarde staan of voer een naam in.
   • abonnementsnaam: selecteer het abonnement waarnaar u wilt implementeren.
   • resourcegroep: Selecteer Nieuw en maak een nieuwe resourcegroep met de naam msdocs-app-db-ef.
   • Container-apps-omgeving: Selecteer Nieuwe om het dialoogvenster omgeving voor container-apps te openen en voer de volgende waarden in:
     • omgevingsnaam: De standaardwaarde behouden.
     • Locatie: Selecteer een locatie bij u in de buurt.
     • Azure Log Analytics-werkruimte: Selecteer Nieuw om het dialoogvenster Log Analytics-werkruimte te openen.
       • naam: laat de standaardwaarde staan.
       • Locatie: Selecteer een locatie bij u in de buurt en selecteer vervolgens OK- om het dialoogvenster te sluiten.
     • Klik op OK om het dialoogvenster van de containerapps-omgeving te sluiten.
   • Selecteer Maken om het dialoogvenster voor oorspronkelijke container-apps te sluiten. Visual Studio maakt de container-app-resource in Azure.

5. Zodra de resource is gemaakt, controleert u of deze is geselecteerd in de lijst met container-apps en selecteert u vervolgens Volgende.

6. Je moet een Azure containerregister maken om het gepubliceerde image-artifact voor je app op te slaan. Selecteer het groene + pictogram op het scherm Container Registry.

   

7. Laat de standaardwaarden staan en selecteer vervolgens maken.

8. Nadat het containerregister is gemaakt, controleert u of het is geselecteerd en selecteert u vervolgens volgende.

9. In het scherm Implementatietype, selecteer CI/CD met gebruik van GitHub Actions workflows (genereert yml-bestand) en kies vervolgens Voltooien. Als u in Visual Studio wordt gevraagd om de gebruiker met beheerdersrechten toegang te geven tot de gepubliceerde Docker-container, selecteert u Ja.

Visual Studio maakt en geeft het publicatieprofiel weer. De meeste publicatiestappen en -details worden beschreven in het GitHub Actions .yml-bestand. Dit bestand kan worden weergegeven door te klikken op de knop Werkstroom bewerken in de overzichtsweergave van het publicatieprofiel. Dit bestand wordt verderop in het artikel uitgebreider behandeld.

De Azure SQL Database maken

1. Klik in de "Solution Explorer" met de rechtermuisknop op het knooppunt Connected Services en selecteer SQL Server Database toevoegen >.
2. Selecteer in het dialoogvenster Verbinding maken met afhankelijkheid de Azure SQL Database en kies vervolgens Volgende.
3. Selecteer + Nieuwe maken om een nieuwe database toe te voegen.
4. Voer in het dialoogvenster Azure SQL Database de volgende waarden in:
   • databasenaam: laat de standaardwaarde staan.
   • abonnementsnaam: selecteer hetzelfde abonnement als eerder.
   • Resourcegroep: Selecteer dezelfde msdocs-app-db-ef groep die u eerder hebt gemaakt.
   • Databaseserver: Selecteer Nieuw... en voer vervolgens de volgende waarden in het nieuwe POP-upvenster in:
     • databaseservernaam: voer een unieke servernaam in of voeg willekeurige getallen toe aan het einde van de automatisch gegenereerde naam.
     • Locatie: Selecteer een locatie die zich dicht bij u in de buurt bevindt.
     • gebruikersnaam van de beheerder: voer een waarde van uw keuze in.
     • administratorwachtwoord: voer een waarde van uw keuze in.
     • administratorwachtwoord (bevestigen): voer hetzelfde wachtwoord in om te bevestigen. Selecteer OK- om het dialoogvenster SQL Server te sluiten
   • Selecteer Maken om de SQL Server en database te maken.
   • Wanneer de bewerking is voltooid, selecteert u de server in de lijst en kiest u Volgende
5. Laat in het dialoogvenster Verbinding maken met Azure SQL Database de standaardwaarden staan, maar zorg ervoor dat onderaan Geen is geselecteerd bij de optie Verbindingsreekswaarde opslaan in.
6. Selecteer Voltooien en Visual Studio maakt de SQL-resources aan.

De container-app verbinden met Azure SQL

1. Selecteer op de overzichtspagina van de container-app die u hebt gemaakt Service Connector (Preview) in het linkernavigatiemenu.

2. Selecteer + maken om een nieuwe verbinding te maken.

3. Voer in het uitklapmenu Verbinding maken de volgende waarden in:

   • Container: Selecteer de dotnetcoresqldb-container die u hebt gemaakt.

   • Servicetype: selecteer SQL Database.

   • abonnement: Selecteer hetzelfde abonnement dat u hebt gebruikt om de container-app te maken.

   • verbindingsnaam: laat de standaardwaarde staan.

   • SQL Server: Selecteer de databaseserver die u eerder hebt gemaakt.

   • SQL-database: Selecteer de database die u eerder hebt gemaakt.

   • Clienttype: Selecteer .NET-.

     

4. Selecteer Volgende: Verificatie en voer de volgende waarden in:

   • Selecteer verbindingsreeks voor het verificatietype.
   • gebruikersnaam: Voer de gebruikersnaam in die u hebt gebruikt bij het maken van de databaseserver.
   • wachtwoord: voer het wachtwoord in dat u hebt gebruikt bij het maken van de databaseserver.

5. Laat de rest van de instellingen op de standaardinstelling staan en selecteer Volgende: Netwerken.

6. Laat de standaardwaarde geselecteerd en kies Volgende: Controleren enmaken.

7. Nadat Azure de instellingen gevalideerd heeft, selecteer Maken.

Na een ogenblik wordt de verbinding met de SQL-database weergegeven. Selecteer de pijl om de verbinding uit te vouwen en de AZURE_SQL_CONNECTIONSTRING waarde weer te geven. Deze verbindingsnaam komt overeen met de naam van de verbindingsreeks voor de omgevingsvariabele die is gedefinieerd in de voorbeeld-app.

De GitHub Actions-werkstroom configureren

Het werkstroombestand van GitHub Actions dat door Visual Studio wordt gegenereerd, kan worden gebruikt door GitHub om de app te bouwen en te implementeren in Azure wanneer wijzigingen worden gepusht. Dit proces werkt momenteel, maar de geïmplementeerde app genereert een uitzondering. Hoewel de Azure SQL-database is gemaakt, moet er een stap worden toegevoegd aan de GitHub Actions-werkstroom om het schema te genereren. De verbindingsreeks voor de Azure SQL-database kan veilig worden opgeslagen als geheim in GitHub en worden opgehaald door de werkstroom wanneer deze wordt uitgevoerd.

Haal de verbindingsreeks op en voeg deze toe aan GitHub-geheimen

1. Zoek in Azure Portal naar de database die u hebt gemaakt in de hoofdzoekbalk en selecteer deze in de resultaten.

2. Selecteer op de overzichtspagina van de database verbindingsreeksen in het linkernavigatievenster.

3. Kopieer op het tabblad ADO.NET de verbindingsreeks uit het formulierveld.

   

4. Navigeer naar de forked GitHub-opslagplaats van de app.

5. Selecteer op het tabblad InstellingenGeheimen > Acties in het linkernavigatievenster en kies vervolgens Nieuw opslagplaatsgeheim.

6. Voer op de pagina Nieuw geheim de volgende waarden in:

   • naam: voer een naam van DbConnectionin.

   • Geheim: plak de connectiestring die u uit Azure hebt gekopieerd. Zorg ervoor dat u de tijdelijke aanduiding voor het wachtwoord in de verbindingsreeks vervangt door het wachtwoord dat u hebt gekozen bij het maken van de database.

   • Selecteer Geheimetoevoegen.

     

De verbindingsreeks wordt nu veilig opgeslagen in de geheimen van de GitHub-opslagplaats en kan worden opgehaald met behulp van een GitHub-werkstroom.

De GitHub Actions-werkstroom wijzigen om migraties in te schakelen

1. Open het GitHub Actions-werkstroom .yml bestand dat door Visual Studio is gegenereerd door op de overzichtspagina van de publicatie de knop Werkstroom bewerken te selecteren.

   

2. Voeg de volgende yaml toe aan het einde van het werkstroombestand:

   - name: Run EF 
     run: | 
       dotnet tool install --global dotnet-ef
       dotnet tool restore
       dotnet ef database update -p DotNetCoreSqlDb --connection '${{ secrets.DBConnection }}'
   

   Met deze code worden de opdrachtregelprogramma's voor het entity framework geïnstalleerd en worden de app-migraties uitgevoerd. Wanneer de werkstroom wordt uitgevoerd, gebruikt de code ook de parameter connection van de opdracht database update om de verbindingsreeks localdb te overschrijven, die is opgeslagen in het bestand appsettings.json, met de waarde die is toegevoegd aan GitHub Secrets.

De GitHub Actions-werkstroom uitvoeren en de implementatie testen

1. Voer de wijzigingen door in de toepassing en push naar de geforkte repository met behulp van het volgende commando:

   git add --all
   git commit -m "Added GitHub Actions workflow"
   git push
   

2. Navigeer naar de GitHub-opslagplaats en selecteer het tabblad Acties. Een werkstroomuitvoering moet automatisch zijn geactiveerd als de push is geslaagd.

3. Selecteer de actieve werkstroom om de logboekdetails voor elke stap weer te geven wanneer deze zijn voltooid. De migratie wordt voor het laatst uitgevoerd om de database in Azure bij te werken.

   

Nadat de werkstroom is voltooid, wordt de toepassing geïmplementeerd in Azure Container Apps en verbonden met de database met een bijgewerkt schema.

U kunt de implementatie testen door naar de startpagina van de container-app te gaan en een TODO te maken, net zoals u lokaal hebt gedaan. U kunt altijd de URL naar uw container-app vinden op de overzichtspagina voor de app in Azure Portal.