Condividi tramite

Guida introduttiva: Creare un'app console Go tramite la configurazione delle app di Azure

In questa guida introduttiva si usa Configurazione app di Azure per centralizzare l'archiviazione e la gestione delle impostazioni dell'applicazione usando la libreria client del provider Go di Configurazione app di Azure.

Il provider di configurazione delle app per Go semplifica l'applicazione delle coppie chiave-valore dalla configurazione delle app di Azure all'applicazione Go. Abilita le impostazioni di associazione allo struct Go. Offre funzionalità come la composizione della configurazione da più etichette, la rimozione dei prefissi di chiave, la risoluzione automatica dei riferimenti a Key Vault e molte altre ancora.

Prerequisiti

Aggiungere coppie chiave-valore

Aggiungere le coppie chiave-valore seguenti all'archivio di Configurazione app. Per altre informazioni su come aggiungere valori chiave a un archivio usando il portale di Azure o l’interfaccia della riga di comando, andare a Creare un valore chiave.

Chiave Valore Tipo di contenuto
Config.Message Salve, mondo! Lasciare vuoto
Config.App.Name Go Console App Lasciare vuoto
Config.App.Debug true Lasciare vuoto
Config.App.Settings {"timeout": 30, "retryCount": 3} application/json

Connettersi a Configurazione app

  1. Creare una nuova directory per il progetto.

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

  2. Inizializzare un nuovo modulo Go.

    go mod init app-configuration-quickstart

  3. Aggiungere il provider di Configurazione app di Azure come dipendenza.

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

  4. Creare un file denominato appconfig.go con il contenuto seguente. È possibile connettersi all'archivio di Configurazione app usando Microsoft Entra ID (scelta consigliata) o una stringa di connessione.

     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

Il Unmarshal metodo fornisce un modo sicuro per caricare i valori di configurazione in struct Go. Questo approccio previene errori di runtime dovuti a chiavi di configurazione digitate incorrettamente e rende il codice più manutenibile. Unmarshal è particolarmente utile per configurazioni complesse con strutture annidate, tipi di dati diversi o quando si lavora con microservizi che richiedono contratti di configurazione chiari tra i componenti.

Creare un file denominato main.go con il contenuto seguente:

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

Byte JSON

Il GetBytes metodo recupera la configurazione come dati JSON non elaborati, offrendo un'alternativa flessibile all'associazione di struct. Questo approccio si integra perfettamente con librerie di elaborazione JSON esistenti, ad esempio il pacchetto standard encoding/json o i framework di configurazione, viperad esempio . È particolarmente utile quando si lavora con configurazioni dinamiche, quando è necessario archiviare temporaneamente la configurazione o quando si esegue l'integrazione con sistemi esistenti che prevedono l'input JSON. L'uso di GetBytes consente di accedere direttamente alla configurazione in un formato compatibile universalmente, sfruttando al contempo le funzionalità di gestione centralizzate di Configurazione app di Azure.

Aggiornare main.go con il contenuto seguente:

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

Eseguire l'applicazione

  1. Impostare la variabile di ambiente per l'autenticazione.

    Impostare la variabile di ambiente denominata AZURE_APPCONFIG_ENDPOINT sull'endpoint dell'archivio di Configurazione app disponibile in Panoramica dello store nel portale di Azure.

    Se si usa il prompt dei comandi di Windows, eseguire il comando seguente e riavviare il prompt per rendere effettiva la modifica:

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

    Se si usa PowerShell, eseguire il comando seguente:

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

    Se si usa macOS o Linux, eseguire il comando seguente:

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

    Assicurarsi inoltre di aver eseguito l'accesso con l'interfaccia della riga di comando di Azure o di usare le variabili di ambiente per l'autenticazione di Azure:

    az login

  2. Dopo aver impostato correttamente la variabile di ambiente, eseguire il comando seguente per eseguire l'esempio Unmarshal e GetBytes :

    go mod tidy
go run .

    L'output dovrebbe essere simile al seguente:

    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!"}

Pulire le risorse

Se non si vuole continuare a usare le risorse create in questo articolo, eliminare il gruppo di risorse creato qui per evitare addebiti.

Importante

L'eliminazione di un gruppo di risorse è irreversibile. Il gruppo di risorse e tutte le risorse in esso contenute vengono eliminati in modo permanente. Assicurarsi di non eliminare accidentalmente il gruppo di risorse o le risorse sbagliate. Se le risorse per questo articolo sono state create in un gruppo di risorse che contiene altre risorse che si vogliono mantenere, eliminare ogni risorsa singolarmente dal rispettivo riquadro anziché eliminare il gruppo di risorse.

  1. Accedere al portale di Azure e selezionare Gruppi di risorse.
  2. Nella casella Filtra per nome immettere il nome del gruppo di risorse.
  3. Nell'elenco dei risultati selezionare il nome del gruppo di risorse per visualizzare una panoramica.
  4. Selezionare Elimina gruppo di risorse.
  5. Verrà chiesto di confermare l'eliminazione del gruppo di risorse. Immettere il nome del gruppo di risorse per confermare e selezionare Elimina.

Dopo qualche istante, il gruppo di risorse e tutte le risorse che contiene vengono eliminati.

Passaggi successivi

In questa guida introduttiva è stato creato un nuovo archivio di Configurazione app e si è appreso come accedere ai valori chiave usando il provider Go di Configurazione app di Azure in un'applicazione console.

Per altre informazioni sul provider Go di Configurazione app di Azure, vedere la documentazione di riferimento.

  • Last updated on