Självstudie: Skapa en ASP.NET Core och Azure SQL Database-app i Azure App Service

I den här guiden får du lära dig att:

Om du inte har en Azure-prenumerationkan du skapa ett kostnads fritt konto innan du börjar.

Förutsättningar

För att slutföra den här kursen behöver du:

• Installera Git
• Installera den senaste .NET 5.0 SDK

• Använd bash-miljön i Azure Cloud Shell.

  

• Om du vill kan du i stället installera Azure CLI för att köra CLI-referenskommandon.

  • Om du använder en lokal installation loggar du in på Azure CLI med hjälp av kommandot az login. Slutför autentiseringsprocessen genom att följa stegen som visas i terminalen. Fler inloggningsalternativ finns i Logga in med Azure CLI.

  • När du uppmanas till det installerar du Azure CLI-tillägg vid första användning. Mer information om tillägg finns i Använda tillägg med Azure CLI.

  • Kör az version om du vill hitta versionen och de beroende bibliotek som är installerade. Om du vill uppgradera till den senaste versionen kör du az upgrade.

Skapa en lokal ASP.NET Core-app

I det här steget konfigurerar du det lokala ASP.NET Core-projektet.

Klona exempelprogrammet

1. Använd kommandot cd för att komma till en arbetskatalog i terminalfönstret.

2. Kör följande kommandon för att klona exempellagringsplatsen och ändra dess rot.

   git clone https://github.com/azure-samples/dotnetcore-sqldb-tutorial
   cd dotnetcore-sqldb-tutorial
   

   Exempelprojektet innehåller en grundläggande CRUD-app (create-read-update-delete) med Entity Framework Core.

3. Kontrollera att standardgrenen är main .

   git branch -m main
   

   Tips

   Ändringen av grennamnet krävs inte av App Service. Men eftersom många lagringslager ändrar sin standardgren till (se Ändra distributionsgren ), visar den här självstudien också hur du main distribuerar en lagringsplats från main .

Kör programmet

1. Kör följande kommandon för att installera de nödvändiga paketen, köra databasmigreringar och starta programmet.

   dotnet tool install -g dotnet-ef
   dotnet ef database update
   dotnet run
   

2. Gå till http://localhost:5000 i en webbläsare. Välj länken Skapa nytt och skapa några att-göra-objekt.

   

3. Du kan när som helst stoppa ASP.NET Core genom att trycka på Ctrl+C i terminalen.

Skapa SQL Database för produktion

I det här steget skapar du en SQL Database i Azure. När appen har distribuerats till Azure används den här molndatabasen.

För SQL Database används Azure SQL Database i den här självstudien.

Skapa en resursgrupp

En resurs grupp är en logisk behållare där Azure-resurser, till exempel webbappar, databaser och lagrings konton, distribueras och hanteras. Du kan exempelvis välja att ta bort hela resursgruppen i ett enkelt steg längre fram.

I Cloud Shell skapar du en resurs grupp med az group create kommandot. I följande exempel skapas en resursgrupp med namnet myResourceGroup på platsen Europa, västra. Om du vill se alla platser som stöds för App Service på Kostnadsfri nivå, kör du kommandot az appservice list-locations --sku FREE.

az group create --name myResourceGroup --location "West Europe"

Du skapar vanligtvis din resursgrupp och resurserna i en region nära dig.

När kommandot har slutförts visar JSON-utdata resursgruppens egenskaper.

Skapa en logisk SQL Database-server

I Cloud Shell skapar du en SQL Database logisk server med az sql server create kommandot .

Ersätt <server-name> platshållaren med ett unikt SQL Database namn. Det här namnet används som en del av den globalt unika SQL Database slutpunkten, <server-name>.database.windows.net . Giltiga tecken är a - z , 0 - 9 , - . Ersätt också och <db-username> med ett användarnamn och lösenord som du själv <db-password> väljer.

az sql server create --name <server-name> --resource-group myResourceGroup --location "West Europe" --admin-user <db-username> --admin-password <db-password>

När den logiska SQL Database-servern har skapats visar Azure CLI information som liknar följande exempel:

{
  "administratorLogin": "<db-username>",
  "administratorLoginPassword": null,
  "fullyQualifiedDomainName": "<server-name>.database.windows.net",
  "id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Sql/servers/<server-name>",
  "identity": null,
  "kind": "v12.0",
  "location": "westeurope",
  "name": "<server-name>",
  "resourceGroup": "myResourceGroup",
  "state": "Ready",
  "tags": null,
  "type": "Microsoft.Sql/servers",
  "version": "12.0"
}

Konfigurera en serverbrandväggsregel

1. Skapa en brandväggsregel på servernivå för Azure SQL Database via kommandotaz sql server firewall create. När både start-IP och slut-IP har angetts till 0.0.0.0 öppnas brandväggen endast för andra Azure-resurser.

   az sql server firewall-rule create --resource-group myResourceGroup --server <server-name> --name AllowAzureIps --start-ip-address 0.0.0.0 --end-ip-address 0.0.0.0
   

   Tips

   Du kan begränsa brandväggsregeln ännu mer genom att endast använda de utgående IP-adresser som används av din app.

2. I den Cloud Shell du kommandot igen för att tillåta åtkomst från din lokala dator genom att ersätta med <your-ip-address> din lokala IPv4 IP-adress.

   az sql server firewall-rule create --name AllowLocalClient --server <server-name> --resource-group myResourceGroup --start-ip-address=<your-ip-address> --end-ip-address=<your-ip-address>
   

Skapa en databas

Skapa en databas med en S0-prestandanivå på servern med kommandot az sql db create.

az sql db create --resource-group myResourceGroup --server <server-name> --name coreDB --service-objective S0

Hämta anslutningssträng

Hämta anslutningssträngen med az sql db show-connection-string kommandot .

az sql db show-connection-string --client ado.net --server <server-name> --name coreDB

I kommandoutdata ersätter du <username> och med <password> de autentiseringsuppgifter för databasadministratör som du använde tidigare.

Det här är anslutningssträngen för din ASP.NET Core app. Kopiera den för senare bruk.

Konfigurera appen för att ansluta till produktionsdatabasen

Öppna Startup.cs från din lokala lagringsplats och leta upp följande kod:

services.AddDbContext<MyDatabaseContext>(options =>
        options.UseSqlite("Data Source=localdatabase.db"));

Ersätt den med följande kod.

services.AddDbContext<MyDatabaseContext>(options =>
        options.UseSqlServer(Configuration.GetConnectionString("MyDbConnection")));

Köra databasmigrering till produktionsdatabasen

Din app ansluter för närvarande till en lokal Sqlite-databas. Nu när du har konfigurerat en Azure SQL Database återskapar du den första migreringen för att rikta in dig på den.

Kör följande kommandon från lagringsplatsens rot. Ersätt <connection-string> med anslutningssträngen som du skapade tidigare.

# Delete old migrations
rm -r Migrations
# Recreate migrations with UseSqlServer (see previous snippet)
dotnet ef migrations add InitialCreate

# Set connection string to production database
# PowerShell
$env:ConnectionStrings:MyDbConnection="<connection-string>"
# CMD (no quotes)
set ConnectionStrings:MyDbConnection=<connection-string>
# Bash (no quotes)
export ConnectionStrings__MyDbConnection=<connection-string>

# Run migrations
dotnet ef database update

Köra appen med ny konfiguration

1. Nu när databasmigreringarna körs på produktionsdatabasen kan du testa appen genom att köra:

   dotnet run
   

2. Gå till http://localhost:5000 i en webbläsare. Välj länken Skapa nytt och skapa några att-göra-objekt. Din app läser och skriver nu data till produktionsdatabasen.

3. Genomför dina lokala ändringar och spara dem sedan på Git-lagringsplatsen.

   git add .
   git commit -m "connect to SQLDB in Azure"
   

Nu är du redo att distribuera din kod.

Distribuera app till Azure

I det här steget distribuerar du ditt SQL Database-anslutna ASP.NET Core till App Service.

Konfigurera lokal git-distribution

FTP och lokal Git kan distribuera till en Azure-webbapp med hjälp av en distributionsanvändare. När du har konfigurerat distributionsanvändaren kan du använda den för alla dina Azure-distributioner. Ditt användarnamn och lösenord för distribution på kontonivå skiljer sig från autentiseringsuppgifterna för din Azure-prenumeration.

Konfigurera distributionsanvändaren genom att köra kommandot az webapp deployment user set i Azure Cloud Shell. Ersätt <username> och med ett användarnamn och lösenord för <password> distributionsanvändaren.

• Användarnamnet måste vara unikt i Azure och för lokala Git-pushar får det inte innehålla @ symbolen .
• Lösenordet måste vara minst åtta tecken långt, med två av följande tre element: bokstäver, siffror och symboler.

az webapp deployment user set --user-name <username> --password <password>

JSON-utdata visar lösenordet som null . Om du ser felet 'Conflict'. Details: 409 ska du byta användarnamn. Om du ser felet 'Bad Request'. Details: 400 ska du använda ett starkare lösenord.

Registrera ditt användarnamn och lösenord som ska användas för att distribuera dina webbappar.

Skapa en App Service-plan

az appservice plan create --name myAppServicePlan --resource-group myResourceGroup --sku FREE

{ 
  "adminSiteName": null,
  "appServicePlanName": "myAppServicePlan",
  "geoRegion": "West Europe",
  "hostingEnvironmentProfile": null,
  "id": "/subscriptions/0000-0000/resourceGroups/myResourceGroup/providers/Microsoft.Web/serverfarms/myAppServicePlan",
  "kind": "app",
  "location": "West Europe",
  "maximumNumberOfWorkers": 1,
  "name": "myAppServicePlan",
  < JSON data removed for brevity. >
  "targetWorkerSizeId": 0,
  "type": "Microsoft.Web/serverfarms",
  "workerTierName": null
} 

az appservice plan create --name myAppServicePlan --resource-group myResourceGroup --sku FREE --is-linux

{ 
  "freeOfferExpirationTime": null,
  "geoRegion": "West Europe",
  "hostingEnvironmentProfile": null,
  "id": "/subscriptions/0000-0000/resourceGroups/myResourceGroup/providers/Microsoft.Web/serverfarms/myAppServicePlan",
  "kind": "linux",
  "location": "West Europe",
  "maximumNumberOfWorkers": 1,
  "name": "myAppServicePlan",
  < JSON data removed for brevity. >
  "targetWorkerSizeId": 0,
  "type": "Microsoft.Web/serverfarms",
  "workerTierName": null
} 

Skapa en webbapp

az webapp create --resource-group myResourceGroup --plan myAppServicePlan --name <app-name> --deployment-local-git

Local git is configured with url of 'https://<username>@<app-name>.scm.azurewebsites.net/<app-name>.git'
{
  "availabilityState": "Normal",
  "clientAffinityEnabled": true,
  "clientCertEnabled": false,
  "clientCertExclusionPaths": null,
  "cloningInfo": null,
  "containerSize": 0,
  "dailyMemoryTimeQuota": 0,
  "defaultHostName": "<app-name>.azurewebsites.net",
  "deploymentLocalGitUrl": "https://<username>@<app-name>.scm.azurewebsites.net/<app-name>.git",
  "enabled": true,
  < JSON data removed for brevity. >
}

az webapp create --resource-group myResourceGroup --plan myAppServicePlan --name <app-name> --runtime 'DOTNET|5.0' --deployment-local-git

Local git is configured with url of 'https://<username>@<app-name>.scm.azurewebsites.net/<app-name>.git'
{
  "availabilityState": "Normal",
  "clientAffinityEnabled": true,
  "clientCertEnabled": false,
  "cloningInfo": null,
  "containerSize": 0,
  "dailyMemoryTimeQuota": 0,
  "defaultHostName": "<app-name>.azurewebsites.net",
  "deploymentLocalGitUrl": "https://<username>@<app-name>.scm.azurewebsites.net/<app-name>.git",
  "enabled": true,
  < JSON data removed for brevity. >
}

Konfigurera anslutningssträng

Om du vill ange anslutningssträngar för din Azure-app az webapp config appsettings set använder du kommandot i Cloud Shell. I följande kommando ersätter du <app-name> , samt parametern med <connection-string> anslutningssträngen som du skapade tidigare.

az webapp config connection-string set --resource-group myResourceGroup --name <app-name> --settings MyDbConnection='<connection-string>' --connection-string-type SQLAzure

I ASP.NET Core kan du använda den här namngivna anslutningssträngen ( ) med hjälp av standardmönstret, precis som alla anslutningssträngar som anges i MyDbConnection appsettings.json. I det här fallet MyDbConnection definieras också i din appsettings.json. När du kör i App Service har anslutningssträngen som definierats i App Service företräde framför den anslutningssträng som definierats i din appsettings.json. Koden använder värdet appsettings.json under lokal utveckling och samma kod använder App Service när den distribueras.

Information om hur anslutningssträngen refereras i koden finns i Konfigurera appen för att ansluta till produktionsdatabasen.

Skicka till Azure från Git

1. Eftersom du distribuerar -grenen måste du ange standarddistributionsgrenen för main din App Service-app main till (se Ändra distributionsgren). I Cloud Shell anger du DEPLOYMENT_BRANCH appinställningen med az webapp config appsettings set kommandot .

   az webapp config appsettings set --name <app-name> --resource-group myResourceGroup --settings DEPLOYMENT_BRANCH='main'
   

2. I det lokala terminalfönstret kan du lägga till en Azure-fjärrdatabas till din lokala Git-databas. Ersätt <deploymentLocalGitUrl-from-create-step> med URL:en för den Fjärranslutna Git som du sparade från Skapa en webbapp.

   git remote add azure <deploymentLocalGitUrl-from-create-step>
   

3. Skicka till Azure-fjärrdatabasen för att distribuera appen med följande kommando. När Git Autentiseringshanteraren uppmanar dig att ange autentiseringsuppgifter ska du se till att du anger de autentiseringsuppgifter som du skapade i Konfigurera en distributionsanvändare , inte de autentiseringsuppgifter som du använder för att logga in på Azure Portal.

   git push azure main
   

   Det kan ett par minuter att köra kommandot. Medan det körs visas information liknande den i följande exempel:

   Enumerating objects: 268, done.
   Counting objects: 100% (268/268), done.
   Compressing objects: 100% (171/171), done.
   Writing objects: 100% (268/268), 1.18 MiB | 1.55 MiB/s, done.
   Total 268 (delta 95), reused 251 (delta 87), pack-reused 0
   remote: Resolving deltas: 100% (95/95), done.
   remote: Updating branch 'main'.
   remote: Updating submodules.
   remote: Preparing deployment for commit id '64821c3558'.
   remote: Generating deployment script.
   remote: Project file path: .\DotNetCoreSqlDb.csproj
   remote: Generating deployment script for ASP.NET MSBuild16 App
   remote: Generated deployment script files
   remote: Running deployment command...
   remote: Handling ASP.NET Core Web Application deployment with MSBuild16.
   remote: .
   remote: .
   remote: .
   remote: Finished successfully.
   remote: Running post deployment command(s)...
   remote: Triggering recycle (preview mode disabled).
   remote: App container will begin restart within 10 seconds.
   To https://<app-name>.scm.azurewebsites.net/<app-name>.git
    * [new branch]      main -> main
   

   Enumerating objects: 273, done.
   Counting objects: 100% (273/273), done.
   Delta compression using up to 4 threads
   Compressing objects: 100% (175/175), done.
   Writing objects: 100% (273/273), 1.19 MiB | 1.85 MiB/s, done.
   Total 273 (delta 96), reused 259 (delta 88)
   remote: Resolving deltas: 100% (96/96), done.
   remote: Deploy Async
   remote: Updating branch 'main'.
   remote: Updating submodules.
   remote: Preparing deployment for commit id 'cccecf86c5'.
   remote: Repository path is /home/site/repository
   remote: Running oryx build...
   remote: Build orchestrated by Microsoft Oryx, https://github.com/Microsoft/Oryx
   remote: You can report issues at https://github.com/Microsoft/Oryx/issues
   remote: .
   remote: .
   remote: .
   remote: Done.
   remote: Running post deployment command(s)...
   remote: Triggering recycle (preview mode disabled).
   remote: Deployment successful.
   remote: Deployment Logs : 'https://<app-name>.scm.azurewebsites.net/newui/jsonviewer?view_url=/api/deployments/cccecf86c56493ffa594e76ea1deb3abb3702d89/log'
   To https://<app-name>.scm.azurewebsites.net/<app-name>.git
    * [new branch]      main -> main
   

Bläddra till Azure-appen

1. Bläddra till den distribuerade appen i webbläsaren.

   http://<app-name>.azurewebsites.net
   

2. Lägg till några att-göra-uppgifter.

   

Grattis! Du kör en datadriven app ASP.NET Core i App Service.

Uppdatera lokalt och omdistribuera

I det här steget gör du en ändring i ditt databasschema och publicerar den till Azure.

Uppdatera datamodellen

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

public bool Done { get; set; }

Köra databasmigrering igen

Kör några kommandon för att göra uppdateringar av produktionsdatabasen.

dotnet ef migrations add AddProperty
dotnet ef database update

Använda den nya egenskapen

Gör några ändringar i koden så att du använder egenskapen Done. För att göra självstudien enklare ska du bara ändra vyerna Index och Create så att du ser hur egenskapen fungerar.

1. Öppna Controllers/TodosController.cs.

2. Leta rätt på metoden Create([Bind("ID,Description,CreatedDate")] Todo todo) och lägg till Done i listan med egenskaper för attributet Bind. När du är klar ser signaturen för metoden Create() ut som följande kod:

   public async Task<IActionResult> Create([Bind("ID,Description,CreatedDate,Done")] Todo todo)
   

3. Öppna Views/Todos/Create.cshtml.

4. I Razor-koden bör du se ett <div class="form-group">-element för Description och sedan ett annat <div class="form-group">-element för CreatedDate. Direkt efter dessa två element ska du lägga till ett annat <div class="form-group">-element för Done:

   <div class="form-group">
       <label asp-for="Done" class="col-md-2 control-label"></label>
       <div class="col-md-10">
           <input asp-for="Done" class="form-control" />
           <span asp-validation-for="Done" class="text-danger"></span>
       </div>
   </div>
   

5. Öppna Views/Todos/Index.cshtml.

6. Sök efter det tomma <th></th>-elementet. Lägg till följande Razor-kod direkt ovanför det här elementet:

   <th>
       @Html.DisplayNameFor(model => model.Done)
   </th>
   

7. Hitta elementet <td> som innehåller ”tag helpers” asp-action. Lägg till följande Razor-kod direkt ovanför det här elementet:

   <td>
       @Html.DisplayFor(modelItem => item.Done)
   </td>
   

Det är allt som krävs för att du ska se ändringarna i vyerna Index och Create.

Testa ändringarna lokalt

1. Kör appen lokalt.

   dotnet run
   

   Anteckning

   Om du öppnar ett nytt terminalfönster måste du ange anslutningssträngen till produktionsdatabasen i terminalen, som du gjorde i Köra databasmigrering till produktionsdatabasen.

2. Öppna webbläsaren och navigera till http://localhost:5000/. Du kan nu lägga till en att-göra-uppgift och markera Klart. Den ska sedan visas på din startsida som en slutförd uppgift. Kom ihåg att vyn Edit inte innehåller fältet Done eftersom du inte ändrade vyn Edit.

Publicera ändringar till Azure

1. Spara ändringarna i Git och push-skicka dem till App Service appen.

   git add .
   git commit -m "added done field"
   git push azure main
   

2. När är git push klar går du till din App Service och provar att lägga till ett att göra-objekt och markerar Klar.

   

Alla befintliga att-göra-uppgifter visas fortfarande. När du publicerar om ASP.NET Core-appen går befintliga data i SQL Database inte förlorade. Med Entity Framework Core Migrations ändras endast dataschemat, så att befintliga data lämnas intakta.

Strömma diagnostikloggar

När ASP.NET Core-appen körs i Azure App Service kan du skicka konsolloggarna till Cloud Shell. På så sätt kan du få samma diagnostikmeddelanden för att felsöka programfel.

Exempelprojektet följer redan riktlinjerna för loggningsprovidern Azure App Service med två konfigurationsändringar:

• Innehåller en referens till Microsoft.Extensions.Logging.AzureAppServices i DotNetCoreSqlDb.csproj.
• Anrop loggerFactory.AddAzureWebAppDiagnostics() i Program.cs.

1. För att ange loggnivå för ASP.NET Core i App Service till Information från standardnivån Erroranvänder du kommandot az webapp log config i Cloud Shell.

   az webapp log config --name <app-name> --resource-group myResourceGroup --application-logging filesystem --level information
   

   Anteckning

   Projektets loggnivå är redan inställd på Information i appsettings.json.

2. Starta loggströmningen med kommandot az webapp log tail i Cloud Shell.

   az webapp log tail --name <app-name> --resource-group myResourceGroup
   

3. Uppdatera Azure-app i webbläsaren så hämtas webbtrafik när loggströmningen har startats. Du kan nu se konsolloggarna som skickas till terminalen. Om du inte ser konsolloggarna omedelbart kan du titta efter igen efter 30 sekunder.

4. Skriv Ctrl+C när som helst för att stoppa loggströmningen.

Mer information om hur du anpassar ASP.NET Core finns i Loggning i .NET.

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 tar du bort resursgruppen genom att köra följande kommando i Cloud Shell:

az group delete --name myResourceGroup

Det kan några minuter att köra kommandot.

Nästa steg

Vad du lärt dig:

Gå vidare till nästa självstudie där du får lära dig att mappa ett anpassat DNS-namn till appen.

Eller så kan du kolla in andra resurser: