Démarrage rapide : Ajouter des indicateurs de fonctionnalité à un service en arrière-plan .NET

Article
12/17/2024

Dans ce guide de démarrage rapide, vous incorporez la fonctionnalité de gestion des fonctionnalités d’Azure App Configuration dans un service en arrière-plan .NET. Vous utilisez App Configuration pour stocker et gérer vos indicateurs de fonctionnalité de manière centralisée.

Prérequis

La prise en charge de la gestion des fonctionnalités étend la fonctionnalité de configuration dynamique dans App Configuration. L’exemple de ce guide de démarrage rapide s’appuie sur l’application de service en arrière-plan .NET introduite dans le tutoriel de configuration dynamique. Avant de continuer, terminez le tutoriel suivant pour créer une application de service en arrière-plan .NET avec une configuration dynamique.

Tutoriel : Utiliser une configuration dynamique dans un service en arrière-plan .NET

Ajouter un indicateur de fonctionnalité

Ajoutez un indicateur de fonctionnalité appelé Bêta au magasin App Configuration et laissez les valeurs par défaut à Étiquette et à Description. Pour plus d’informations sur l’ajout d’indicateurs de fonctionnalité à un magasin à l’aide du portail Azure ou de CLI, accédez à Créer un indicateur de fonctionnalité.

Utiliser l’indicateur de fonctionnalité

Ajoutez des références au package NuGet Microsoft.FeatureManagement en exécutant la commande suivante :
```
dotnet add package Microsoft.FeatureManagement
```
Exécutez la commande suivante pour restaurer les packages de votre projet :
```
dotnet restore
```
Ouvrez Program.cs et ajoutez l’instruction suivante :
```
using Microsoft.FeatureManagement;
```

Ajoutez un appel à la méthode UseFeatureFlags à l’intérieur de l’appel AddAzureAppConfiguration et inscrivez les services de gestion des fonctionnalités.

Microsoft Entra ID (recommandé)
Chaîne de connexion

// Existing code in Program.cs
// ... ...
builder.Configuration.AddAzureAppConfiguration(options =>
{
    string endpoint = Environment.GetEnvironmentVariable("Endpoint"); 
    options.Connect(new Uri(endpoint), new DefaultAzureCredential());

    // Use feature flags
    options.UseFeatureFlags();

    // Register the refresher so that the Worker service can consume it through dependency injection
    builder.Services.AddSingleton(options.GetRefresher());
});

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

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

// Existing code in Program.cs
// ... ...
builder.Configuration.AddAzureAppConfiguration(options =>
{
    options.Connect(Environment.GetEnvironmentVariable("ConnectionString"));

    // Use feature flags
    options.UseFeatureFlags();

    // Register the refresher so that the Worker service can consume it through dependency injection
    builder.Services.AddSingleton(options.GetRefresher());
});

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

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

Conseil

Lorsqu’aucun paramètre n’est passé à la méthode UseFeatureFlags, elle charge tous les indicateurs de fonctionnalité sans étiquette dans votre magasin App Configuration. L’intervalle d’actualisation par défaut des indicateurs de fonctionnalité est de 30 secondes. Vous pouvez personnaliser ce comportement via le paramètre FeatureFlagOptions. Par exemple, l’extrait de code suivant charge uniquement les indicateurs de fonctionnalité qui commencent par TestApp: dans leur nom de clé et ont l’étiquette dev. Le code modifie également l’intervalle d’actualisation à 5 minutes. Notez que cet intervalle d’actualisation est distinct de celui pour les valeurs de clé normales.

options.UseFeatureFlags(featureFlagOptions =>
{
    featureFlagOptions.Select("TestApp:*", "dev");
    featureFlagOptions.CacheExpirationInterval = TimeSpan.FromMinutes(5);
});

Ouvrez Worker.cs et ajoutez l’instruction suivante :
```
using Microsoft.FeatureManagement;
```

Mettez à jour le constructeur du service Worker pour obtenir les instances de IConfigurationRefresher et de IFeatureManager par le biais de l’injection de dépendances.

public class Worker : BackgroundService
{
    private readonly ILogger<Worker> _logger;
    private readonly IConfigurationRefresher _refresher;
    private readonly IFeatureManager _featureManager;

    public Worker(ILogger<Worker> logger, IConfigurationRefresher refresher, IFeatureManager featureManager)
    {
        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
        _refresher = refresher ?? throw new ArgumentNullException(nameof(refresher));
        _featureManager = featureManager ?? throw new ArgumentNullException(nameof(featureManager));
    }

    // ... ...
}

Mettez à jour la méthode ExecuteAsync afin de consigner un message en fonction de l’état de l’indicateur de fonctionnalité.

La méthode TryRefreshAsync est appelée au début de chaque itération de l’exécution de la tâche pour actualiser l’indicateur de fonctionnalité. Aucune opération n’est effectuée si la fenêtre d’intervalle d’actualisation n’est pas atteinte. L’opérateur await n’est pas utilisé afin que les indicateurs de fonctionnalité soient actualisés sans bloquer l’itération actuelle de l’exécution de la tâche. Dans ce cas, les itérations ultérieures de l’exécution de la tâche obtiennent une valeur mise à jour.

protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
    while (!stoppingToken.IsCancellationRequested)
    {
        // Intentionally not await TryRefreshAsync to avoid blocking the execution.
        _refresher.TryRefreshAsync(stoppingToken);

        if (_logger.IsEnabled(LogLevel.Information))
        {
            if (await _featureManager.IsEnabledAsync("Beta"))
            {
                _logger.LogInformation("[{time}]: Worker is running with Beta feature.", DateTimeOffset.Now);
            }
            else
            {
                _logger.LogInformation("[{time}]: Worker is running.", DateTimeOffset.Now);
            }
        }

        await Task.Delay(TimeSpan.FromSeconds(30), stoppingToken);
    }
}

Générer et exécuter l’application localement

Exécutez la commande suivante pour générer l’application :
```
dotnet build
```
La génération terminée correctement, lancez la commande suivante pour exécuter l’application localement :
```
dotnet run
```
Les sorties suivantes devraient s’afficher dans la console.
Connectez-vous au portail Azure. Sélectionnez Toutes les ressources, puis le magasin App Configuration que vous avez créé précédemment.
Sélectionnez Gestionnaire de fonctionnalités et recherchez l’indicateur de fonctionnalité Beta. Activez l’indicateur en cochant la case située sous Activé.
Patientez quelques instants pour que la fenêtre d’intervalle d’actualisation passe. Vous verrez le message de journal mis à jour.

Nettoyer les ressources

Si vous ne souhaitez plus utiliser les ressources créées dans cet article, supprimez le groupe de ressources que vous avez créé ici afin d’éviter des frais.

Important

La suppression d’un groupe de ressources est irréversible. Le groupe de ressources et toutes les ressources qu’il contient sont supprimés définitivement. Veillez à ne pas supprimer accidentellement les mauvaises ressources ou le mauvais groupe de ressources. Si vous avez créé les ressources pour cet article dans un groupe de ressources contenant d’autres ressources que vous souhaitez conserver, supprimez chaque ressource individuellement à partir de son volet, au lieu de supprimer l’intégralité du groupe de ressources.

Connectez-vous au portail Azure, puis sélectionnez Groupes de ressources.
Dans la zone Filtrer par nom, entrez le nom de votre groupe de ressources.
Dans la liste de résultats, sélectionnez le nom du groupe de ressources pour afficher une vue d’ensemble.
Sélectionnez Supprimer le groupe de ressources.
Vous êtes invité à confirmer la suppression du groupe de ressources. Entrez le nom de votre groupe de ressources à confirmer, puis sélectionnez Supprimer.

Après quelques instants, le groupe de ressources et toutes ses ressources sont supprimés.

Étapes suivantes

Dans ce guide de démarrage rapide, vous créez un indicateur de fonctionnalité et vous l’utilisez dans un service en arrière-plan.

Pour activer la fonctionnalité de gestion des fonctionnalités pour d’autres types d’applications, passez aux tutoriels suivants.

Utiliser des indicateurs de fonctionnalités dans les applications ASP.NET Core

Utiliser des indicateurs de fonctionnalité dans des applications console .NET/.NET Framework

Pour en savoir plus sur la gestion des indicateurs de fonctionnalités dans Azure App Configuration, passez au tutoriel suivant.

Gérer les indicateurs de fonctionnalités dans Azure App Configuration

Pour obtenir la liste complète des fonctionnalités de la bibliothèque de gestion des fonctionnalités .NET, passez au document suivant.

Gestion des fonctionnalités .NET

Partager via