Snabbstart: Skapa en ASP.NET Core-app med Azure App Configuration

Artikel
03/05/2024

I den här snabbstarten använder du Azure App Configuration för att externalisera lagring och hantering av dina appinställningar för en ASP.NET Core-app. ASP.NET Core skapar ett enda nyckelvärdesbaserat konfigurationsobjekt med inställningar från en eller flera konfigurationsprovidrar. App Configuration erbjuder ett .NET-konfigurationsproviderbibliotek. Därför kan du använda App Configuration som en extra konfigurationskälla för din app. Om du har en befintlig app behöver du bara några små ändringar i appens startkod för att börja använda App Configuration.

Förutsättningar

Ett Azure-konto med en aktiv prenumeration. Skapa en kostnadsfritt.
Ett appkonfigurationsarkiv. Skapa en butik.
.NET SDK 6.0 eller senare

Dricks

Azure Cloud Shell är ett kostnadsfritt interaktivt gränssnitt som du kan använda för att köra kommandoradsinstruktionerna i den här artikeln. Den har vanliga Azure-verktyg förinstallerade, inklusive .NET SDK. Om du är inloggad på din Azure-prenumeration startar du Azure Cloud Shell från shell.azure.com. Du kan lära dig mer om Azure Cloud Shell genom att läsa vår dokumentation

Lägga till nyckelvärden

Lägg till följande nyckelvärden i App Configuration Store och lämna Etikett och Innehållstyp med sina standardvärden. Mer information om hur du lägger till nyckelvärden i ett arkiv med hjälp av Azure-portalen eller CLI finns i Skapa ett nyckelvärde.

Tangent	Värde
TestApp:Inställningar:BackgroundColor	Vit
TestApp:Inställningar:FontColor	Svart
TestApp:Inställningar:FontSize	24
TestApp:Inställningar:Message	Data från Azure App Configuration

Skapa en ASP.NET Core-webbapp

Använd .NET-kommandoradsgränssnittet (CLI) för att skapa ett nytt ASP.NET Core-webbappsprojekt. Azure Cloud Shell tillhandahåller dessa verktyg åt dig. De är också tillgängliga på Plattformarna Windows, macOS och Linux.

Kör följande kommando för att skapa en ASP.NET Core-webbapp i en ny TestAppConfig-mapp :

dotnet new webapp --output TestAppConfig --framework net6.0

Anslut till App Configuration Store

Navigera till projektets katalog TestAppConfig och kör följande kommando för att lägga till en Microsoft.Azure.AppConfiguration.AspNetCore NuGet-paketreferens:
```
dotnet add package Microsoft.Azure.AppConfiguration.AspNetCore
```
Kör följande kommando. Kommandot använder Secret Manager för att lagra en hemlighet med namnet ConnectionStrings:AppConfig, som lagrar anslutningssträng för appkonfigurationsarkivet. <your_connection_string> Ersätt platshållaren med appkonfigurationsarkivets anslutningssträng. Du hittar anslutningssträng under Åtkomstnycklar för appkonfigurationsarkivet i Azure-portalen.
```
dotnet user-secrets init
dotnet user-secrets set ConnectionStrings:AppConfig "<your_connection_string>"
```
Dricks

Vissa gränssnitt trunkerar anslutningssträng såvida det inte omges av citattecken. Kontrollera att kommandots dotnet user-secrets list utdata visar hela anslutningssträng. Om den inte gör det kör du kommandot igen och omsluter anslutningssträng med citattecken.

Secret Manager lagrar hemligheten utanför projektträdet, vilket förhindrar oavsiktlig delning av hemligheter i källkoden. Den används bara för att testa webbappen lokalt. När appen distribueras till Azure som App Service använder du Anslut ionssträngar, programinställningar eller miljövariabler för att lagra anslutningssträng. Du kan också undvika anslutningssträng tillsammans genom att ansluta till App Configuration med hjälp av hanterade identiteter eller dina andra Microsoft Entra-identiteter.
Öppna Program.cs och lägg till Azure App Configuration som en extra konfigurationskälla genom att anropa AddAzureAppConfiguration metoden.
```
var builder = WebApplication.CreateBuilder(args);

// Retrieve the connection string
string connectionString = builder.Configuration.GetConnectionString("AppConfig");

// Load configuration from Azure App Configuration
builder.Configuration.AddAzureAppConfiguration(connectionString);

// The rest of existing code in program.cs
// ... ...
```
Den här koden ansluter till appkonfigurationsarkivet med hjälp av en anslutningssträng och läser in alla nyckelvärden som inte har några etiketter. Mer information om appkonfigurationsprovidern finns i API-referensen för appkonfigurationsprovidern.

Läsa från App Configuration Store

I det här exemplet uppdaterar du en webbsida för att visa dess innehåll med hjälp av de inställningar som du konfigurerade i appkonfigurationsarkivet.

Lägg till en Inställningar.cs fil i roten i projektkatalogen. Den definierar en starkt skriven Settings klass för den konfiguration som du ska använda. Ersätt namnområdet med namnet på projektet.

namespace TestAppConfig
{
    public class Settings
    {
        public string BackgroundColor { get; set; }
        public long FontSize { get; set; }
        public string FontColor { get; set; }
        public string Message { get; set; }
    }
}

Binda avsnittet TestApp:Settings i konfigurationen till objektet Settings .

Uppdatera Program.cs med följande kod och lägg till TestAppConfig namnområdet i början av filen.

using TestAppConfig;

// Existing code in Program.cs
// ... ...

builder.Services.AddRazorPages();

// Bind configuration "TestApp:Settings" section to the Settings object
builder.Services.Configure<Settings>(builder.Configuration.GetSection("TestApp:Settings"));

var app = builder.Build();

// The rest of existing code in program.cs
// ... ...

Öppna Index.cshtml.cs i katalogen Pages och uppdatera IndexModel klassen med följande kod. using Microsoft.Extensions.Options Lägg till namnområdet i början av filen, om det inte redan finns där.

public class IndexModel : PageModel
{
    private readonly ILogger<IndexModel> _logger;

    public Settings Settings { get; }

    public IndexModel(IOptionsSnapshot<Settings> options, ILogger<IndexModel> logger)
    {
        Settings = options.Value;
        _logger = logger;
    }
}

Öppna Index.cshtml i katalogen Pages och uppdatera innehållet med följande kod.

@page
@model IndexModel
@{
    ViewData["Title"] = "Home page";
}

<style>
    body {
        background-color: @Model.Settings.BackgroundColor;
    }

    h1 {
        color: @Model.Settings.FontColor;
        font-size: @(Model.Settings.FontSize)px;
    }
</style>

<h1>@Model.Settings.Message</h1>

Skapa och köra appen lokalt

Om du vill skapa appen med hjälp av .NET CLI går du till rotkatalogen för projektet. Kör följande kommando i kommandogränssnittet:
```
dotnet build
```
När bygget har slutförts kör du följande kommando för att köra webbappen lokalt:
```
dotnet run
```
Utdata från dotnet run kommandot innehåller två URL:er. Öppna en webbläsare och gå till någon av dessa URL:er för att få åtkomst till ditt program. Exempel: https://localhost:5001.

Om du arbetar i Azure Cloud Shell väljer du knappen Webbförhandsgranskning följt av Konfigurera. När du uppmanas att konfigurera porten för förhandsversion anger du 5000 och väljer Öppna och bläddra.

Webbsidan ser ut så här:

Rensa resurser

Om du inte vill fortsätta använda resurserna som skapas i den här artikeln tar du bort resursgruppen som du skapade här för att undvika avgifter.

Viktigt!

Att ta bort en resursgrupp kan inte ångras. Resursgruppen och alla resurser i den tas bort permanent. Se till att du inte oavsiktligt tar bort fel resursgrupp eller resurser. Om du har skapat resurserna för den här artikeln i en resursgrupp som innehåller andra resurser som du vill behålla tar du bort varje resurs individuellt från respektive fönster i stället för att ta bort resursgruppen.

Logga in på Azure-portalen och välj Resursgrupper.
I rutan Filtrera efter namn anger du namnet på resursgruppen.
I resultatlistan väljer du resursgruppens namn för att se en översikt.
Välj Ta bort resursgrupp.
Du blir ombedd att bekräfta borttagningen av resursgruppen. Ange namnet på resursgruppen för att bekräfta och välj Ta bort.

Efter en liten stund tas resursgruppen och alla dess resurser bort.

Nästa steg

I den här snabbstarten kommer du att göra följande:

Etablerade ett nytt appkonfigurationsarkiv.
Anslut till appkonfigurationsarkivet med hjälp av appkonfigurationsproviderbiblioteket.
Läs appkonfigurationsarkivets nyckelvärden med konfigurationsproviderbiblioteket.
Visade en webbsida med de inställningar som du konfigurerade i appkonfigurationsarkivet.

Om du vill lära dig hur du konfigurerar din ASP.NET Core-webbapp för att dynamiskt uppdatera konfigurationsinställningarna fortsätter du till nästa självstudie.

Aktivera dynamisk konfiguration

Dela via