Partager via

Démarrage rapide : Créer une application console Go avec Azure App Configuration

Dans ce guide de démarrage rapide, vous utilisez Azure App Configuration pour centraliser le stockage et la gestion des paramètres d’application à l’aide de la bibliothèque de client du fournisseur Azure App Configuration Go.

Le fournisseur App Configuration pour Go simplifie l’effort d’application de valeurs clés d’Azure App Configuration à l’application Go. Il permet de lier les paramètres à une struct Go. Il offre des fonctionnalités telles que la composition de la configuration à partir de plusieurs étiquettes, l'élagage des préfixes de clés, la résolution automatique des références du coffre de clés, et bien d'autres encore.

Conditions préalables

Ajouter des clés-valeurs

Ajoutez les valeurs de clés suivantes au magasin App Configuration. Pour plus d’informations sur l’ajout de clés-valeurs à un magasin avec le Portail Azure ou la CLI, consultez Créer une clé-valeur.

Clé Valeur Type de contenu
Config.Message Salut tout le monde! Laissez ce champ vide
Config.App.Name Application console Go Laissez ce champ vide
Config.App.Debug vrai Laissez ce champ vide
Config.App.Settings {"timeout » : 30, « retryCount » : 3} application/json

Se connecter à App Configuration

  1. Créez un nouveau répertoire pour le projet.

    mkdir app-configuration-quickstart
cd app-configuration-quickstart

  2. Initialisez un nouveau module Go.

    go mod init app-configuration-quickstart

  3. Ajoutez le fournisseur Azure App Configuration en tant que dépendance.

    go get github.com/Azure/AppConfiguration-GoProvider/azureappconfiguration

  4. 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.

     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 which keys to load and trimming options
 	options := &azureappconfiguration.Options{
 		Selectors: []azureappconfiguration.Selector{
 			{
 				KeyFilter:   "Config.*",
 				LabelFilter: "",
 			},
 		},
 		TrimKeyPrefixes: []string{"Config."},
 	}

 	// 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
 }

Unmarshal

La Unmarshal méthode fournit un moyen sécurisé de charger des valeurs de configuration dans des structs Go. Cette approche empêche les erreurs d’exécution de clés de configuration mal typées et rend votre code plus gérable. Unmarshal est particulièrement utile pour les configurations complexes avec des structures imbriquées, différents types de données ou lors de l’utilisation de microservices qui nécessitent des contrats de configuration clairs entre les composants.

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

package main

import (
	"context"
	"fmt"
	"log"
	"time"
)

type Config struct {
	Message string
	App     struct {
		Name     string
		Debug    bool
		Settings struct {
			Timeout     int
			RetryCount  int
		}
	}
}

func main() {
	// Create a context with timeout
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	// Load configuration
	provider, err := loadAzureAppConfiguration(ctx)
	if err != nil {
		log.Fatalf("Error loading configuration: %v", err)
	}

	// Create a configuration object and unmarshal the loaded key-values into it
	var config Config
	if err := provider.Unmarshal(&config, nil); err != nil {
		log.Fatalf("Failed to unmarshal configuration: %v", err)
	}

	// Display the configuration values
	fmt.Println("\nConfiguration Values:")
	fmt.Println("---------------------")
	fmt.Printf("Message: %s\n", config.Message)
	fmt.Printf("App Name: %s\n", config.App.Name)
	fmt.Printf("Debug Mode: %t\n", config.App.Debug)
	fmt.Printf("Timeout: %d seconds\n", config.App.Settings.Timeout)
	fmt.Printf("Retry Count: %d\n", config.App.Settings.RetryCount)
}

Octets JSON

La GetBytes méthode récupère votre configuration en tant que données JSON brutes, offrant une alternative flexible à la liaison de struct. Cette approche s’intègre en toute transparence aux bibliothèques de traitement JSON existantes, comme le package standard encoding/json ou les frameworks de configuration tels que viper. Il est particulièrement utile lors de l’utilisation de configurations dynamiques, lorsque vous devez stocker temporairement la configuration ou lors de l’intégration à des systèmes existants qui attendent une entrée JSON. L’utilisation de GetBytes vous donne un accès direct à votre configuration dans un format compatible universel tout en bénéficiant toujours des fonctionnalités de gestion centralisée d’Azure App Configuration.

Mettez à jour main.go avec le contenu suivant :

	// Existing code in main.go
	// ... ...
	fmt.Printf("Timeout: %d seconds\n", config.App.Settings.Timeout)
	fmt.Printf("Retry Count: %d\n", config.App.Settings.RetryCount)

	// Get configuration as JSON bytes
	jsonBytes, err := provider.GetBytes(nil)
	if err != nil {
		log.Fatalf("Failed to get configuration as bytes: %v", err)
	}

	fmt.Println("\nRaw JSON Configuration:")
	fmt.Println("------------------------")
	fmt.Println(string(jsonBytes))
	
	// Initialize a new Viper instance
	v := viper.New()
	v.SetConfigType("json") // Set the config format to JSON
	
	// Load the JSON bytes into Viper
	if err := v.ReadConfig(bytes.NewBuffer(jsonBytes)); err != nil {
		log.Fatalf("Failed to read config into viper: %v", err)
	}

	// Use viper to access your configuration
	// ...

Exécuter l’application

  1. Définissez la variable d’environnement pour l’authentification.

    Définissez la variable d’environnement nommée AZURE_APPCONFIG_ENDPOINT sur le point de terminaison de votre magasin App Configuration qui se trouve sous la Vue d’ensemble de votre magasin dans le Portail Azure.

    Si vous utilisez l’invite de commandes Windows, exécutez la commande suivante et redémarrez l’invite pour que la modification soit prise en compte :

    setx AZURE_APPCONFIG_ENDPOINT "<endpoint-of-your-app-configuration-store>"

    Si vous utilisez PowerShell, exécutez la commande suivante :

    $Env:AZURE_APPCONFIG_ENDPOINT = "<endpoint-of-your-app-configuration-store>"

    Si vous utilisez macOS ou Linux, exécutez la commande suivante :

    export AZURE_APPCONFIG_ENDPOINT='<endpoint-of-your-app-configuration-store>'

    En outre, vérifiez que vous êtes connecté avec Azure CLI ou utilisez des variables d’environnement pour l’authentification Azure :

    az login

  2. Une fois la variable d’environnement correctement définie, exécutez la commande suivante pour exécuter l’exemple Unmarshal et GetBytes :

    go mod tidy
go run .

    Vous devez obtenir une sortie similaire à la suivante :

    Configuration Values:
---------------------
Message: Hello World!
App Name: Go Console App
Debug Mode: true
Timeout: 30 seconds
Retry Count: 3

Raw JSON Configuration:
------------------------
{"App":{"Debug":true,"Name":"Go Console App","Settings":{"retryCount":3,"timeout":30}},"Message":"Hello World!"}

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 magasin App Configuration et appris à accéder aux valeurs clés à l’aide du fournisseur Azure App Configuration Go dans une application console.

Pour en savoir plus sur le fournisseur Go Azure App Configuration, consultez la documentation de référence.

  • Last updated on