kurz: vytvoření aplikace ASP.NET Core a Azure SQL Database v Azure App Service

V tomto kurzu se naučíte:

Pokud ještě nemáte předplatné Azure,vytvořte si bezplatný účet před tím, než začnete.

Požadavky

Pro absolvování tohoto kurzu potřebujete:

• Nainstalovat Git.
• Nainstalovat nejnovější sadu .NET 5,0 SDK

• V nástroji použijte prostředí Bash Azure Cloud Shell.

  

• Pokud tomu dáváte přednost, můžete nainstalovat Azure CLI a spouštět referenční příkazy CLI.

  • Pokud používáte místní instalaci, přihlaste se k Azure CLI pomocí příkazu az login. Pokud chcete dokončit proces ověřování, postupujte podle kroků zobrazených na terminálu. Další možnosti přihlášení jsou popsané v tématu Přihlášení pomocí Azure CLI.

  • Po zobrazení výzvy nainstalujte rozšíření Azure CLI při prvním použití. Další informace o rozšířeních najdete v tématu Využití rozšíření v Azure CLI.

  • Spuštěním příkazu az version zjistěte verzi a závislé knihovny, které jsou nainstalované. Pokud chcete upgradovat na nejnovější verzi, spusťte az upgrade.

Vytvoření místní aplikace ASP.NET Core

V tomto kroku nastavíte místní projekt ASP.NET Core.

Klonování ukázkové aplikace

1. V okně terminálu přejděte pomocí příkazu cd do pracovního adresáře.

2. Spuštěním následujících příkazů naklonujte ukázkové úložiště a přejděte do jeho kořenové složky.

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

   Ukázkový projekt obsahuje základní aplikaci CRUD (vytváření-čtení-aktualizace-odstraňování) pomocí Entity Framework Core.

3. Ujistěte se, že je výchozí větev main .

   git branch -m main
   

   Tip

   App Service nepožaduje změnu názvu větve. Ale vzhledem k tomu, že mnoho úložišť mění výchozí větev na main (viz Změna větve nasazení), v tomto kurzu se také dozvíte, jak nasadit úložiště z main .

Spuštění aplikace

1. Spuštěním následujících příkazů nainstalujte požadované balíčky, spusťte operace migrace databáze a spusťte aplikaci.

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

2. V prohlížeči přejděte na http://localhost:5000. Vyberte odkaz Vytvořit nový a vytvořte několik položek úkolů.

   

3. ASP.NET Core můžete kdykoli zastavit stisknutím Ctrl+C v terminálu.

Vytvoření produkční databáze SQL

V tomto kroku vytvoříte databázi SQL v Azure. Po nasazení do Azure bude aplikace používat tuto cloudovou databázi.

Jako databáze SQL se v tomto kurzu používá Azure SQL Database.

Vytvoření skupiny prostředků

Skupina prostředků je logický kontejner, ve kterém se nasazují a spravují prostředky Azure, jako jsou webové aplikace, databáze a účty úložiště. Později se například můžete rozhodnout odstranit celou skupinu prostředků v jednom jednoduchém kroku.

V Cloud Shell vytvořte skupinu prostředků pomocí az group create příkazu. Následující příklad vytvoří skupinu prostředků myResourceGroup v umístění Západní Evropa. Pokud chcete zobrazit všechna podporovaná umístění pro službu App Service na úrovni Free, spusťte příkaz az appservice list-locations --sku FREE.

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

Obvykle budete svoji skupinu prostředků a prostředky vytvářet v oblasti, kterou máte blízko.

Po dokončení příkazu se ve výstupu JSON zobrazí vlastnosti skupiny prostředků.

Vytvoření logického serveru databáze SQL

v Cloud Shell vytvořte pomocí příkazu SQL Database logický server az sql server create .

<server-name> zástupný text nahraďte jedinečným názvem SQL Database. tento název se používá jako součást globálně jedinečného SQL Databaseho koncového bodu, <server-name>.database.windows.net . Platné znaky jsou a - z , 0 - 9 , - . Také nahraďte <db-username> a zadejte <db-password> uživatelské jméno a heslo podle vašeho výběru.

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

Po vytvoření logického serveru databáze SQL se v rozhraní příkazového řádku Azure zobrazí podobné informace jako v následujícím příkladu:

{
  "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"
}

Konfigurace pravidla brány firewall serveru

1. Vytvoření pravidla brány firewall na úrovni serveru služby Azure SQL Database pomocí příkazu az sql server firewall create. Pokud je jako počáteční i koncová adresa IP nastavená hodnota 0.0.0.0, je brána firewall otevřená jen pro ostatní prostředky Azure.

   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
   

   Tip

   Pravidlo brány firewall můžete dál omezit použitím jenom odchozích IP adres, které vaše aplikace používá.

2. V Cloud Shell znovu spusťte příkaz a umožněte přístup z místního počítače nahrazením <your-ip-address> místní IP adresy IPv4.

   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>
   

Vytvoření databáze

Vytvořte na serveru databázi s úrovní výkonu S0 pomocí příkazu az sql db create.

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

Načíst připojovací řetězec

Pomocí příkazu Získejte připojovací řetězec az sql db show-connection-string .

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

Ve výstupu příkazu nahraďte <username> a <password> s přihlašovacími údaji správce databáze, které jste použili dříve.

toto je připojovací řetězec pro vaši aplikaci ASP.NET Core. Zkopírujte ho pro pozdější použití.

Konfigurace aplikace pro připojení k provozní databázi

V místním úložišti otevřete Startup.cs a vyhledejte následující kód:

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

Nahraďte následujícím kódem.

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

Spuštění migrace databáze do provozní databáze

Vaše aplikace se aktuálně připojuje k místní databázi SQLite. teď, když jste nakonfigurovali Azure SQL Database, vytvořte novou migraci, abyste ji mohli cílit.

V kořenovém adresáři úložiště spusťte následující příkazy. Nahraďte <connection-string> připojovacím řetězcem, který jste vytvořili dříve.

# 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

Spustit aplikaci s novou konfigurací

1. Teď, když jsou migrace databáze spuštěné v provozní databázi, otestujte aplikaci spuštěním:

   dotnet run
   

2. V prohlížeči přejděte na http://localhost:5000. Vyberte odkaz Vytvořit nový a vytvořte několik položek úkolů. Vaše aplikace teď čte a zapisuje data do provozní databáze.

3. Potvrďte své místní změny a pak je potvrďte do úložiště Git.

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

Teď jste připraveni nasadit svůj kód.

Nasazení aplikace do Azure

v tomto kroku nasadíte ASP.NET Core aplikaci SQL Database připojenou k App Service.

Konfigurace nasazení místního gitu

FTP a místní Git se můžou nasadit do webové aplikace Azure pomocí uživatele nasazení. Jakmile nakonfigurujete uživatele nasazení, můžete ho použít pro všechna nasazení Azure. Uživatelské jméno a heslo nasazení na úrovni účtu se liší od přihlašovacích údajů předplatného Azure.

Pokud chcete nakonfigurovat uživatele nasazení, spusťte v Azure Cloud Shell příkaz AZ WebApp Deployment User set . Nahraďte <username> a <password> pomocí uživatelského jména a hesla pro nasazení.

• Uživatelské jméno musí být v rámci Azure jedinečné a pro místní nabízená oznámení Git nesmí obsahovat @ symbol.
• Heslo musí mít délku alespoň osm znaků a dva z následujících tří prvků: písmena, číslice a symboly.

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

Výstup JSON zobrazuje heslo jako null . Pokud se zobrazí chyba 'Conflict'. Details: 409, změňte uživatelské jméno. Pokud se zobrazí chyba 'Bad Request'. Details: 400, použijte silnější heslo.

Poznamenejte si uživatelské jméno a heslo, které chcete použít k nasazení webových aplikací.

Vytvoření plánu služby App Service

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
} 

Vytvoření webové aplikace

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. >
}

Konfigurace připojovacího řetězce

K nastavení připojovacích řetězců pro aplikaci Azure použijte az webapp config appsettings set příkaz v Cloud Shell. V následujícím příkazu nahraďte a <app-name> <connection-string> parametr připojovacím řetězcem, který jste vytvořili dříve.

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

v ASP.NET Core můžete použít tento pojmenovaný připojovací řetězec ( MyDbConnection ) pomocí standardního vzoru, jako je libovolný připojovací řetězec zadaný v souboru appsettings. json. V tomto případě MyDbConnection je také definováno v souboru appSettings. JSON. Při spuštění v App Service má připojovací řetězec definovaný v App Service přednost před připojovacím řetězcem definovaným v souboru appSettings. JSON. Kód používá hodnotu appSettings. JSON během místního vývoje a stejný kód používá App Service hodnota při nasazení.

Pokud chcete zjistit, jak se na připojovací řetězec odkazuje v kódu, přečtěte si téma Konfigurace aplikace pro připojení k provozní databázi.

Přenos z Gitu do Azure

1. Vzhledem k tomu, že nasazujete větev , musíte nastavit výchozí větev nasazení pro vaši aplikaci App Service na (viz Změna main větve main nasazení). V Cloud Shell nastavte nastavení DEPLOYMENT_BRANCH aplikace pomocí az webapp config appsettings set příkazu .

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

2. Zpět v okně místního terminálu přidejte vzdálené úložiště Azure do místního úložiště Git. Nahraďte <deploymentLocalGitUrl-from-create-step> adresou URL vzdáleného úložiště Git, kterou jste si uložili v části Vytvoření webové aplikace.

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

3. Nasaďte aplikaci do vzdáleného úložiště Azure pomocí následujícího příkazu. Když vás Správce přihlašovacích údajů Git vyzve k zadání přihlašovacích údajů, nezapomeňte zadat přihlašovací údaje, které jste vytvořili v části Konfigurace uživatele nasazení, a ne přihlašovací údaje, které používáte pro přihlášení k Azure Portal.

   git push azure main
   

   Spuštění tohoto příkazu může trvat několik minut. Při spuštění příkaz zobrazí podobné informace jako v následujícím příkladu:

   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
   

Přejít k aplikaci Azure

1. Přejděte do nasazené aplikace pomocí webového prohlížeče.

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

2. Přidejte několik položek úkolů.

   

Blahopřejeme! spouštíte datově řízenou aplikaci ASP.NET Core v App Service.

Místní aktualizace a opětovné nasazení

V tomto kroku provedete změnu schématu databáze a publikujete ji v Azure.

Aktualizace datového modelu

Otevřete modely/todo. cs v editoru kódu. Do třídy ToDo přidejte následující vlastnost:

public bool Done { get; set; }

Znovu spustit migrace databáze

Spusťte několik příkazů, abyste provedli aktualizace provozní databáze.

dotnet ef migrations add AddProperty
dotnet ef database update

Použití nové vlastnosti

Proveďte v kódu několik změn, aby aplikace využívala vlastnost Done. Pro zjednodušení budete v tomto kurzu měnit jen zobrazení Index a Create, aby se vlastnost projevila v praxi.

1. Otevřete Controllers/TodosController. cs.

2. Najděte metodu Create([Bind("ID,Description,CreatedDate")] Todo todo) a přidejte vlastnosti Done do seznamu vlastností v atributu Bind. Po dokončení bude podpis vaší metody Create() vypadat podobně jako následující kód:

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

3. Otevřete zobrazení/TODO/vytvořit. cshtml.

4. V kódu Razor byste měli vidět prvek <div class="form-group"> pro Descriptiona pak další prvek <div class="form-group"> pro CreatedDate. Přímo za tyto dva prvky přidejte další prvek <div class="form-group"> pro 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. Otevřete zobrazení/todoe/index. cshtml.

6. Vyhledejte prázdný prvek <th></th>. Přímo nad tento prvek přidejte následující kód Razor:

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

7. Najděte prvek <td>, který obsahuje pomocné rutiny značky asp-action. Přímo nad tento prvek přidejte následující kód Razor:

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

To je všechno, co potřebujete, aby se v zobrazení Index a Create projevily změny.

Místní test provedených změn

1. Spusťte aplikaci místně.

   dotnet run
   

   Poznámka

   Pokud otevřete nové okno terminálu, budete muset připojovací řetězec nastavit na provozní databázi v terminálu, stejně jako při spuštění migrace databáze do provozní databáze.

2. V prohlížeči přejděte na adresu http://localhost:5000/. Teď můžete přidat položku úkolu a zaškrtnout možnost Hotovo. Položka by se měla zobrazit na domovské stránce jako dokončená. Nezapomeňte, že v zobrazení Edit se pole Done nezobrazí, protože jste zobrazení Edit nezměnili.

Publikování změn v Azure

1. Potvrďte změny v Gitu a nahrajte je do aplikace App Service.

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

2. Až git push to bude hotové, přejděte do aplikace App Service a zkuste přidat položku úkoly a vrátit se k ní .

   

Všechny vaše existující položky úkolů jsou nadále zobrazené. při opětovném publikování ASP.NET Core aplikace nebudou ztracena stávající data v SQL Database. Migrace Entity Framework Core také změní jen datové schéma, ale existující data ponechá beze změny.

Streamování diagnostických protokolů

i když je aplikace ASP.NET Core spuštěná v Azure App Service, můžete získat protokoly konzoly, které budou směrované do Cloud Shell. Tímto způsobem můžete získat stejné diagnostické zprávy, které vám pomůžou ladit chyby aplikace.

Ukázkový projekt už následuje po pokynech pro poskytovatele protokolování Azure App Service se dvěma změnami konfigurace:

• Obsahuje odkaz na Microsoft.Extensions.Logging.AzureAppServices v DotNetCoreSqlDb. csproj.
• Volání loggerFactory.AddAzureWebAppDiagnostics() v programu program. cs.

1. chcete-li nastavit úroveň protokolu ASP.NET Core v App Service na Information z výchozí úrovně Error , použijte az webapp log config příkaz v Cloud Shell.

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

   Poznámka

   Úroveň protokolu projektu je už nastavená na Information v souboru appSettings. JSON.

2. Chcete-li spustit streamování protokolů, použijte az webapp log tail příkaz v Cloud Shell.

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

3. Po spuštění streamování protokolů aktualizujte aplikaci Azure v prohlížeči, abyste získali nějaký webový provoz. Teď se zobrazí protokoly konzoly směrované do terminálu. Pokud nevidíte protokoly konzoly okamžitě, podívejte se znovu za 30 sekund.

4. Streamování protokolů můžete kdykoli zastavit zadáním Ctrl+C.

další informace o přizpůsobení protokolů ASP.NET Core najdete v tématu protokolování v .net.

Vyčištění prostředků

V předchozích krocích jste vytvořili prostředky Azure ve skupině prostředků. Pokud předpokládáte, že už tyto prostředky nebudete potřebovat, odstraňte skupinu prostředků spuštěním následujícího příkazu ve službě Cloud Shell:

az group delete --name myResourceGroup

Spuštění tohoto příkazu může trvat přibližně minut.

Další kroky

Naučili jste se:

Přejděte k dalšímu kurzu, kde se dozvíte, jak namapovat vlastní název DNS na svou aplikaci.

Nebo si prohlédněte další zdroje informací: