Distribuera ASP.NET Core-appar till Azure App Service

Azure App Service är en Plattformstjänst för molnbaserad databehandling i Microsoft för att vara värd för webbappar, inklusive ASP.NET Core.

Mönster för företagswebbappar

Vägledning om hur du skapar en tillförlitlig, säker, högpresterande, testbar och skalbar ASP.NET Core-app finns i Enterprise-webbappmönster. En komplett exempelwebbapp av produktionskvalitet som implementerar mönstren är tillgänglig.

Användbara resurser

App Service-dokumentation är hem för dokumentation om Azure Apps, självstudier, exempel, hjälpguider och resurser. Två viktiga handledningar som handlar om att vara värd för ASP.NET Core-appar är:

Skapa en ASP.NET Core-webbapp i Azure
Använd Visual Studio för att skapa och distribuera en ASP.NET Core-webbapp till Azure App Service i Windows.

Skapa en ASP.NET Core-app i App Service på Linux
Använd kommandoraden för att skapa och distribuera en ASP.NET Core-webbapp till Azure App Service i Linux.

Se ASP.NET Core på App Service-instrumentpanelen för den version av ASP.NET Core som är tillgänglig i Azure App Service.

Prenumerera på App Service-meddelanden lagringsplats och övervaka problemen. App Service-teamet publicerar regelbundet meddelanden och scenarier som anländer till App Service.

Följande artiklar finns i ASP.NET Core-dokumentation:

Publicera en ASP.NET Core-app till Azure med Visual Studio
Lär dig hur du publicerar en ASP.NET Core-app till Azure App Service med hjälp av Visual Studio.

Skapa din första pipeline
Konfigurera en CI-version för en ASP.NET Core-app och skapa sedan en kontinuerlig distributionsversion till Azure App Service.

sandbox-miljön i Azure Web App
Upptäck de körningsbegränsningar för Azure App Service som tillämpas av Azure Apps-plattformen.

Felsöka och debugga ASP.NET Core-projekt
Förstå och felsöka varningar och fel med ASP.NET Core-projekt.

Programkonfiguration

Plattform

Plattformsarkitekturen (x86/x64) för en App Services-app anges i appens inställningar i Azure-portalen för appar som finns på en A-serieberäkning (Basic) eller högre värdnivå. Bekräfta att appens publiceringsinställningar (till exempel i Visual Studio publicera profil (.pubxml)) matchar inställningen i appens tjänstkonfiguration i Azure-portalen.

ASP.NET Core-appar kan publiceras beroende av ramverk eftersom körtiderna för 64-bitarsappar (x64) och 32-bitarsappar (x86) är tillgängliga på Azure App Service. Den .NET Core SDK- som är tillgänglig på App Service är 32-bitars, men du kan distribuera 64-bitars-appar som skapats lokalt med hjälp av Kudu-konsolen eller publiceringsprocessen i Visual Studio. Mer information finns i avsnittet Publicera och distribuera appen.

Mer information om .NET Core-ramverkskomponenter och distributionsmetoder, till exempel information om .NET Core-körningen och .NET Core SDK, finns i Om .NET Core: Sammansättning.

Paket

Inkludera följande NuGet-paket för att tillhandahålla automatiska loggningsfunktioner för appar som distribueras till Azure App Service:

• Microsoft.AspNetCore.AzureAppServices.HostingStartup använder IHostingStartup- för att tillhandahålla ASP.NET Core-loggningsintegrering med Azure App Service. De tillagda loggningsfunktionerna tillhandahålls av Microsoft.AspNetCore.AzureAppServicesIntegration-paketet.
• Microsoft.AspNetCore.AzureAppServicesIntegration kör AddAzureWebAppDiagnostics för att lägga till Azure App Service-diagnostikloggningsproviders i Microsoft.Extensions.Logging.AzureAppServices-paketet.
• Microsoft.Extensions.Logging.AzureAppServices tillhandahåller loggimplementeringar för att stödja Azure App Service-diagnostikloggar och funktioner för loggströmning.

Föregående paket måste uttryckligen refereras till i appens projektfil.

Åsidosätt appkonfiguration med hjälp av Azure-portalen

Med appinställningar i Azure Portal kan du ange miljövariabler för appen. Miljövariabler kan användas av konfigurationsprovidern för miljövariabler .

När en appinställning skapas eller ändras i Azure-portalen och knappen Spara har valts startas Azure-appen om. Miljövariabeln är tillgänglig för appen när tjänsten har startats om.

Miljövariabler läses in i appens konfiguration när CreateBuilder- anropas för att skapa värden. Mer information finns i miljövariablernas konfigurationsprovider .

Scenarier för proxyserver och lastbalanserare

IIS Integration Middleware, som konfigurerar Forwarded Headers Middleware när det är värd för out-of-process, och ASP.NET Core Module konfigureras för att vidarebefordra schemat (HTTP/HTTPS) och den externa IP-adressen där begäran har sitt ursprung. Ytterligare konfiguration kan krävas för appar som finns bakom ytterligare proxyservrar och lastbalanserare. Mer information finns i Konfigurera ASP.NET Core att fungera med proxyservrar och lastbalanserare.

Övervakning och loggning

ASP.NET Core-appar som distribueras till App Service får automatiskt ett App Service-tillägg, ASP.NET Core Logging Integration. Tillägget möjliggör loggningsintegrering för ASP.NET Core-appar i Azure App Service.

Information om övervakning, loggning och felsökning finns i följande artiklar:

Övervaka appar i Azure App Service
Lär dig hur du granskar kvoter och mått för appar och App Service-planer.

Aktivera diagnostikloggning för appar i Azure App Service
Upptäck hur du aktiverar och får åtkomst till diagnostikloggning för HTTP-statuskoder, misslyckade begäranden och webbserveraktivitet.

Hantera fel i ASP.NET Core
Förstå vanliga metoder för att hantera fel i ASP.NET Core-appar.

Felsöka ASP.NET Core i Azure App Service och IIS-
Lär dig hur du diagnostiserar problem med Azure App Service-distributioner med ASP.NET Core-appar.

Vanliga fel vid felsökning för Azure App Service och IIS med ASP.NET Core
Se vanliga distributionskonfigurationsfel för appar som hanteras av Azure App Service/IIS med felsökningsråd.

Data Protection-nyckelring och distributionsfack

dataskyddsnycklar sparas i mappen %HOME%\ASP.NET\DataProtection-Keys. Den här mappen backas upp av nätverkslagring och synkroniseras på alla datorer som är värdar för appen. Nycklar skyddas inte i vila. Den här mappen tillhandahåller nyckelringen till alla instanser av en app i ett enda distributionsfack. Separata utplaceringsplatser, till exempel Mellanlagring och Produktion, delar inte samma nyckelring.

När du byter mellan distributionsplatser kan inget system som använder dataskydd dekryptera lagrade data med hjälp av nyckelringen i föregående fack. ASP.NET Cookie Middleware använder dataskydd för att skydda sina cookies. Detta leder till att användare loggas ut från en app som använder standarden ASP.NET Cookie Middleware. För en platsoberoende nyckelringslösning använder du en extern nyckelringsprovider, till exempel:

• Azure Blob Storage
• Azure Key Vault
• SQL-butik
• Rediscache

Mer information finns i Nyckellagringsproviders i ASP.NET Core.

Distribuera en ASP.NET Core-app som använder en .NET Core-förhandsversion

Information om hur du distribuerar en app som använder en förhandsversion av .NET Core finns i följande resurser. Dessa tillvägagångssätt används också när körmiljön är tillgänglig, men SDK:t har inte installerats på Azure App Service.

• Ange .NET Core SDK-versionen med Azure Pipelines
• Distribuera en fristående förhandsversionsapp
• Använda Docker med Web Apps för containrar
• Installera förhandsgranskningswebbplatstillägget

Se ASP.NET Core på App Service-instrumentpanelen för den version av ASP.NET Core som är tillgänglig i Azure App Service.

Se Välj den .NET Core-version som ska användas för information om hur du väljer versionen av .NET SDK för fristående distributioner.

Ange .NET Core SDK-versionen genom att använda Azure Pipelines

Använd Azure App Service CI/CD-scenarier för att konfigurera en kontinuerlig integreringsversion med Azure DevOps. När Azure DevOps-versionen har skapats kan du konfigurera versionen så att den använder en specifik SDK-version.

Ange .NET Core SDK-versionen

När du använder App Service-distributionscentret för att skapa en Azure DevOps-version innehåller standardgenereringspipelinen steg för Restore, Build, Testoch Publish. Om du vill ange SDK-versionen väljer du knappen Lägg till (+) i listan Agentjobb för att lägga till ett nytt steg. Sök efter .NET Core SDK- i sökfältet.

Flytta steget till den första positionen i bygget så att stegen som följer den använder den angivna versionen av .NET Core SDK. Ange versionen av .NET Core SDK. I det här exemplet är SDK inställt på 3.0.100.

Om du vill publicera en fristående distribution (SCD)konfigurerar du SCD i Publish-steget och anger Runtime Identifier (RID).

Distribuera en fristående förhandsversionsapp

En fristående distribution (SCD) som är avsedd för en förhandsversionskörning innehåller själva förhandsversionskörningen i distributionen.

När du distribuerar en fristående app:

• Webbplatsen i Azure App Service kräver inte förhandsgranskningswebbplatstillägget .
• Appen måste publiceras enligt en annan metod än vid publicering för en ramverksberoende distribution (FDD).

Följ riktlinjerna i avsnittet Utdriftsätta den fristående appen.

Använda Docker med Web Apps för containrar

Docker Hub på https://hub.docker.com/_/microsoft-dotnet innehåller den senaste förhandsversionen av Docker-avbildningar. Bilderna kan användas som basavbildning. Använd avbildningen och distribuera till Web Apps for Containers som vanligt.

Installera webbplatstillägget för förhandsversionen

Om ett problem uppstår med förhandsgranskningswebbplatstillägget ska du öppna ett ärende i dotnet/AspNetCore.

1. Från Azure-portalen går du till App Service.
2. Välj webbappen.
3. Skriv "ex" i sökrutan för att filtrera efter "Tillägg" eller rulla nedåt i listan över hanteringsverktyg.
4. Välj tillägg.
5. Välj Lägg till.
6. Välj ASP.NET Core {X.Y} ({x64|x86}) Runtime-tillägget i listan, där {X.Y} är ASP.NET Core-förhandsversionen och {x64|x86} anger plattformen.
7. Välj OK för att acceptera de juridiska villkoren.
8. Välj OK för att installera tillägget.

När åtgärden är klar installeras den senaste .NET Core-förhandsversionen. Kontrollera installationen:

1. Välj Avancerade verktyg.

2. Välj Gå i Avancerade verktyg.

3. Välj menyalternativet felsökningskonsolen>PowerShell.

4. Kör följande kommando i PowerShell-prompten. Ersätt ASP.NET Core-körningsversionen med {X.Y} och plattformen för {PLATFORM} i kommandot:

   Test-Path D:\home\SiteExtensions\AspNetCoreRuntime.{X.Y}.{PLATFORM}\
   

   Kommandot returnerar True när x64 preview-körningen är installerad.

Notera

Plattformsarkitekturen (x86/x64) för en App Services-app anges i appens inställningar i Azure-portalen för appar som finns på en A-serieberäkning (Basic) eller högre värdnivå. Bekräfta att appens publiceringsinställningar (till exempel i Visual Studio publicera profil (.pubxml)) matchar inställningen i appens tjänstkonfiguration i Azure-portalen.

Om appen körs i processläge och plattformsarkitekturen har konfigurerats för 64-bitars (x64) använder ASP.NET Core Module 64-bitars förhandsgranskningskörningen, om den finns. Installera ASP.NET Core {X.Y} (x64) Runtime-tillägget med azure-portalen.

När du har installerat x64-förhandsversionen kör du följande kommando i Azure Kudu PowerShell-kommandofönstret för att verifiera installationen. Ersätt ASP.NET Core-körningsversionen med {X.Y} i följande kommando:

Test-Path D:\home\SiteExtensions\AspNetCoreRuntime.{X.Y}.x64\

Kommandot returnerar True när x64 preview-körningen är installerad.

Använd förhandsgranskningswebbplatstillägget med en ARM-mall

Om en ARM-mall används för att skapa och distribuera appar kan Microsoft.Web/sites/siteextensions resurstyp användas för att lägga till webbplatstillägget i en webbapp. I följande exempel läggs ASP.NET Core 5.0 (x64) Runtime-webbplatstillägg (AspNetCoreRuntime.5.0.x64) till i appen:

{
    ...
    "parameters": {
        "site_name": {
            "defaultValue": "{SITE NAME}",
            "type": "String"
        },
        ...
    },       
    ...
    "resources": [
        ...
        {
            "type": "Microsoft.Web/sites/siteextensions",
            "apiVersion": "2018-11-01",
            "name": "[concat(parameters('site_name'), '/AspNetCoreRuntime.5.0.x64')]",
            "location": "[resourceGroup().location]",
            "dependsOn": [
                "[resourceId('Microsoft.Web/sites', parameters('site_name'))]"
            ]
        }
    ]
}
    

För platshållaren {SITE NAME}använder du appens namn i Azure App Service (till exempel contoso).

Publicera och distribuera appen

För en 64-bitars distribution:

• Använd en 64-bitars .NET Core SDK för att skapa en 64-bitarsapp.
• Ange Platform till 64-bitars i App Service Configuration>Allmänna inställningar. Appen måste använda en Bas- eller högre prenumerationsplan för att möjliggöra valet av plattformens arkitektur.

Distribuera app som är beroende av ramverk

Appar som publiceras som ramverksberoende är plattformskompatibla och inkluderar inte .NET-körtiden i distributionen. Azure App Service innehåller .NET-ramverket.

Visual Studio

1. Högerklicka på projektet i Solution Explorer och välj Publicera. Du kan också välja Skapa>Publicera {Programnamn} från Visual Studio-verktygsfältet.
2. I dialogrutan Publicera väljer du Azure>Nästa.
3. Välj Azure-tjänsten.
4. Välj Avancerat. Dialogrutan Publicera öppnas.
5. Välj en resursgrupp och värdplan eller skapa nya.
6. Välj Slutför.
7. På sidan Publicera:
   • För Konfigurationväljer du pennikonen Redigera konfiguration:
     • Kontrollera att konfigurationen Release har valts.
     • I listrutan distributionsläge väljer du Framework-Beroende.
     • I listrutan Målkörning väljer du önskad körning. Standardvärdet är win-x86.
   • Om du vill ta bort ytterligare filer vid distributionen öppnar du Filpubliceringsalternativ och markerar kryssrutan för att ta bort ytterligare filer på målet.
   • Välj Spara.
   • Välj Publicera.

.NET CLI

1. I projektfilen anger du inte en Runtime Identifier (RID).

2. Publicera appen i Release-konfiguration från ett kommandoskal med kommandot dotnet publish. I följande exempel publiceras appen som en ramverksberoende app:

   dotnet publish --configuration Release
   

3. Flytta innehållet i katalogen bin/Release/{TARGET FRAMEWORK}/publish till webbplatsen i App Service. Om du drar innehållet i mappen publicering från din lokala hårddisk eller nätverksandel direkt till App Service i Kudu-konsolen, ska du dra filerna till mappen D:\home\site\wwwroot i Kudu-konsolen.

Distribuera appen fristående

Om du publicerar en app som fristående skapas en plattformsspecifik körbar fil. Utdatapubliceringsmappen innehåller alla komponenter i appen, inklusive .NET-biblioteken och körmiljön. Mer information finns i [Publicera fristående]/dotnet/core/deploying/#publish-self-contained). Använd Visual Studio eller .NET CLI för en fristående distribution (SCD).

Visual Studio

1. Högerklicka på projektet i Solution Explorer och välj Publicera. Du kan också välja Skapa>Publicera {Programnamn} från Visual Studio-verktygsfältet.
2. I dialogrutan Publicera väljer du Azure>Nästa.
3. Välj Azure-tjänsten.
4. Välj Avancerat. Dialogrutan Publicera öppnas.
5. Välj en resursgrupp och värdplan eller skapa nya.
6. Välj Slutför.
7. På sidan Publicera:
   • För Konfigurationväljer du pennikonen Redigera konfiguration:
     • Kontrollera att konfigurationen Release har valts.
     • I rullgardinsmenyn för distributionsläge väljer du fristående .
     • I listrutan Målkörtid väljer du önskad körtid. Standardvärdet är win-x86.
   • Om du vill ta bort ytterligare filer vid distributionen öppnar du Filpubliceringsalternativ och markerar kryssrutan för att ta bort ytterligare filer på målet.
   • Välj Spara.
   • Välj Publicera.

.NET CLI

1. I projektfilen anger du en eller flera Runtime Identifiers (RID). Använd <RuntimeIdentifier> för en enda RID eller använd <RuntimeIdentifiers> för att tillhandahålla en semikolonavgränsad lista över flera RID:er. I följande exempel anges win-x86 RID:

   <PropertyGroup>
     <TargetFramework>{TARGET FRAMEWORK}</TargetFramework>
     <RuntimeIdentifier>win-x86</RuntimeIdentifier>
   </PropertyGroup>
   

2. Från ett kommandogränssnitt publicerar du appen i Release-konfiguration för värdens runtime med kommandot dotnet publish. I följande exempel kommer appen att publiceras för win-x86 RID. RID som tillhandahålls till alternativet --runtime måste anges i egenskapen <RuntimeIdentifier> (eller <RuntimeIdentifiers>) i projektfilen.

   dotnet publish --configuration Release --runtime win-x86 --self-contained
   

3. Flytta innehållet i katalogen bin/Release/{TARGET FRAMEWORK}/{RUNTIME IDENTIFIER}/publish till webbplatsen i App Service. Om du drar publicera mappinnehåll från din lokala hårddisk eller nätverksresurs direkt till App Service i Kudu-konsolendrar du filerna till mappen D:\home\site\wwwroot i Kudu-konsolen.

Protokollinställningar (HTTPS)

Med säkra protokollbindningar kan du ange ett certifikat som ska användas när du svarar på begäranden via HTTPS. Bindning kräver ett giltigt privat certifikat (.pfx) som utfärdats för det specifika värdnamnet. För mer information, se Självstudie: Binda ett befintligt anpassat SSL-certifikat till Azure App Service.

Transformera web.config

Om du behöver transformera web.config vid publicering (till exempel ange miljövariabler baserat på konfiguration, profil eller miljö) kan du läsa Transformera web.config.

Ytterligare resurser

• App Service-översikt
• Översikt över Azure App Service-diagnostik
• Host ASP.NET Core i en webbgrupp
• Självstudie: Ansluta till SQL Database från .NET App Service utan hemligheter med hjälp av en hanterad identitet

Azure App Service på Windows Server använder Internet Information Services (IIS). Kestrel och YARP på frontänden tillhandahåller lastbalanserare. Följande avsnitt gäller den underliggande IIS-tekniken:

• Host ASP.NET Core i Windows med IIS
• ASP.NET Core Module (ANCM) för IIS
• IIS-moduler med ASP.NET Core
• Windows Server – IT-administratörsinnehåll för aktuella och tidigare versioner