Självstudie: Distribuera en ASP.NET Core-app och databas till Azure Container Apps med GitHub Actions

I den här självstudien får du lära dig hur du distribuerar en ASP.NET Core-app och SQL Database till Azure Container Apps med hjälp av Visual Studio och GitHub Actions. Du får också lära dig hur du hanterar Entity Framework-migreringar och databasuppdateringar i GitHub Actions, men begreppen kan också tillämpas på andra CI/CD-verktyg och miljöer.

Förutsättningar

Du behöver Visual Studio 2022 installerat med arbetsbelastningen ASP.NET och webbutveckling och Azure-utveckling .

Om du redan har installerat Visual Studio:

• Installera de senaste uppdateringarna i Visual Studio genom att välja Hjälp>sök efter uppdateringar.
• Kontrollera att arbetsbelastningarna ASP.NET och webbutveckling och Azure-utveckling har installerats genom att välja Verktyg>Hämta verktyg och funktioner.

Konfigurera exempelappen lokalt

Använd TODO-exempelappen för att följa med i den här självstudien. Klona appen från GitHub med följande kommando:

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

Navigera till projektmappen och öppna lösningen DotNetCoreSqlDb.sln i Visual Studio.

TODO-programmet är redo att köras, men du måste upprätta en anslutning till den localdb SQL Server som är tillgänglig i Visual Studio. Om du ansluter till localdb kan du köra appen och spara todos när du arbetar lokalt.

1. Högerklicka på noden Anslutna tjänster i Visual Studio Solution Explorer och välj Lägg till > SQL Server Database.
2. I dialogrutan Anslut till beroende väljer du SQL Server Express LocalDB (lokal) och väljer sedan Nästa.
3. I dialogrutan Anslut till SQL Server Express LocalDB (lokal) anger du följande värden:
   • Namn på anslutningssträng: Lämna standardvärdet.
   • Värde för anslutningssträng: Lämna standardvärdet.
   • Spara värdet för anslutningssträngen i: Välj Ingen.
   • Välj Nästa
4. På skärmen Sammanfattning av ändringar lämnar du inställningarna som standardvärden och väljer Slutför för att slutföra arbetsflödet.

Visual Studio visar en sammanfattning av tjänstberoendena, inklusive anslutningen till LocalDB.

Därefter måste du skapa en inledande migrering och använda den för att uppdatera den lokala databasen med rätt schema för TODO-appen.

1. Välj ikonen ... till höger om listan över tjänstberoenden bredvid LocalDB anslutningen och välj Lägg till migrering.
2. I dialogrutan Entity Framework Migrations (Entity Framework-migreringar ) väntar du en stund på att Visual Studio ska hitta klassen DbContext som ingår i projektet. När värdena har lästs in väljer du Slutför.
3. Visual Studio genererar en Migrations mapp i projektet och skapar en inledande migreringsklass. Den här klassen kan användas för att uppdatera databasen med rätt schema.
4. Välj ikonen ... bredvid LocalDB tjänsten igen och välj Uppdatera databas.
5. I dialogrutan Entity Framework-migreringar väntar du en stund på att Visual Studio ska hitta DbContext klassen igen och väljer sedan Slutför. Visual Studio kör migreringen och skapar schemat för databasen på LocalDB-servern.

Starta projektet genom att välja körknappen DotNetCoreSqlDb överst i Visual Studio.

När appen läses in kontrollerar du att databasen fungerar korrekt genom att ange en ny TODO. ToDO visas i huvudlistvyn på appens startsida.

Utforska appens startkonfiguration

Exempelappen innehåller följande kod i filen 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")));
}

Den här koden tillämpar följande konfigurationer:

• När appen körs lokalt hämtas localdb-anslutningssträngen från appsettings.json-filen och tillhandahålls till Entity Framework. Med den här konfigurationen kan localdb anslutningssträngen checkas in i källkontrollen så att andra utvecklare enkelt kan ansluta till en lokal databas under utvecklingen. Det gör också att Entity Framework-migreringar kan köras lokalt. Entity Framework identifierar som standard inte anslutningssträngar som lagras i miljövariabeln när migreringar körs.
• När appen körs i GitHub Actions-arbetsflöden eller i Produktion hämtas anslutningssträngen från miljövariabler. Miljövariabler kan förhindra att produktionssäkerhetsanslutningssträngar checkas in i källkontrollen eller inkluderas i konfigurationsfiler.

Skapa Azure-tjänsterna

Appen kräver att följande Azure-tjänster skapas för en lyckad distribution:

• Containerapp: Krävs för att vara värd för och köra det distribuerade programmet.
• Container Registry: Lagrar den skapade avbildningsartefakten för den containerbaserade appen.
• SQL Database: En Azure SQL-databas för att lagra appens data.

Publiceringsfunktionerna i Visual Studio kan hantera skapandet av dessa resurser åt dig.

Skapa Azure Container App och Azure Container Registry

1. I Visual Studio Solution Explorer högerklickar du på projektnoden på den översta nivån och väljer Publicera.

2. I publiceringsdialogrutan väljer du Azure som distributionsmål och väljer sedan Nästa.

3. För det specifika målet väljer du Azure Container Apps (Linux) och sedan Nästa.

4. Skapa en ny containerapp att distribuera till. Välj knappen + Skapa ny för att öppna en ny dialogruta och ange följande värden:

   

   • Namn på containerapp: Lämna standardvärdet eller ange ett namn.
   • Prenumerationsnamn: Välj den prenumeration som du vill distribuera till.
   • Resursgrupp: Välj Ny och skapa en ny resursgrupp med namnet msdocs-app–db-ef.
   • Miljö för containerappar: Välj Ny för att öppna miljödialogrutan för containerappar och ange följande värden:
     • Miljönamn: Behåll standardvärdet.
     • Plats: Välj en plats nära dig.
     • Azure Log Analytics-arbetsyta: Välj Ny för att öppna dialogrutan Log Analytics-arbetsyta.
       • Namn: Lämna standardvärdet.
       • Plats: Välj en plats nära dig och välj sedan Ok för att stänga dialogrutan.
     • Välj Ok för att stänga dialogrutan för containerappsmiljön.
   • Välj Skapa för att stänga dialogrutan med ursprungliga containerappar. Visual Studio skapar containerappresursen i Azure.

5. När resursen har skapats kontrollerar du att den är markerad i listan över containerappar och väljer sedan Nästa.

6. Du måste skapa ett Azure Container Registry för att lagra den publicerade bildartefakten för din app. Välj den gröna + ikonen på skärmen Container Registry .

   

7. Lämna standardvärdena och välj sedan Skapa.

8. När containerregistret har skapats kontrollerar du att det är valt och väljer sedan nästa.

9. På skärmen Distributionstyp väljer du CI/CD med GitHub Actions-arbetsflöden (genererar yml-fil) och väljer sedan Slutför. Om Visual Studio uppmanar dig att ge administratörsanvändaren åtkomst till den publicerade Docker-containern väljer du Ja.

Visual Studio skapar och visar publiceringsprofilen. De flesta publiceringssteg och information beskrivs i GitHub Actions-filen .yml , som kan visas genom att klicka på knappen Redigera arbetsflöde i sammanfattningsvyn för publiceringsprofilen. Den här filen beskrivs mer ingående senare i artikeln.

Skapa Azure SQL Database

1. Högerklicka på noden Anslutna tjänster i Solution Explorer och välj Lägg till > SQL Server Database.
2. I dialogrutan Anslut till beroende väljer du Azure SQL Database och sedan Nästa.
3. Välj + Skapa ny för att lägga till en ny databas.
4. I dialogrutan Azure SQL Database anger du följande värden:
   • Databasnamn: Lämna standardvärdet.
   • Prenumerationsnamn: Välj samma prenumeration som tidigare.
   • Resursgrupp: Välj samma msdocs-app-db-ef grupp som skapades tidigare.
   • Databasserver: Välj Ny... och ange sedan följande värden i det nya popup-fönstret:
     • Databasservernamn: Ange ett unikt servernamn eller lägg till slumpmässiga tal i slutet av det autogenererade namnet.
     • Plats: Välj en plats som ligger nära dig.
     • Administratörsanvändarnamn: Ange ett värde som du väljer.
     • Administratörslösenord: Ange ett värde som du väljer.
     • Administratörslösenord (bekräfta): Ange samma lösenord för att bekräfta. Välj OK för att stänga SQL Server-dialogrutan
   • Välj Skapa för att skapa SQL Server och databasen.
   • När åtgärden är klar väljer du servern i listan och väljer Nästa
5. I dialogrutan Anslut till Azure SQL Database lämnar du standardvärdena, men se till att Ingen har valts längst ned för alternativet Spara anslutningssträng.
6. Välj Slutför så skapar Visual Studio SQL-resurserna.

Ansluta containerappen till Azure SQL

1. På översiktssidan för containerappen som du skapade väljer du Service Connector (förhandsversion) i det vänstra navigeringsfältet.

2. Välj + Skapa för att skapa en ny anslutning.

3. I den utfällbara menyn Skapa anslutning anger du följande värden:

   • Behållare: Välj containern dotnetcoresqldb som du skapade.

   • Tjänsttyp: Välj SQL Database.

   • Abonnemang: Välj samma prenumeration som du använde för att skapa containerappen.

   • Anslutningsnamn: Lämna standardvärdet.

   • SQL Server: Välj den databasserver som du skapade tidigare.

   • SQL-databas: Välj den databas som du skapade tidigare.

   • Klienttyp: Välj .NET.

     

4. Välj Nästa: Autentisering och ange följande värden:

   • Välj Anslutningssträng för autentiseringstypen.
   • Användarnamn: Ange det användarnamn som du använde när du skapade databasservern.
   • Lösenord: Ange det lösenord som du använde när du skapade databasservern.

5. Låt resten av inställningarna vara som standard och välj Nästa: Nätverk.

6. Låt standardvärdet vara markerat och välj Nästa: Granska + Skapa.

7. När Azure har validerat inställningarna, välj Skapa.

Efter en stund bör anslutningen till SQL-databasen visas. Välj pilen för att expandera anslutningen och se värdet AZURE_SQL_CONNECTIONSTRING . Det här anslutningsnamnet matchar namnet på miljövariabelns anslutningssträng som definierats i exempelappen.

Konfigurera GitHub Actions-arbetsflödet

GitHub Actions-arbetsflödesfilen som genereras av Visual Studio kan användas av GitHub för att skapa och distribuera appen till Azure när ändringarna skickas. För närvarande skulle den här processen fungera, men den distribuerade appen skulle generera ett undantag. Även om Azure SQL-databasen skapades måste ett steg läggas till i GitHub Actions-arbetsflödet för att generera schemat. Anslutningssträngen för Azure SQL-databasen kan lagras säkert som en hemlighet i GitHub och hämtas av arbetsflödet när den körs.

Hämta anslutningssträngen och lägg till den i GitHub-hemligheter

1. I Azure-portalen söker du efter databasen som du skapade i huvudsökfältet och väljer den i resultatet.

2. På sidan databasöversikt väljer du Anslutningssträngar i det vänstra navigeringsfältet.

3. På fliken ADO.NET kopierar du anslutningssträngen från formulärfältet.

   

4. Navigera till den förgrenade GitHub-lagringsplatsen för appen.

5. Under fliken Inställningar väljer du Hemligheter > åtgärder i det vänstra navigeringsfältet och väljer sedan Ny lagringsplatshemlighet.

6. På sidan Ny hemlighet anger du följande värden:

   • Namn: Ange namnet DbConnection.

   • Hemlig: Klistra in anslutningssträngen som kopierats från Azure. Ersätt platshållaren för lösenord i anslutningssträngen med det lösenord du valde när du skapade databasen.

   • Välj Lägg till hemlighet.

     

Anslutningssträngen lagras nu på ett säkert sätt i GitHub-lagringsplatsens hemligheter och kan hämtas med hjälp av ett GitHub-arbetsflöde.

Ändra GitHub Actions-arbetsflödet för att aktivera migreringar

1. Öppna gitHub Actions-arbetsflödesfilen .yml som genererats av Visual Studio genom att välja knappen Redigera arbetsflöde på sidan för publiceringssammanfattning.

   

2. Lägg till följande yaml i slutet av arbetsflödesfilen:

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

   Den här koden installerar entitetsramverkets kommandoradsverktyg och kör appmigreringarna. När arbetsflödet körs använder koden också parametern connection av kommandot database update för att åsidosätta anslutningssträngen localdb som lagras i filen appsettings.json med det värde som har lagts till i GitHub-sekreten.

Kör GitHub Actions-arbetsflödet och testa distributionen

1. Genomför ändringarna i programmet och skicka till den förgrenade lagringsplatsen med hjälp av följande kommando:

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

2. Gå till GitHub-lagringsplatsen och välj fliken Åtgärder . En arbetsflödeskörning ska ha utlösts automatiskt om push-överföringen lyckades.

3. Välj det aktiva arbetsflödet för att visa logginformationen för varje steg när de slutförs. Migreringen körs senast för att uppdatera databasen i Azure.

   

När arbetsflödet har slutförts distribueras programmet till Azure Container Apps och ansluts till databasen med ett uppdaterat schema.

Du kan testa distributionen genom att gå till startsidan för containerappen och skapa en TODO, precis som du gjorde lokalt. Du hittar alltid URL:en till containerappen på översiktssidan för appen i Azure-portalen.