Självstudie: Distribuera en ASP.NET-app med Azure SQL Database till Azure

2025-06-27

Med Azure App Service får du en automatiskt uppdaterad webbvärdtjänst med hög skalbarhet. Den här självstudien visar hur du distribuerar en datadriven ASP.NET-app i App Service och ansluter den till Azure SQL Database.

När du är klar med självstudien har du en ASP.NET app som är ansluten till en Azure SQL-databas som körs i Azure. I följande exempel visas appgränssnittet.

Skärmbild som visar ett publicerat ASP.NET program i Azure App Service.

I den här handledningen kommer du att:

Publicera en datadriven webbapp till Azure.
Skapa en Azure SQL-databas för att lagra appdata.
Anslut ASP.NET-appen till Azure SQL-databasen.
Konfigurera en hanterad identitet och Microsoft Entra-ID-autentisering för databasanslutningen.
Uppdatera datamodellen och distribuera om appen.
Strömma programloggar från Azure till Visual Studio.

Förutsättningar

Om du inte har något Azure-konto skapar du ett kostnadsfritt konto innan du börjar.
Installera Visual Studio 2022 med arbetsbelastningarna ASP.NET och webbutveckling och Azure Development .
- Du kan lägga till arbetsbelastningarna i en befintlig Visual Studio-installation genom att välja Hämta verktyg och funktioner på Visual Studio Tools-menyn .
- Kontrollera att du har de senaste uppdateringarna för Visual Studio 2022 genom att välja Hjälp>sök efter uppdateringar och installera den senaste versionen om det behövs.

Skapa och köra appen

Exempelprojektet innehåller en grundläggande ASP.NET CRUD-app (create-read-update-delete) som använder Entity Framework Code First.

Ladda ned exempelprojektet och extrahera filendotnet-sqldb-tutorial-master.zip .
Öppna den extraherade filen dotnet-sqldb-tutorial-master/DotNetAppSqlDb.sln i Visual Studio.
Tryck på F5 för att köra appen och öppna den i standardwebbläsaren.

Kommentar

Installera eventuella NuGet-paket som saknas om det behövs.
I appen väljer du Skapa ny och skapar ett par to-do objekt.
Testa länkarna Edit (Redigera), Details (Information) och Delete (Ta bort).

Publicera appen till Azure

Om du vill publicera appen till Azure skapar och konfigurerar du en Publiceringsprofil som har en Azure App Service- och App Service-plan som värd för appen. Sedan skapar du en Azure SQL Server- och Azure SQL-databas som innehåller appdata och konfigurerar en databaskontext för att ansluta appen till databasen.

Högerklicka på Projektet DotNetAppSqlDb i Visual Studio Solution Explorer och välj Publicera.
På skärmen Publicera väljer du Azure som mål och väljer Nästa.
På nästa skärm kontrollerar du att Azure App Service (Windows) är valt och väljer Nästa.

På nästa publiceringsskärm loggar du in på ditt Microsoft-konto och den prenumeration som du vill använda.
Bredvid App Service väljer du Skapa ny.

Konfigurera Azure App Service

På skärmen App Service (Windows) konfigurerar du App Service Namn, resursgruppen och Hostingplanen.
Under Namn kan du behålla det genererade webbappnamnet eller ändra det till ett annat namn med tecknen a-z, 0-9och -. Webbappens namn måste vara unikt för alla Azure-appar.
Bredvid Resursgrupp väljer du Ny och namnger resursgruppen myResourceGroup.

En resursgrupp är en logisk container där Azure-resurser, till exempel webbappar, databaser och lagringskonton, distribueras och hanteras. Du kan exempelvis välja att ta bort hela resursgruppen i ett enkelt steg längre fram.
Bredvid Värdplan väljer du Ny.

En App Service-plan anger plats, storlek och funktioner för webbservergruppen som är värd för din app. Du kan spara pengar när du är värd för flera appar genom att konfigurera webbapparna så att de delar en enda App Service-plan.

App Service-planer definierar följande:
- Region (till exempel: Europa, norra; USA, östra; Asien, sydöstra m.m.)
- Instansstorlek (liten, medel eller stor)
- Skalningsantal (1 till 20 instanser)
- SKU (Kostnadsfri, Delad, Basic, Standard eller Premium)

Fyll i Hostingplan och tryck sedan på OK.

Inställning	Föreslaget värde	Mer information
App Service-plan	myAppServicePlan	App Service-planer
Plats	Östra USA	Azure-regioner
Storlek	Gratis	Prisnivåer

Skärmbild som visar hur du skapar värdplanen.

På skärmen App Service (Windows) väljer du Skapa och väntar tills Azure-resurserna har skapats.
På skärmen Publicera visas de resurser som du har konfigurerat. Välj Slutföroch välj sedan Stäng.

Skapa en server och en databas

Innan du kan skapa en databas behöver du en logisk SQL-server. En logisk SQL-server är en logisk konstruktion som innehåller en grupp databaser som hanteras som en grupp.

På skärmen Publicera för DotNetAppSqlDb-appen går du till avsnittet Tjänstberoenden , väljer ellipsen ... bredvid SQL Server Database och väljer Anslut.

Kommentar

Se till att konfigurera SQL Database från fliken Publicera , inte fliken Anslutna tjänster .
På skärmen Anslut till beroende väljer du Azure SQL Database och sedan Nästa.
På skärmen Konfigurera Azure SQL Database väljer du Skapa ny.
På skärmen Azure SQL Database bredvid Databasservern väljer du Ny.
Ändra servernamnet till ett värde som du vill ha. Servernamnet måste vara unikt för alla servrar i Azure SQL.
Välj OK.
På skärmen Azure SQL Database behåller du det standardgenererade databasnamnet. Välj Skapa och vänta tills databasresurserna har skapats.
När databasresurserna skapas väljer du Nästa.
På skärmen Anslut till Azure SQL Database väljer du Slutför.

Kommentar

Om du ser filer med lokala användarhemligheter i stället kontrollerar du att du använde sidan Publicera , inte sidan Anslutna tjänster , för att konfigurera SQL Database.

Din Azure SQL Database-anslutning har nu konfigurerats för att använda Hanterad identitet för Azure-tjänster, en säker metod för att ansluta din app till dina Azure-resurser som inte använder hemligheter eller lösenord. Nu måste du ange lämpliga behörigheter för DEN SQL-användare som motsvarar den hanterade identiteten för att anslutningen ska fungera.

Konfigurera hanterad identitet

När guiden skapa Azure SQL Database konfigurerade Azure SQL-servern med en hanterad identitet och Standardautentisering för Entra-ID lade den till ditt Entra-ID-konto som Azure SQL-administratör. Om du är inloggad på samma konto i Visual Studio kan du använda samma anslutningssträng för att ansluta till databasen i både Visual Studio och Azure.

På menyn Verktyg väljer du NuGet Package Manager>Package Manager Console.

Installera följande paket i Package Manager-konsolen:

Install-Package Microsoft.Data.SqlClient
Install-Package Microsoft.EntityFramework.SqlServer

På en PowerShell-kommandorad kör du följande kommando för att logga in på SQL Database, ersätter <server-name> med servernamnet och <entra-id-user> med det Microsoft Entra-användarnamn som du använde för att konfigurera databasen i Visual Studio. Entra-användaren har administratörsåtkomst till databasservern som standard.
```
sqlcmd -S <servername>.database.windows.net -d DotNetAppSqlDb_db -U <entra-id-user> -G -l 30
```
Följ anvisningarna för att logga in.

I SQL-prompten kör du följande kommandon för att bevilja de minsta behörigheter som din app behöver, och <app-name> ersätt med ditt appnamn.

CREATE USER [<app-name>] FROM EXTERNAL PROVIDER;
ALTER ROLE db_datareader ADD MEMBER [<app-name>];
ALTER ROLE db_datawriter ADD MEMBER [<app-name>];
ALTER ROLE db_ddladmin ADD MEMBER [<app-name>];
GO

Uppdatera databaskontexten

Appen använder en databaskontext för att ansluta till databasen, som refereras till i filen Models/MyDatabaseContext.cs . I det här avsnittet uppdaterar du koden för att referera till Entity Framework 6 SQL Server-providern, som är beroende av den moderna Microsoft.Data.SqlClient-ADO.NET-providern .

Entity Framework 6-providern ersätter den inbyggda System.Data.SqlClient SQL Server-providern och har stöd för Microsoft Entra ID-autentiseringsmetoder. Mer information finns i Microsoft.EntityFramework.SqlServer}.

[DbConfigurationType(typeof(MicrosoftSqlDbConfiguration))] fungerar lokalt för att använda Microsoft.Data.SqlClient för databaskontexten, men eftersom System.Data.SqlClient är hårdkodad som leverantör i Azure App Service, måste du utöka MicrosoftSqlDbConfiguration för att omdirigera referenser till System.Data.SqlClient till Microsoft.Data.SqlClient istället.

I web.configtar du bort entityFramework/providers/provider avsnittet och raden: <provider invariantName="System.Data.SqlClient" .../>.

Lägg till följande klass i Modeller/MyDatabaseContext.cs:

    public class AppServiceConfiguration : MicrosoftSqlDbConfiguration
    {
        public AppServiceConfiguration()
        {
            SetProviderFactory("System.Data.SqlClient", Microsoft.Data.SqlClient.SqlClientFactory.Instance);
            SetProviderServices("System.Data.SqlClient", MicrosoftSqlProviderServices.Instance);
            SetExecutionStrategy("System.Data.SqlClient", () => new MicrosoftSqlAzureExecutionStrategy());
        }
    }

Lägg till följande attribut i klassdeklarationen MyDatabaseContext :
```
[DbConfigurationType(typeof(AppServiceConfiguration))]
```

Implementera ASP.NET-appen

Längst upp på fliken Publicera väljer du Publicera. Din ASP.NET-app distribueras till Azure och standardwebbläsaren startar till URL:en för den distribuerade appen.
Om du vill testa appen lägger du till några to-do objekt.

Grattis! Din datadrivna ASP.NET-app körs live i Azure App Service.

Använda SQL Server Object Explorer

Du kan använda Visual Studio SQL Server Object Explorer för att enkelt utforska och hantera din Azure SQL-databas. I SQL Server Object Explorer kan du utföra de vanligaste databasåtgärderna, till exempel att köra frågor eller skapa tabeller, vyer och lagrade procedurer.

Tillåta klientanslutning från datorn

Som standard tillåter Azure-servern endast anslutningar till sina databaser från Azure-tjänster, till exempel din Azure-app. Den nya databasen öppnade brandväggen för App Service-appen som du skapade.

För att få åtkomst till databasen från den lokala datorn, till exempel från Visual Studio, måste Azure-servern öppna brandväggen för att tillåta åtkomst för datorns offentliga IP-adress.

Om du uppmanas att lägga till åtkomst för din lokala klient måste du välja alternativet Tillåt datorns offentliga IP-adress. Det här alternativet skapar en brandväggsregel för att tillåta den offentliga IP-adressen för den lokala datorn. Dialogrutan är redan ifylld med datorns aktuella IP-adress.

Om du inte får en uppmaning om att lägga till åtkomst för den lokala datorn kan du gå till Din Azure SQL-databas i Azure-portalen och välja Ange serverbrandvägg på den översta menyraden. På sidan Nätverk under Brandväggsregler väljer du alternativet Lägg till din klient-IPv4-adress.

Kommentar

Om internetleverantören ändrar din offentliga IP-adress måste du konfigurera om brandväggen för att få åtkomst till Azure-databasen igen.

Ansluta till Azure SQL-databasen lokalt

Gå till Visa-menyn och välj SQL Server Object Explorer.
Längst upp i fönstret SQL Server Object Explorer väljer du ikonen för att lägga till SQL Server.
På skärmen Anslut visas anslutningen under Azure-noden. Fyll i informationen för servernamn, användarnamn, lösenord och databasnamn och välj Anslut.
När Visual Studio har konfigurerat anslutningen för SQL Database-instansen visas databasen i SQL Server Object Explorer. Expandera <anslutningsnamnet>>Databaser><databasnamnet>> för att se data.
Expandera Tabeller, högerklicka på ToDoes tabellen och välj Visa data för att interagera med databasdata.

Uppdatera appen med Code First Migrations

Du kan använda välbekanta verktyg i Visual Studio för att uppdatera din databas och app i Azure. I det här steget använder du Code First Migrations i Entity Framework för att ändra databasschemat och publicera ändringen till Azure.

Mer information om att använda Entity Framework Code First Migrations finns i artikeln om att komma igång med Entity Framework 6 Code First med MVC 5.

Uppdatera datamodellen

Öppna Models\Todo.cs i kodredigeraren. Lägg till följande egenskap i klassen ToDo:

public bool Done { get; set; }

Kör Code First Migrations lokalt

Kör några kommandon och gör uppdateringar i den lokala databasen.

På menyn Verktyg väljer du NuGet Package Manager>Package Manager Console.
Aktivera Code First Migrations i fönstret Package Manager-konsolen:
```
Enable-Migrations
```
Lägg till en migrering:
```
Add-Migration AddProperty
```
Uppdatera den lokala databasen:
```
Update-Database
```
Kör appen genom att trycka på Ctrl+F5 . Testa länkarna Redigera, Information och Skapa ny .

Om applikationen läses in utan några fel har Code First Migrations lyckats. Sidan ser dock fortfarande likadan ut eftersom programlogik inte använder den här nya egenskapen ännu.

Använda den nya egenskapen

Gör några ändringar i koden för att se egenskapen Done i praktiken. I den här självstudien ändrar du bara vyerna Index och Create för att använda den nya egenskapen.

Öppna Controllers\TodosController.cs och lägg till Create() i listan med egenskaper i Done attributet i Bind metoden på rad 52. Din Create() metodsignatur bör se ut som följande kod:
```
public ActionResult Create([Bind(Include = "Description,CreatedDate,Done")] Todo todo)
```

Öppna Views\Todos\Create.cshtml och notera elementet <div class="form-group"> som använder model.Description och elementet <div class="form-group"> som använder model.CreatedDatei Razor-koden.

Efter dessa två element lägger du till följande <div class="form-group"> element som använder model.Done:

<div class="form-group">
    @Html.LabelFor(model => model.Done, htmlAttributes: new { @class = "control-label col-md-2" })
    <div class="col-md-10">
        <div class="checkbox">
            @Html.EditorFor(model => model.Done)
            @Html.ValidationMessageFor(model => model.Done, "", new { @class = "text-danger" })
        </div>
    </div>
</div>

Öppna Views\Todos\Index.cshtml och lägg till följande Razor-kod precis ovanför det tomma <th></th> elementet:
```
<th>
    @Html.DisplayNameFor(model => model.Done)
</th>
```
Ovanför elementet <td> som innehåller hjälpmetoderna Html.ActionLink() lägger du till ett annat <td> element med följande Razor-kod:
```
<td>
    @Html.DisplayFor(modelItem => item.Done)
</td>
```
Spara alla filer och tryck på Ctrl+F5 för att köra appen.
Lägg till ett to-do objekt i appen och välj Klar. Objektet ska visas på startsidan som ett slutfört objekt. Vyn Redigera visar inte fältet Klar eftersom du inte ändrade vyn Redigera .

Aktivera Code First Migrations i Azure

Nu när kodändringen fungerar, inklusive databasmigrering, kan du publicera den till din Azure-app och uppdatera din Azure SQL-databas med Code First Migrations också.

I Visual Studio Solution Explorer högerklickar du på projektet och väljer Publicera.
Välj Fler åtgärder>Redigera för att öppna publiceringsinställningarna.
I listrutan MyDatabaseContext väljer du databasanslutningen för din Azure SQL-databas.
Välj Kör kod första migreringar (körs vid programstart)och välj sedan Spara.

Publicera dina ändringar

Nu när du har aktiverat Code First Migrations i Azure-appen kan du publicera kodändringarna.

På sidan Publicera väljer du Publicera.
I den publicerade webbappen kan du försöka lägga till fler to-do objekt igen och välja Klar. De bör visas på startsidan som slutförda objekt.

Alla befintliga att-göra-uppgifter visas fortfarande. När du publicerar om ditt ASP.NET program går inte befintliga data i Azure SQL-databasen förlorade. Code First Migrations ändrar bara dataschemat och lämnar dina data intakta.

Strömma programloggar

Du kan strömma spårningsmeddelanden direkt från din Azure-app till Visual Studio.

Öppna Controllers\TodosController.cs och observera att varje åtgärd börjar med en Trace.WriteLine() metod. Den här koden visar hur du lägger till spårningsmeddelanden i din Azure-app.

Aktivera loggströmning

På sidan Publicera i Visual Studio skrollar du ned till avsnittet Hostingmiljö.
Välj ellipsen ... uppe till höger och välj Visa strömmande loggar.

Loggarna strömmas nu till fönstret Output (Utdata).

Du ser inga spårningsmeddelanden ännu, för när du först väljer Visa strömmande loggar anger Din Azure-app spårningsnivån till Error, som endast loggar felhändelser med hjälp av Trace.TraceError() metoden.

Ändra spårningsnivåer

Om du vill ändra efterföljningsnivåer för att mata ut andra meddelanden, gå till avsnittet Hostingtjänsten på sidan Publicera, välj ... längst upp till höger och välj sedan Öppna i Azure-portalen.
På sidan Azure-portalen för din app väljer du App Service-loggar under Övervakning på den vänstra menyn.
Under Programloggning (Filsystem) väljer du Utförlig under Nivå och väljer sedan Spara.

Dricks

Du kan experimentera med olika spårningsnivåer och se vilka typer av meddelanden som visas för varje nivå. Till exempel omfattar nivån Information alla loggar som skapats av Trace.TraceInformation(), Trace.TraceWarning() och Trace.TraceError(), men inte loggar som skapats av Trace.WriteLine().

I webbläsaren går du till ditt Azure to-do listprogram igen och navigerar runt i appen. Spårningsmeddelanden som i följande exempel strömmas nu till Output-fönstret i Visual Studio.

Application:2025-05-12T23:41:11  PID[17108] Verbose     GET /Todos/Index
Application:2025-05-12T23:42:04  PID[17108] Verbose     GET /Todos/Index
Application:2025-05-12T23:42:06  PID[17108] Verbose     POST /Todos/Create
Application:2025-05-12T23:42:07  PID[17108] Verbose     GET /Todos/Index

Stoppa loggströmning

Om du vill stoppa loggströmningstjänsten väljer du ikonen Stoppa övervakning i fönstret Utdata .

Skärmbild som visar Stoppa loggströmning.

Rensa resurser

I de föregående stegen skapade du Azure-resurser i en resursgrupp. Om du inte tror att du behöver dessa resurser i framtiden, kan du ta bort dem genom att ta bort resursgruppen.

Från ditt webbprograms Översiktsida i Azure portal väljer du länken myResourceGroup under resursgruppen.
Kontrollera att resurser på resursgruppsidan är de som du vill ta bort.
Välj Ta bort resursgrupp, skriv myResourceGroup i textrutan och välj sedan Ta bort.
Bekräfta igen genom att välja Ta bort.

Gå till nästa handledning för att lära dig använda hanterad identitet för att förbättra säkerheten för anslutningar till Azure SQL Database.

Självstudie: Ansluta till SQL Database från App Service utan hemligheter med hjälp av en hanterad identitet

Feedback

Var den här sidan till hjälp?