.NET-configuratieprovider

Azure App Configuration is een beheerde service waarmee ontwikkelaars hun toepassingsconfiguraties eenvoudig en veilig kunnen centraliseren. Met de .NET-configuratieproviderbibliotheek kan de configuratie vanuit een Azure App Configuration-archief op een beheerde manier worden geladen. Deze clientbibliotheek voegt extra functionaliteit toe boven op de Azure SDK voor .NET.

Configuratie laden

De .NET-configuratieprovider van Azure App Configuration kan worden geïntegreerd met het .NET-configuratiesysteem, zodat u eenvoudig configuratiewaarden kunt laden uit uw Azure App Configuration-archief. U kunt de provider toevoegen tijdens het opstarten van de toepassing en deze naast andere configuratiebronnen gebruiken.

Als u de .NET-configuratieprovider wilt gebruiken, installeert u het pakket:

dotnet add package Microsoft.Extensions.Configuration.AzureAppConfiguration

U roept AddAzureAppConfiguration de extensiemethode aan IConfigurationBuilder om Azure App Configuration als configuratieprovider aan uw toepassing toe te voegen.

De bibliotheek van de configuratieprovider implementeert een gecombineerd optiespatroon en opbouwpatroon om een schone, declaratieve manier te bieden om het AzureAppConfigurationOptionste configureren. De AddAzureAppConfiguration methode accepteert een Action<AzureAppConfigurationOptions> gemachtigde parameter waarmee u de provider kunt configureren via een fluent-API.

Als u verbinding wilt maken met uw Azure App Configuration-archief, roept u de Connect methode op de AzureAppConfigurationOptions instantie aan, waarmee hetzelfde optiesobject wordt geretourneerd om methodeketening mogelijk te maken.

using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Configuration.AzureAppConfiguration;
using Azure.Identity;

var builder = new ConfigurationBuilder();
builder.AddAzureAppConfiguration(options =>
    {
        string endpoint = Environment.GetEnvironmentVariable("AppConfigurationEndpoint");
        options.Connect(new Uri(endpoint), new DefaultAzureCredential());
    });

var config = builder.Build();
Console.WriteLine(config["TestApp:Settings:Message"] ?? "Hello world!");

var builder = WebApplication.CreateBuilder(args);
builder.Configuration.AddAzureAppConfiguration(options =>
    {
        string endpoint = Environment.GetEnvironmentVariable("Endpoint");
        options.Connect(new Uri(endpoint), new DefaultAzureCredential());
    });

using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Configuration.AzureAppConfiguration;
using Azure.Identity;

var builder = new ConfigurationBuilder();
builder.AddAzureAppConfiguration(options =>
    {
        string connectionString = Environment.GetEnvironmentVariable("ConnectionString");
        options.Connect(connectionString);
    });

var config = builder.Build();
Console.WriteLine(config["TestApp:Settings:Message"] ?? "Hello world!");

var builder = WebApplication.CreateBuilder(args);
builder.Configuration.AddAzureAppConfiguration(options =>
    {
        string connectionString = Environment.GetEnvironmentVariable("ConnectionString");
        options.Connect(connectionString);
    });

Configuratie gebruiken

Nadat u de Azure App Configuration-provider hebt toegevoegd, hebt u op verschillende manieren toegang tot uw configuratiewaarden:

1. Directe toegang

De eenvoudigste methode is om waarden rechtstreeks uit het IConfiguration exemplaar op te halen:

// Directly get the configuration
string message = configuration["TestApp:Settings:Message"];

IConfigurationSection settingsSection = configuration.GetSection("TestApp:Settings");

2. Afhankelijkheidsinjectie met IConfiguration

In services of controllers kunt u de IConfiguration interface rechtstreeks injecteren en gebruiken:

public class WeatherService
{
    private readonly IConfiguration _configuration;

    public WeatherService(IConfiguration configuration)
    {
        _configuration = configuration;
    }

    public Task<WeatherForecast> GetForecastAsync()
    {
        // Access configuration values directly from the injected instance
        string apiEndpoint = _configuration["TestApp:Weather:ApiEndpoint"];

        ...

        return Task.FromResult(new WeatherForecast());
    }
}

3. Optiespatroon voor sterk getypte configuratie

// Define a strongly typed settings class
public class Settings
{
    public string BackgroundColor { get; set; }
    public long FontSize { get; set; }
    public string FontColor { get; set; }
    public string Message { get; set; }
}

builder.Services.Configure<Settings>(builder.Configuration.GetSection("TestApp:Settings"));

Ga naar de documentatie voor meer informatie over het optiespatroon in .NET.

Verwerking van JSON-inhoudstypen

U kunt JSON-sleutelwaarden maken in App Configuration. Wanneer een sleutelwaarde met het inhoudstype "application/json" wordt gelezen, wordt deze door de configuratieprovider afgevlakt in afzonderlijke instellingen binnen IConfiguration. Ga voor meer informatie naar Inhoudstype gebruiken om JSON-sleutelwaarden op te slaan in App Configuration.

Specifieke sleutelwaarden laden met behulp van selectors

De configuratieprovider laadt standaard alle sleutelwaarden zonder label uit App Configuration. U kunt sleutelwaarden selectief laden vanuit uw App Configuration-archief door de Select methode aan te roepen op AzureAppConfigurationOptions.

builder.AddAzureAppConfiguration(options =>
{
    options.Connect(new Uri(endpoint), new DefaultAzureCredential())
        // Load configuration values with prefix "TestApp:" and no label
        .Select("App:Settings:*")
        // Load configuration values with prefix "TestApp:" and "Prod" label
        .Select("App:Settings:*", "Prod")
        // Load configuration values with prefix "TestApp:" and "Prod" label that have the tag "Group" with value "Contoso"
        .Select("App:Settings:*", "Prod", new[] { "Group=Contoso" })
});

De Select methode heeft drie parameters. De eerste parameter is een sleutelfilter dat aangeeft welke sleutels moeten worden geladen, de tweede parameter is een labelfilter dat aangeeft welke sleutelwaarden met specifieke labels moeten worden geladen. De derde parameter geeft een verzameling tagfilters op die allemaal aanwezig moeten zijn op een sleutelwaarde die moet worden geladen.

Sleutelfilter

De sleutelfilterparameter bepaalt welke configuratiesleutels moeten worden opgenomen:

• Exacte overeenkomst: Het gebruik van een specifieke tekenreeks komt overeen met alleen sleutels die exact overeenkomen met het filter.
• Overeenkomst met voorvoegsel: Door een sterretje (*) aan het einde toe te voegen, wordt er een voorvoegselfilter gemaakt (bijvoorbeeld: App:Settings:* alle sleutels die beginnen met 'App:Settings:' worden geladen).
• Meervoudige sleutelselectie: met behulp van een komma (,) kunt u meerdere expliciete sleutels selecteren (bijvoorbeeld Key1,Key2,Key3).
• Gereserveerde tekens: het sterretje (*), de komma (,) en de backslash (\) zijn gereserveerd en moeten worden voorzien van een backslash wanneer deze wordt gebruikt in sleutelnamen (bijvoorbeeld het sleutelfilter a\\b\,\*c* retourneert alle sleutelwaarden waarvan de sleutel begint met a\b,*c.).

Labelfilter

De labelfilterparameter selecteert sleutelwaarden met een specifiek label. Als dit niet is opgegeven, wordt de ingebouwde LabelFilter.Null functie gebruikt.

Tagfilters

De parameter tagfilters selecteert sleutelwaarden met specifieke tags. Een sleutelwaarde wordt alleen geladen als deze alle tags en bijbehorende waarden bevat die zijn opgegeven in de filters. Als u een null-waarde TagValue.Null voor een tag wilt opgeven, kan de ingebouwde waarde worden gebruikt.

Voorvoegsel bijsnijden van sleutels

Wanneer u configuratiewaarden met specifieke voorvoegsels laadt, kunt u de TrimKeyPrefix methode gebruiken om deze voorvoegsels uit de sleutels in uw configuratie te verwijderen. Hiermee maakt u schonere configuratiesleutels in uw toepassing terwijl u de organisatie in uw App Configuration-archief onderhoudt.

builder.AddAzureAppConfiguration(options =>
{
    options.Connect(new Uri(endpoint), new DefaultAzureCredential())
        // Load configuration values with prefix "TestApp:" and trim the prefix
        .Select("TestApp:*")
        .TrimKeyPrefix("TestApp:");
});

Als uw App Configuration-archief bijvoorbeeld een sleutel met de naam TestApp:Settings:Messagebevat, is deze toegankelijk in uw toepassing, net als Settings:Message na het bijsnijden van het TestApp: voorvoegsel.

Toewijzing van configuratie-instellingen

Bij het laden van sleutelwaarden uit Azure App Configuration haalt de provider deze eerst op als ConfigurationSetting objecten voordat deze worden toegevoegd aan het .NET-configuratiesysteem. Met de Map API kunt u deze instellingen tijdens deze pijplijn transformeren, zodat u kunt bepalen hoe configuraties in uw toepassing worden weergegeven.

De Map methode accepteert een gedelegeerde functie die een ConfigurationSetting object ontvangt, kunt u het wijzigen en retourneert een ValueTask<ConfigurationSetting>. Dit is met name handig voor sleutelnaamtransformaties of waardeopmaak op basis van runtimevoorwaarden.

In het volgende voorbeeld ziet u hoe u de Map API gebruikt om dubbele onderstrepingstekens (__) te vervangen door dubbele puntjes (:) in configuratiesleutels. Deze transformatie behoudt de hiërarchische structuur die door .NET-configuratie wordt verwacht wanneer sleutels alternatieve tekens moeten gebruiken in App Configuration:

builder.Configuration.AddAzureAppConfiguration(options =>
{
    options.Connect(new Uri(appConfigEndpoint), new DefaultAzureCredential())
        .Map((setting) =>
        {
            // Transform keys from format "App__Settings__Message" to "App:Settings:Message"
            setting.Key = setting.Key.Replace("__", ":");
            
            return new ValueTask<ConfigurationSetting>(setting);
        });
});

Configuratie vernieuwen

Als u vernieuwen configureert, kan de toepassing de meest recente waarden ophalen uit het App Configuration-archief zonder dat u opnieuw hoeft op te starten. U kunt de ConfigureRefresh methode aanroepen om het vernieuwen van de sleutelwaarde te configureren.

builder.Configuration.AddAzureAppConfiguration(options =>
{
    options.Connect(new Uri(appConfigEndpoint), new DefaultAzureCredential())
        // Load all keys that start with `TestApp:` and have no label
        .Select(keyFilter: "TestApp:*", labelFilter: LabelFilter.Null)
        .ConfigureRefresh(refreshOptions => {
            // Trigger full configuration refresh when any selected key changes.
            refreshOptions.RegisterAll()
            // Check for changes no more often than every 60 seconds
                .SetRefreshInterval(TimeSpan.FromSeconds(60));
        });
});

In de ConfigureRefresh methode roept u de methode aan om de RegisterAll App Configuration-provider te instrueren om de configuratie opnieuw te laden wanneer er een wijziging wordt gedetecteerd in een van de geselecteerde sleutelwaarden (die beginnen met TestApp: en geen label hebben).

U kunt een aanroep toevoegen aan de SetRefreshInterval methode om de minimale tijd op te geven tussen het vernieuwen van de configuratie. Als dit niet is ingesteld, is het standaardvernieuwingsinterval 30 seconden.

Vernieuwen starten

Om de vernieuwing te activeren, moet u de TryRefreshAsync methode van de IConfigurationRefresher oproepen. Azure App Configuration biedt verschillende patronen voor implementatie, afhankelijk van uw toepassingsarchitectuur.

1. Afhankelijkheidsinjectie

Registreer de vernieuwingsservice voor toepassingen die gebruikmaken van afhankelijkheidsinjectie (inclusief ASP.NET Core- en achtergrondservices):

builder.Configuration.AddAzureAppConfiguration(options =>
{
    options.Connect(new Uri(appConfigEndpoint), new DefaultAzureCredential())            
           .ConfigureRefresh(refreshOptions =>
           {
                refreshOptions.RegisterAll()
                    .SetRefreshInterval(TimeSpan.FromSeconds(60));
           })
});

// Register refresher service with the DI container
builder.Services.AddAzureAppConfiguration();

builder.Services.AddAzureAppConfiguration() voegt de IConfigurationRefreshProvider service toe aan de DI-container, waarmee u toegang hebt tot de vernieuwingen van alle Azure App Configuration-bronnen in de configuratie van de toepassing.

ASP.NET Core-toepassingen

Voor ASP.NET Core-toepassingen kunt u het Microsoft.Azure.AppConfiguration.AspNetCore pakket gebruiken om aanvraaggestuurde configuratievernieuwing te bereiken met een ingebouwde middleware.

dotnet add package Microsoft.Azure.AppConfiguration.AspNetCore

Nadat u de service hebt geregistreerd, belt u UseAzureAppConfiguration om AzureAppConfigurationRefreshMiddleware toe te voegen aan uw applicatiepijplijn zodat de configuratie automatisch wordt vernieuwd bij binnenkomende verzoeken.

...

// Call the AddAzureAppConfiguration to add refresher service to the DI container
builder.Services.AddAzureAppConfiguration();

var app = builder.Build();

// Call the app.UseAzureAppConfiguration() method as early as appropriate in your request pipeline so another middleware doesn't skip it
app.UseAzureAppConfiguration();

// Continue with other middleware registration
app.UseRouting();
...

De AzureAppConfigurationRefreshMiddleware functie controleert automatisch op configuratiewijzigingen bij het geconfigureerde vernieuwingsinterval. Deze methode is efficiënt omdat alleen wordt vernieuwd wanneer aan beide voorwaarden wordt voldaan: een HTTP-aanvraag wordt ontvangen en het vernieuwingsinterval is verstreken.

Achtergrondservices

Voor achtergrondservices kunt u de IConfigurationRefresherProvider service injecteren en elk van de geregistreerde vernieuwingen handmatig vernieuwen.

public class Worker : BackgroundService
{
    private readonly IConfiguration _configuration;
    private readonly IEnumerable<IConfigurationRefresher> _refreshers;

    public Worker(IConfiguration configuration, IConfigurationRefresherProvider refresherProvider)
    {
        _configuration = configuration;
        _refreshers = refresherProvider.Refreshers;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        foreach (IConfigurationRefresher refresher in _refreshers)
        {
            refresher.TryRefreshAsync();
        }

        ...
    }
}

2. Directe toegang

Voor toepassingen die geen afhankelijkheidsinjectie gebruiken, kunt u de vernieuwing rechtstreeks verkrijgen via de opties:

IConfigurationRefresher refresher = null;
var builder = new ConfigurationBuilder();
builder.AddAzureAppConfiguration(options =>
{
    options.Connect(new Uri(appConfigEndpoint), new DefaultAzureCredential())            
           .ConfigureRefresh(refreshOptions =>
           {
               refreshOptions.RegisterAll();
           });

    // Store the refresher for later use
    refresher = options.GetRefresher();
});

IConfiguration config = builder.Build();

// Later in your code, trigger refresh when needed
if (refresher != null)
{
    await refresher.TryRefreshAsync()
}

Console.WriteLine(config["TestApp:Settings:Message"]);

Verversen van de sentinel-sleutel

Een sentinel-sleutel is een sleutel die u bijwerkt nadat u de wijziging van alle andere sleutels hebt voltooid. De configuratieprovider bewaakt de sentinel-sleutel in plaats van alle geselecteerde sleutelwaarden. Wanneer er een wijziging wordt gedetecteerd, vernieuwt uw app alle configuratiewaarden.

Deze methode is handig bij het bijwerken van meerdere sleutelwaarden. Als u de sentinel-sleutel pas bijwerkt nadat alle andere configuratiewijzigingen zijn voltooid, zorgt u ervoor dat uw toepassing de configuratie slechts eenmaal opnieuw laadt, zodat de consistentie behouden blijft.

builder.Configuration.AddAzureAppConfiguration(options =>
{
    options.Connect(new Uri(appConfigEndpoint), new DefaultAzureCredential())
        // Load all keys that start with `TestApp:` and have no label
        .Select(keyFilter: "TestApp:*", labelFilter: LabelFilter.Null)
        .ConfigureRefresh(refreshOptions => {
            // Trigger full configuration refresh only if the `SentinelKey` changes.
            refreshOptions.Register("SentinelKey", refreshAll: true);
        });
});

Ga naar Zelfstudie: Dynamische configuratie gebruiken in een ASP.NET Core-app voor meer informatie over het vernieuwen van de configuratie.

Functievlag

Functievlagmen in Azure App Configuration bieden een moderne manier om de beschikbaarheid van functies in uw toepassingen te beheren. In tegenstelling tot normale configuratiewaarden moeten functievlagmen expliciet worden geladen met behulp van de UseFeatureFlags methode. U kunt op FeatureFlagOptions configureren voor het laden van specifieke functievlaggen met behulp van selectors en het interval instellen voor het verversen van de functievlaggen.

builder.Configuration.AddAzureAppConfiguration(options =>
{
    options.Connect(new Uri(appConfigEndpoint), new DefaultAzureCredential())
        .UseFeatureFlags(featureFlagOptions => {
            // Load feature flags with prefix "TestApp:" and "dev" label
            featureFlagOptions.Select("TestApp:*", "dev")
            // Check for changes no more often than every 60 seconds
                .SetRefreshInterval(TimeSpan.FromSeconds(60));
        });
});

In de UseFeatureFlags methode roept u de Select methode aan om functievlagmen selectief te laden. U kunt sleutelfilters, labelfilters en tagfilters gebruiken om de functievlaggen te selecteren die u wilt laden. Als er geen Select methode wordt aangeroepen, UseFeatureFlags worden alle functievlagmen zonder label standaard geladen.

Anders dan sleutelwaarden worden functievlagmen automatisch geregistreerd voor vernieuwen zonder expliciete ConfigureRefresh aanroep. U kunt de minimale tijd opgeven tussen het vernieuwen van functievlag's via de SetRefreshInterval methode. Het standaardvernieuwingsinterval is 30 seconden.

Functiebeheer

De bibliotheek voor functiebeheer biedt een manier om toepassingsfunctionaliteit te ontwikkelen en beschikbaar te maken op basis van functievlagmen. De functiebeheerbibliotheek is ontworpen om te werken in combinatie met de bibliotheek van de configuratieprovider. Installeer het Microsoft.FeatureManagement-pakket:

dotnet add package Microsoft.FeatureManagement

Aanroepen AddFeatureManagement kunt u om IVariantFeatureManager en gerelateerde services in de DI-container te registreren. Deze registratie maakt functievlagfunctionaliteit beschikbaar in uw toepassing via afhankelijkheidsinjectie.

using Microsoft.FeatureManagement;

...

builder.Configuration.AddAzureAppConfiguration(options =>
{
    options.Connect(new Uri(appConfigEndpoint), new DefaultAzureCredential());
    // Use feature flags
    options.UseFeatureFlags();
});

// Register feature management services
builder.Services.AddFeatureManagement();

In het volgende voorbeeld ziet u hoe u de functiebeheerservice gebruikt via afhankelijkheidsinjectie:

public class WeatherForecastController : ControllerBase
{
    private readonly IFeatureManager _featureManager;

    public WeatherForecastController(IVariantFeatureManager featureManager)
    {
        _featureManager = featureManager;
    }

    [HttpGet]
    public async Task<IActionResult> Get()
    {
        // Check if a feature flag is enabled
        if (await _featureManager.IsEnabledAsync("WeatherForecast"))
        {
            var forecast = GenerateWeatherForecast();
            return Ok(forecast);
        }
        
        return NotFound("Weather forecast feature is not available");
    }
}

Ga naar de quickstart voor functievlagmarkeringen voor meer informatie over het gebruik van de functiebeheerbibliotheek.

Functievlagtelemetrie

Wanneer telemetrie van functies is ingeschakeld, injecteert de Azure App Configuration provider aanvullende eigenschappen aan de telemetriegegevens van functies. Deze eigenschappen bieden meer context over de functievlag en de bijbehorende evaluatie:

• AllocationID: een unieke id die de status van de toewijzing van de functievlag aangeeft.
• ETag: de huidige ETag voor de functievlag.
• FeatureFlagReference: een verwijzing naar de functievlag in de indeling van <your_store_endpoint>kv/<feature_flag_key>. Wanneer een label aanwezig is, bevat de verwijzing deze als een queryparameter: <your_store_endpoint>kv/<feature_flag_key>?label=<feature_flag_label>.

Het volledige schema vindt u in de definitie van het gebeurtenisschema voor de evaluatie van de functie van de app-configuratiefunctie. Ga voor meer informatie over het gebruik van de telemetrie voor functie-vlaggen naar de telemetrie inschakelen voor functie-vlaggen handleiding.

Naslaginformatie over Key Vault

Azure-app Configuration ondersteunt het verwijzen naar geheimen die zijn opgeslagen in Azure Key Vault. In App Configuration kunt u sleutels maken die zijn toegewezen aan geheimen die zijn opgeslagen in Key Vault. De geheimen worden veilig opgeslagen in Key Vault, maar kunnen net als elke andere configuratie worden geopend nadat ze zijn geladen.

De bibliotheek van de configuratieprovider haalt key Vault-verwijzingen op, net zoals voor andere sleutels die zijn opgeslagen in App Configuration. Omdat de client de sleutels herkent als Key Vault-verwijzingen, hebben ze een uniek inhoudstype en maakt de client verbinding met Key Vault om hun waarden voor uw toepassing op te halen.

Verbinding maken met Key Vault

U moet de ConfigureKeyVault methode aanroepen om te configureren hoe u verbinding maakt met Key Vault. De Azure App Configuration-provider biedt meerdere manieren om uw Key Vault-geheimen te verifiëren en te openen.

1. Instantie registreren SecretClient

U kunt opgegeven SecretClient exemplaren registreren voor het oplossen van verwijzingen naar geheimen vanuit een bijbehorende sleutelkluis.

using Azure.Identity;
using Azure.Security.KeyVault.Secrets;

...

var secretClient = new SecretClient(new Uri(vaultUri), new DefaultAzureCredential());

builder.Configuration.AddAzureAppConfiguration(options =>
{
    options.Connect(new Uri(appConfigEndpoint), new DefaultAzureCredential())  
        .ConfigureKeyVault(kv =>
        {
            // Register a SecretClient instance
            kv.Register(secretClient);
        });
});

2. Referentie gebruiken

U kunt de referentie instellen die wordt gebruikt voor verificatie bij sleutelkluizen die niet zijn geregistreerd SecretClient.

using Azure.Identity;

...

builder.Configuration.AddAzureAppConfiguration(options =>
{
    options.Connect(new Uri(appConfigEndpoint), new DefaultAzureCredential())  
        .ConfigureKeyVault(kv =>
        {
            // Use DefaultAzureCredential to access all Key Vaults
            kv.SetCredential(new DefaultAzureCredential());
        });
});

3. Aangepaste geheime resolver gebruiken

U kunt ook aanroepen SetSecretResolver om een aangepaste geheime resolver toe te voegen die wordt gebruikt wanneer er geen geregistreerde SecretClient gegevens beschikbaar zijn of als de opgegeven referentie niet kan worden geverifieerd bij Key Vault. Deze methode accepteert een gedelegeerde functie waarmee een Key Vault-URI wordt omgezet in een geheime waarde. In het volgende voorbeeld ziet u hoe u een geheime resolver gebruikt die een geheim ophaalt uit omgevingsvariabelen in ontwikkeling en terugvalwaarden gebruikt wanneer het geheim niet kan worden opgehaald uit Key Vault.

var secretClient = new SecretClient(new Uri(vaultUri), new DefaultAzureCredential());

builder.Configuration.AddAzureAppConfiguration(options =>
{
    options.Connect(new Uri(appConfigEndpoint), new DefaultAzureCredential())  
        .ConfigureKeyVault(kv =>
        {
            // Add a custom secret resolver function
            kv.SetSecretResolver(async (Uri secretUri) =>
            {                
                if (builder.Environment.IsDevelopment())
                {
                    return Environment.GetEnvironmentVariable("FALLBACK_SECRET_VALUE");
                }

                try 
                {
                    var secret = await secretClient.GetSecretAsync(secretName);
                    return secret.Value;
                }
                catch (Exception ex)
                {
                    logger.LogWarning($"Failed to retrieve secret from {secretUri}: {ex.Message}");
                    
                    return Environment.GetEnvironmentVariable("FALLBACK_SECRET_VALUE");
                }
            });
        });
});

Key Vault geheim verversen

Met Azure App Configuration kunt u geheime vernieuwingsintervallen onafhankelijk van uw configuratievernieuwingscyclus configureren. Dit is van cruciaal belang voor beveiliging, omdat de Key Vault-referentie-URI in App Configuration ongewijzigd blijft, het onderliggende geheim in Key Vault mogelijk wordt geroteerd als onderdeel van uw beveiligingsprocedures.

Configureer de SetSecretRefreshInterval methode om ervoor te zorgen dat uw toepassing altijd de meest recente geheime waarden gebruikt. Dit dwingt de provider om nieuwe geheime waarden op te halen uit Key Vault wanneer:

• Uw toepassingsoproepen IConfigurationRefresher.TryRefreshAsync
• Het geconfigureerde vernieuwingsinterval voor het geheim is verstreken

Dit mechanisme werkt zelfs wanneer er geen wijzigingen worden gedetecteerd in uw App Configuration-winkel, zodat uw toepassing gesynchroniseerd blijft met gewisselde geheimen.

builder.Configuration.AddAzureAppConfiguration(options =>
{
    options.Connect(new Uri(appConfigEndpoint), new DefaultAzureCredential())
        .ConfigureKeyVault(kv =>
        {
            kv.SetCredential(new DefaultAzureCredential());

            // Option 1: Set refresh interval for specific secrets
            kv.SetSecretRefreshInterval("ApiKey", TimeSpan.FromHours(12)); 
            
            // Option 2: Set a global refresh interval for all secrets with no refresh interval specified
            kv.SetSecretRefreshInterval(TimeSpan.FromHours(24));
        })
        .ConfigureRefresh(refreshOptions => refreshOptions.RegisterAll());
});

Voor meer informatie over het gebruik van Key Vault-naslaginformatie gaat u naar de zelfstudie: Key Vault-verwijzingen gebruiken in een ASP.NET Core-app.

Momentopname

Momentopname is een benoemde, onveranderbare subset van de sleutelwaarden van een App Configuration-archief. De sleutelwaarden waaruit een momentopname bestaat, worden tijdens het maken gekozen via het gebruik van sleutel- en labelfilters. Zodra een momentopname is gemaakt, blijven de sleutelwaarden binnen gegarandeerd ongewijzigd.

U kunt aanroepen SelectSnapshot om sleutelwaarden uit een momentopname te laden.

builder.Configuration.AddAzureAppConfiguration(options =>
{
    options.Connect(new Uri(appConfigEndpoint), new DefaultAzureCredential());
    // Select an existing snapshot by name. This adds all of the key-values and feature flags from the snapshot to this application's configuration.
    options.SelectSnapshot("SnapshotName");
});

Ga naar Momentopnamen maken en gebruiken voor informatie over het gebruik van momentopnamen.

Verwijzing naar momentopname

Een momentopnameverwijzing is een configuratie-instelling die verwijst naar een momentopname in hetzelfde App Configuration-archief. Wanneer deze is geladen, wordt deze door de provider omgezet en worden alle sleutelwaarden uit die momentopname toegevoegd. Met behulp van momentopnameverwijzingen schakelt u tijdens runtime tussen momentopnamen, in tegenstelling tot SelectSnapshot("..."), waarvoor codewijzigingen en/of opnieuw moeten worden opgestart om over te schakelen naar een nieuwe momentopname.

Ga naar het concept voor momentopnamereferenties voor meer informatie over het maken van een momentopnamereferentie.

Opnieuw opstarten

Het laden van de configuratie is een kritieke padbewerking tijdens het opstarten van de toepassing. Om de betrouwbaarheid te garanderen, implementeert de Azure App Configuration-provider een robuust mechanisme voor opnieuw proberen tijdens de eerste configuratiebelasting. Dit helpt uw toepassing te beschermen tegen tijdelijke netwerkproblemen die anders kunnen voorkomen dat het opstarten is geslaagd.

U kunt dit gedrag aanpassen met behulp van de ConfigureStartupOptions methode:

builder.Configuration.AddAzureAppConfiguration(options =>
{
    options.Connect(new Uri(appConfigEndpoint), new DefaultAzureCredential())
        .ConfigureStartupOptions(startupOptions =>
        {
            // Set the time-out for the initial configuration load
            startupOptions.Timeout = TimeSpan.FromSeconds(60);
        });
});

Geo-replicatie

Ga naar Geo-replicatie inschakelen voor informatie over het gebruik van geo-replicatie.

Gedistribueerde tracering

De .NET-provider van Azure App Configuration bevat ingebouwde ondersteuning voor gedistribueerde tracering, zodat u configuratiebewerkingen in uw toepassing kunt bewaken en problemen kunt oplossen. De provider stelt een ActivitySource genaamd "Microsoft.Extensions.Configuration.AzureAppConfiguration" beschikbaar, die Activity wordt gestart voor essentiële bewerkingen, zoals het laden en vernieuwen van de configuratie.

In het volgende voorbeeld ziet u hoe u OpenTelemetry configureert om gedistribueerde traceringen vast te leggen en te bewaken die zijn gegenereerd door de configuratieprovider:

List<Activity> exportedActivities = new();
builder.Services.AddOpenTelemetry()
    .WithTracing(traceBuilder => {
        traceBuilder.AddSource(["Microsoft.Extensions.Configuration.AzureAppConfiguration"]);
            .AddInMemoryExporter(exportedActivities)
    });

Zie de OpenTelemetry .NET-documentatie voor meer informatie over OpenTelemetry in .NET.

Gezondheidscontrole

De .NET-provider van Azure App Configuration biedt ondersteuning voor statuscontroles van .NET-apps. Als u statuscontroles wilt inschakelen, kunt u de AddAzureAppConfiguration()-methode aanroepen op IHealthChecksBuilder, waarmee een IHealthCheck wordt toegevoegd met een standaardregistratienaam van "Microsoft.Extensions.Configuration.AzureAppConfiguration".

builder.Configuration.AddAzureAppConfiguration(options => 
    options.Connect(new Uri(appConfigEndpoint), new DefaultAzureCredential()));

builder.Services.AddHealthChecks()
    .AddAzureAppConfiguration();

De .NET-provider wordt als beschadigd beschouwd wanneer de laatste laad- of vernieuwingspoging is mislukt.

Zie de documentatie voor .NET-statuscontrole voor meer informatie over statuscontroles in .NET.

Verbinding maken met Azure Front Door

Met de integratie van Azure Front Door kunnen clienttoepassingen configuratie ophalen van eindpunten in de edge-cache in plaats van rechtstreeks vanuit App Configuration. Deze architectuur biedt veilige, schaalbare configuratietoegang met de prestatievoordelen van wereldwijde CDN-distributie.

In het volgende voorbeeld ziet u hoe u configuratie-instellingen laadt vanuit Azure Front Door:

builder.Configuration.AddAzureAppConfiguration(options =>
{
    options.ConnectAzureFrontDoor(new Uri("{YOUR-AFD-ENDPOINT}"))
            .Select("TestApp:*")
            .ConfigureRefresh(refreshOptions =>
            {
                refreshOptions.RegisterAll()
                    .SetRefreshInterval(TimeSpan.FromMinutes(1));
            });
});

Zie Load Configuration van Azure Front Door in clienttoepassingen voor meer informatie over Azure Front Door.

Volgende stappen

Als u wilt weten hoe u de .NET-configuratieprovider gebruikt, gaat u verder met de volgende zelfstudie.