Démarrage rapide : Ajouter des indicateurs de fonctionnalité à une application web Go Gin

Dans ce guide de démarrage rapide, vous allez créer un indicateur de fonctionnalité dans Azure App Configuration et l’utiliser pour contrôler dynamiquement la disponibilité d’une nouvelle page web dans une application web Go Gin sans redémarrer ni redéployer.

La prise en charge de la gestion des fonctionnalités étend la fonctionnalité de configuration dynamique dans App Configuration. Cet exemple montre comment intégrer des indicateurs de fonctionnalité dans une application web Go Gin avec des mises à jour en temps réel et un rendu de page conditionnel.

Conditions préalables

• Un compte Azure avec un abonnement actif. Créez-en un gratuitement.
• Un magasin de configuration d'applications. Créez un magasin.
• Accédez à la version 1.21 ou ultérieure. Pour plus d’informations sur l’installation de Go, consultez la page téléchargements Go.
• Azure App Configuration fournisseur Go v1.1.0 ou version ultérieure.

Créer un indicateur de fonctionnalité

Ajoutez un indicateur de fonctionnalité appelé Bêta au magasin App Configuration et conservez les valeurs par défaut des options É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é.

Créer une application web Go

1. Créez un répertoire pour votre projet Go et accédez-y :

   mkdir gin-feature-flag-quickstart
   cd gin-feature-flag-quickstart
   

2. Initialiser un nouveau module Go :

   go mod init gin-feature-flag-quickstart
   

3. Installez les packages Go requis pour Azure App Configuration, l’infrastructure web Gin et la gestion des fonctionnalités :

   go get github.com/gin-gonic/gin
   go get github.com/microsoft/Featuremanagement-Go/featuremanagement
   go get github.com/microsoft/Featuremanagement-Go/featuremanagement/providers/azappconfig
   

4. Créez un répertoire de modèles pour vos modèles HTML et ajoutez les fichiers HTML requis :

   mkdir templates
   

   Ajoutez les fichiers de modèle HTML suivants à partir du référentiel GitHub et placez-les dans le répertoire templates :

   • index.html - Modèle de page d’accueil
   • beta.html - Modèle de page bêta

Utiliser un indicateur de fonctionnalité

1. Créez un fichier nommé appconfig.go avec le contenu suivant : Vous pouvez vous connecter à votre magasin App Configuration en utilisant Microsoft Entra ID (recommandé) ou une chaîne de connexion.

   Microsoft Entra ID (recommandé)

   package main
   
   import (
       "context"
       "log"
       "os"
   
       "github.com/Azure/AppConfiguration-GoProvider/azureappconfiguration"
       "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
   )
   
   func loadAzureAppConfiguration(ctx context.Context) (*azureappconfiguration.AzureAppConfiguration, error) {
       // Get the endpoint from environment variable
       endpoint := os.Getenv("AZURE_APPCONFIG_ENDPOINT")
       if endpoint == "" {
           log.Fatal("AZURE_APPCONFIG_ENDPOINT environment variable is not set")
       }
   
       // Create a credential using DefaultAzureCredential
       credential, err := azidentity.NewDefaultAzureCredential(nil)
       if err != nil {
           log.Fatalf("Failed to create credential: %v", err)
       }
   
       // Set up authentication options with endpoint and credential
       authOptions := azureappconfiguration.AuthenticationOptions{
           Endpoint:   endpoint,
           Credential: credential,
       }
   
       // Configure feature flag options
       options := &azureappconfiguration.Options{
           FeatureFlagOptions: azureappconfiguration.FeatureFlagOptions{
               Enabled: true,
               RefreshOptions: azureappconfiguration.RefreshOptions{
                   Enabled: true,
               },
           },
       }
   
       // Load configuration from Azure App Configuration
       appConfig, err := azureappconfiguration.Load(ctx, authOptions, options)
       if err != nil {
           log.Fatalf("Failed to load configuration: %v", err)
       }
   
       return appConfig, nil
   }
   

   chaîne de connexion

   package main
   
   import (
       "context"
       "log"
       "os"
   
       "github.com/Azure/AppConfiguration-GoProvider/azureappconfiguration"
   )
   
   func loadAzureAppConfiguration(ctx context.Context) (*azureappconfiguration.AzureAppConfiguration, error) {
       // Get the connection string from environment variable
       connectionString := os.Getenv("AZURE_APPCONFIG_CONNECTION_STRING")
       if connectionString == "" {
           log.Fatal("AZURE_APPCONFIG_CONNECTION_STRING environment variable is not set")
       }
   
       // Set up authentication options with connection string
       authOptions := azureappconfiguration.AuthenticationOptions{
           ConnectionString: connectionString,
       }
   
       // Configure feature flag options
       options := &azureappconfiguration.Options{
           FeatureFlagOptions: azureappconfiguration.FeatureFlagOptions{
               Enabled: true,
               RefreshOptions: azureappconfiguration.RefreshOptions{
                   Enabled: true,
               },
           },
       }
   
       // Load configuration from Azure App Configuration
       appConfig, err := azureappconfiguration.Load(ctx, authOptions, options)
       if err != nil {
           log.Fatalf("Failed to load configuration: %v", err)
       }
   
       return appConfig, nil
   }
   

   Conseil / Astuce

   Quand aucun sélecteur n’est spécifié dans FeatureFlagOptions, il charge tous les indicateurs de fonctionnalité sans étiquette dans votre store 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 RefreshOptions. 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.

   azureappconfiguration.FeatureFlagOptions{
       Enabled: true,
       Selectors: []azureappconfiguration.Selector{
           {
               KeyFilter:   "TestApp:*",
               LabelFilter: "dev",
           },
       },
       RefreshOptions: azureappconfiguration.RefreshOptions{
           Enabled: true,
           Interval: 5 * time.Minute,
       },
   }
   

2. Créez un fichier nommé main.go avec le contenu suivant :

   package main
   
   import (
       "context"
       "fmt"
       "log"
       "net/http"
       "os"
   
       "github.com/Azure/AppConfiguration-GoProvider/azureappconfiguration"
       "github.com/gin-gonic/gin"
       "github.com/microsoft/Featuremanagement-Go/featuremanagement"
       "github.com/microsoft/Featuremanagement-Go/featuremanagement/providers/azappconfig"
   )
   
   type WebApp struct {
       featureManager *featuremanagement.FeatureManager
       appConfig      *azureappconfiguration.AzureAppConfiguration
   }
   
   func (app *WebApp) refreshMiddleware() gin.HandlerFunc {
       return func(c *gin.Context) {
           go func() {
               ctx := context.Background()
               if err := app.appConfig.Refresh(ctx); err != nil {
                   log.Printf("Error refreshing configuration: %v", err)
               }
           }()
           c.Next()
       }
   }
   
   func (app *WebApp) featureMiddleware() gin.HandlerFunc {
       return func(c *gin.Context) {
           // Check if Beta feature is enabled
           betaEnabled, err := app.featureManager.IsEnabled("Beta")
           if err != nil {
               log.Printf("Error checking Beta feature: %v", err)
               betaEnabled = false
           }
   
           // Store feature flag status for use in templates
           c.Set("betaEnabled", betaEnabled)
           c.Next()
       }
   }
   
   func (app *WebApp) setupRoutes(r *gin.Engine) {
       r.Use(app.refreshMiddleware())
       r.Use(app.featureMiddleware())
   
       // Load HTML templates
       r.LoadHTMLGlob("templates/*.html")
   
       // Routes
       r.GET("/", app.homeHandler)
       r.GET("/beta", app.betaHandler)
   }
   
   // Home page handler
   func (app *WebApp) homeHandler(c *gin.Context) {
       betaEnabled := c.GetBool("betaEnabled")
   
       c.HTML(http.StatusOK, "index.html", gin.H{
           "title":       "Feature Management Example App",
           "betaEnabled": betaEnabled,
       })
   }
   
   // Beta page handler
   func (app *WebApp) betaHandler(c *gin.Context) {
       betaEnabled := c.GetBool("betaEnabled")
   
       if !betaEnabled {
           return
       }
   
       c.HTML(http.StatusOK, "beta.html", gin.H{
           "title": "Beta Page",
       })
   }
   
   func main() {
       ctx := context.Background()
   
       // Load Azure App Configuration
       appConfig, err := loadAzureAppConfiguration(ctx)
       if err != nil {
           log.Fatalf("Error loading Azure App Configuration: %v", err)
       }
   
       // Create feature flag provider
       featureFlagProvider, err := azappconfig.NewFeatureFlagProvider(appConfig)
       if err != nil {
           log.Fatalf("Error creating feature flag provider: %v", err)
       }
   
       // Create feature manager
       featureManager, err := featuremanagement.NewFeatureManager(featureFlagProvider, nil)
       if err != nil {
           log.Fatalf("Error creating feature manager: %v", err)
       }
   
       // Create web app
       app := &WebApp{
           featureManager: featureManager,
           appConfig:      appConfig,
       }
   
       // Set up Gin with default middleware (Logger and Recovery)
       r := gin.Default()
   
       // Set up routes
       app.setupRoutes(r)
   
       // Start server
       fmt.Println("Starting server on http://localhost:8080")
       fmt.Println("Open http://localhost:8080 in your browser")
       fmt.Println("Toggle the 'Beta' feature flag in Azure portal to see changes")
       fmt.Println()
   
       if err := r.Run(":8080"); err != nil {
           log.Fatalf("Failed to start server: %v", err)
       }
   }
   

Exécuter l’application web

1. Définissez la variable d’environnement pour l’authentification et exécutez l’application.

   go mod tidy
   go run .
   

2. Ouvrez une fenêtre de navigateur, puis accédez à http://localhost:8080. Votre navigateur doit afficher une page similaire à l’image ci-dessous.

   

3. Connectez-vous au portail Azure. Sélectionnez Toutes les ressources, puis le magasin App Configuration que vous avez créé précédemment.

4. Sélectionnez Gestionnaire de fonctionnalités et recherchez l’indicateur de fonctionnalité Beta. Activez l’indicateur en cochant la case située sous Activé.

5. Actualisez le navigateur à plusieurs reprises. Lorsque la fenêtre d’intervalle d’actualisation passe, la page s’affiche avec du contenu mis à jour :

   

6. Notez que l’élément de menu Bêta apparaît maintenant dans la barre de navigation. Cliquez dessus pour accéder à la page bêta :

   

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.

1. Connectez-vous au portail Azure, puis sélectionnez Groupes de ressources.
2. Dans la zone Filtrer par nom, entrez le nom de votre groupe de ressources.
3. Dans la liste de résultats, sélectionnez le nom du groupe de ressources pour afficher une vue d’ensemble.
4. Sélectionnez Supprimer le groupe de ressources.
5. 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 avez créé un indicateur de fonctionnalité dans Azure App Configuration et l’avez utilisé dans une application web Go Gin. La bibliothèque Go de gestion des fonctionnalités fournit des fonctionnalités d’indicateur de fonctionnalité qui s’intègrent en toute transparence à Azure App Configuration.Pour plus de fonctionnalités, passez au document suivant.

Informations de référence sur la gestion des fonctionnalités Go

Bien qu’un indicateur de fonctionnalité vous permette d’activer ou de désactiver des fonctionnalités dans votre application, vous pouvez personnaliser un indicateur de fonctionnalité en fonction de la logique de votre application. Les filtres de fonctionnalité vous permettent d’activer un indicateur de fonctionnalité de manière conditionnelle. Pour plus d’informations, passez au tutoriel suivant.

Activer des fonctionnalités conditionnelles avec des filtres de fonctionnalités

Azure App Configuration propose des filtres de fonctionnalités intégrés qui vous permettent d’activer un indicateur de fonctionnalité uniquement pendant une période spécifique ou auprès d’un public ciblé particulier de votre application. Pour plus d’informations, passez au tutoriel suivant.

Activer des fonctionnalités selon une planification

Déployer des fonctionnalités pour des publics ciblés