Tutorial: Verwenden der dynamischen Konfiguration in einer Azure Functions-App

Artikel
06/01/2023

Der .NET-Konfigurationsanbieter App Configuration unterstützt das dynamische Zwischenspeichern und Aktualisieren der Konfiguration durch Anwendungsaktivitäten. In diesem Tutorial wird veranschaulicht, wie Sie dynamische Konfigurationsupdates in Ihrem Code implementieren können. Es baut auf der Azure Functions-App auf, die in den Schnellstarts vorgestellt wurde. Absolvieren Sie zunächst Erstellen einer Azure Functions-App mit Azure App Configuration, bevor Sie fortfahren.

In diesem Tutorial lernen Sie Folgendes:

Einrichten Ihrer Azure Functions-App für die Aktualisierung der Konfiguration als Reaktion auf Änderungen in einem App Configuration-Speicher
Einfügen der neuesten Konfiguration in Ihre Azure Functions-Aufrufe

Voraussetzungen

Azure-Abonnement – Erstellen eines kostenlosen Kontos
Visual Studio mit der Workload Azure-Entwicklung
Azure Functions-Tools, wenn sie nicht bereits mit Visual Studio installiert sind.
Abgeschlossener Schnellstart: Erstellen einer Azure Functions-App mit Azure App Configuration

Erneutes Laden von Daten aus App Configuration

Azure Functions unterstützt die Ausführung von In-Process oder Isolated-Process. Der Hauptunterschied bei der Verwendung von App Configuration zwischen den beiden Modi besteht darin, wie die Konfiguration aktualisiert wird. Im In-Process-Modus müssen Sie in jeder Funktion einen Aufruf durchführen, um die Konfiguration zu aktualisieren. Im isolated-process-Modus wird Middleware unterstützt. Die App Configuration-Middleware, Microsoft.Azure.AppConfiguration.Functions.Worker, ermöglicht den Aufruf zur automatischen Aktualisierung der Konfiguration, bevor jede Funktion ausgeführt wird.

Aktualisieren Sie den Code, der eine Verbindung zu App Configuration herstellt, und fügen Sie die Datenaktualisierungsbedingungen hinzu.
- In-Process
- Isolierter Prozess
Öffnen Sie Startup.cs, und aktualisieren Sie die Methode ConfigureAppConfiguration.
```
public override void ConfigureAppConfiguration(IFunctionsConfigurationBuilder builder)
{
    builder.ConfigurationBuilder.AddAzureAppConfiguration(options =>
    {
        options.Connect(Environment.GetEnvironmentVariable("ConnectionString"))
                // Load all keys that start with `TestApp:` and have no label
                .Select("TestApp:*")
                // Configure to reload configuration if the registered sentinel key is modified
                .ConfigureRefresh(refreshOptions =>
                    refreshOptions.Register("TestApp:Settings:Sentinel", refreshAll: true));
    });
}
```
Öffnen Sie Program.cs, und aktualisieren Sie die Main-Methode.
```
public static void Main()
{
    var host = new HostBuilder()
        .ConfigureAppConfiguration(builder =>
        {
            builder.AddAzureAppConfiguration(options =>
            {
                options.Connect(Environment.GetEnvironmentVariable("ConnectionString"))
                        // Load all keys that start with `TestApp:` and have no label
                        .Select("TestApp:*")
                        // Configure to reload configuration if the registered sentinel key is modified
                        .ConfigureRefresh(refreshOptions =>
                            refreshOptions.Register("TestApp:Settings:Sentinel", refreshAll: true));
            });
        })
        .ConfigureFunctionsWorkerDefaults()
        .Build();

    host.Run();
}
```
Die ConfigureRefresh-Methode registriert eine Einstellung, die auf Änderungen überprüft werden soll, wann immer eine Aktualisierung innerhalb der Anwendung ausgelöst wird. Der Parameter refreshAll weist den App Configuration-Anbieter an, die gesamte Konfiguration neu zu laden, wenn eine Änderung in der registrierten Einstellung erkannt wird.

Alle für die Aktualisierung registrierten Einstellungen haben einen standardmäßigen Cache-Ablauf von 30 Sekunden, bevor eine neue Aktualisierung versucht wird. Dieser kann durch Aufrufen der Methode AzureAppConfigurationRefreshOptions.SetCacheExpiration aktualisiert werden.
Tipp

Wenn Sie mehrere Schlüsselwerte in App Configuration aktualisieren, möchten Sie normalerweise nicht, dass Ihre Anwendung die Konfiguration neu lädt, bevor alle Änderungen vorgenommen wurden. Sie können einen Sentinel-Schlüssel registrieren und ihn erst aktualisieren, wenn alle anderen Konfigurationsänderungen abgeschlossen sind. Dadurch wird die Konsistenz der Konfiguration in Ihrer Anwendung sichergestellt.

Sie können auch folgende Schritte ausführen, um das Risiko von Inkonsistenzen zu minimieren:
- Entwerfen Sie Ihre Anwendung so, dass sie vorübergehende Konfigurationsinkonsistenzen toleriert.
- Planen Sie eine Warmlaufphase für die Anwendung, bevor Sie sie online schalten (um Anforderungen auszuführen).
- Ermöglichen Sie eine Standardkonfiguration in Ihrer Anwendung, und verwenden Sie diese, wenn die Konfigurationsüberprüfung fehlschlägt.
- Wählen Sie eine Strategie für Aktualisierungen der Konfiguration aus, die die Auswirkungen auf Ihre Anwendung minimiert. Planen Sie solche Änderungen z. B. zu Zeiten mit geringem Datenverkehrsaufkommen.

In-Process
Isolierter Prozess

Aktualisieren Sie die Configure-Methode, um App Configuration-Dienste per Abhängigkeitsinjektion verfügbar zu machen.
```
public override void Configure(IFunctionsHostBuilder builder)
{
    builder.Services.AddAzureAppConfiguration();
}
```

Öffnen Sie Function1.cs, und fügen Sie die folgenden Namespaces hinzu:

using System.Linq;
using Microsoft.Extensions.Configuration.AzureAppConfiguration;

Aktualisieren Sie den Konstruktor, um per Abhängigkeitsinjektion die Instanz von IConfigurationRefresherProvider abzurufen, über die Sie die Instanz von IConfigurationRefresher abrufen können.

private readonly IConfiguration _configuration;
private readonly IConfigurationRefresher _configurationRefresher;

public Function1(IConfiguration configuration, IConfigurationRefresherProvider refresherProvider)
{
    _configuration = configuration;
    _configurationRefresher = refresherProvider.Refreshers.First();
}

Aktualisieren Sie die Run-Methode, und signalisieren Sie die Aktualisierung der Konfiguration mithilfe der TryRefreshAsync-Methode am Anfang des Funktionsaufrufs. Dies ist ein No-Op-Zustand, wenn das Zeitfenster für den Cacheablauf nicht erreicht wird. Entfernen Sie den Operator await, wenn Sie es vorziehen, dass die Konfiguration aktualisiert wird, ohne den aktuellen Functions-Aufruf zu blockieren. In diesem Fall erhalten spätere Functions-Aufrufe den aktualisierten Wert.

public async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req, ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    await _configurationRefresher.TryRefreshAsync(); 

    string keyName = "TestApp:Settings:Message";
    string message = _configuration[keyName];

    return message != null
        ? (ActionResult)new OkObjectResult(message)
        : new BadRequestObjectResult($"Please create a key-value with the key '{keyName}' in App Configuration.");
}

Fügen Sie dem ConfigureServices einen HostBuilder-Aufruf hinzu, um Azure App Configuration-Dienste durch Abhängigkeitsinjektion verfügbar zu machen. Aktualisieren Sie dann ConfigureFunctionsWorkerDefaults, um App Configuration-Middleware für die Aktualisierung der Konfigurationsdaten zu verwenden.

public static void Main()
{
    var host = new HostBuilder()
        .ConfigureAppConfiguration(builder =>
        {
            // Omitted the code added in the previous step.
            // ... ...
        })
        .ConfigureServices(services =>
        {
            // Make Azure App Configuration services available through dependency injection.
            services.AddAzureAppConfiguration();
        })
        .ConfigureFunctionsWorkerDefaults(app =>
        {
            // Use Azure App Configuration middleware for data refresh.
            app.UseAzureAppConfiguration();
        })
        .Build();

    host.Run();
}

Lokales Testen der Funktion

Legen Sie eine Umgebungsvariable mit dem Namen ConnectionString fest, und geben Sie dafür den Zugriffsschlüssel für Ihren App-Konfigurationsspeicher an. Führen Sie bei Verwendung einer Windows-Eingabeaufforderung den folgenden Befehl aus, und starten Sie die Eingabeaufforderung neu, damit die Änderung wirksam wird:
```
setx ConnectionString "connection-string-of-your-app-configuration-store"
```
Führen Sie bei Verwendung von Windows PowerShell den folgenden Befehl aus:
```
$Env:ConnectionString = "connection-string-of-your-app-configuration-store"
```
Führen Sie bei Verwendung von macOS oder Linux den folgenden Befehl aus:
```
export ConnectionString='connection-string-of-your-app-configuration-store'
```
Drücken Sie F5, um Ihre Funktion zu testen. Akzeptieren Sie die entsprechende Aufforderung von Visual Studio zum Herunterladen und Installieren der Azure Functions Core (CLI) -Tools. Sie müssen möglicherweise auch eine Firewallausnahme aktivieren, damit die Tools HTTP-Anforderungen verarbeiten können.
Kopieren Sie die URL Ihrer Funktion aus der Azure Functions-Laufzeitausgabe.
Fügen Sie die URL zu der HTTP-Anforderung in die Adressleiste Ihres Browsers ein. In der folgenden Abbildung sehen Sie die Antwort des Browsers auf die von der Funktion zurückgegebene lokale GET-Anforderung.
Melden Sie sich beim Azure-Portal an. Wählen Sie Alle Ressourcen und dann den App Configuration-Speicher aus, den Sie in der Schnellstartanleitung erstellt haben.
Wählen Sie den Konfigurations-Explorer aus, und aktualisieren Sie den Wert der folgenden Schlüssel:

Schlüssel Wert

TestApp:Settings:Message Daten aus Azure App Configuration: Aktualisiert

Erstellen Sie anschließend den Sentinel-Schlüssel, oder ändern Sie seinen Wert, wenn er bereits vorhanden ist. Beispiel:

Schlüssel Wert

TestApp:Settings:Sentinel v1
Aktualisieren Sie den Browser mehrmals. Wenn die zwischengespeicherte Einstellung nach 30 Sekunden abläuft, zeigt die Seite die Antwort des Funktionsaufrufs mit aktualisiertem Wert an.

Schlüssel	Wert
TestApp:Settings:Message	Daten aus Azure App Configuration: Aktualisiert

Schlüssel	Wert
TestApp:Settings:Sentinel	v1

Hinweis

Der in diesem Tutorial verwendete Beispielcode kann aus dem GitHub-Repository für App Configuration heruntergeladen werden.

Bereinigen von Ressourcen

Wenn Sie die in diesem Artikel erstellten Ressourcen nicht mehr verwenden möchten, löschen Sie die erstellte Ressourcengruppe, um Kosten zu vermeiden.

Wichtig

Das Löschen einer Ressourcengruppe kann nicht rückgängig gemacht werden. Die Ressourcengruppe und alle darin enthaltenen Ressourcen werden unwiderruflich gelöscht. Achten Sie daher darauf, dass Sie nicht versehentlich die falsche Ressourcengruppe oder die falschen Ressourcen löschen. Falls Sie die Ressourcen für diesen Artikel in einer Ressourcengruppe erstellt haben, die andere beizubehaltende Ressourcen enthält, löschen Sie die Ressourcen einzeln über den entsprechenden Bereich, statt die Ressourcengruppe zu löschen.

Melden Sie sich beim Azure-Portal an, und klicken Sie auf Ressourcengruppen.
Geben Sie im Feld Nach Name filtern den Namen Ihrer Ressourcengruppe ein.
Wählen Sie in der Ergebnisliste den Ressourcengruppennamen aus, um eine Übersicht anzuzeigen.
Wählen Sie die Option Ressourcengruppe löschen.
Sie werden aufgefordert, das Löschen der Ressourcengruppe zu bestätigen. Geben Sie zur Bestätigung den Namen Ihrer Ressourcengruppe ein, und klicken Sie auf Löschen.

Daraufhin werden die Ressourcengruppe und alle darin enthaltenen Ressourcen gelöscht.

Nächste Schritte

In diesem Tutorial haben Sie Ihre Azure Functions-App aktiviert, um Konfigurationseinstellungen dynamisch aus App Configuration zu aktualisieren. Fahren Sie mit dem nächsten Tutorial fort, um zu erfahren, wie Sie eine von Azure verwaltete Identität hinzufügen, um den Zugriff auf App Configuration zu optimieren.

Greifen Sie mit verwalteter Identität auf App Configuration zu