Snabbstart: Skapa en Go-konsolapp med Azure App Configuration

I den här snabbstarten använder du Azure App Configuration för att centralisera lagring och hantering av programinställningar med hjälp av Klientbiblioteket för Azure App Configuration Go-providern.

Appkonfigurationsprovidern för Go förenklar arbetet med att tillämpa nyckelvärden från Azure App Configuration till Go-programmet. Det aktiverar bindningsinställningar för Go-struct. Det erbjuder funktioner som konfigurationssammansättning från flera etiketter, trimning av nyckelprefix, automatisk upplösning av Key Vault-referenser och mycket mer.

Förutsättningar

• Ett Azure-konto med en aktiv prenumeration. Skapa en kostnadsfritt.
• En konfigurationsbutik för appar. Skapa en butik.
• Gå 1.21 eller senare. Installera Go.

Lägga till nyckelvärden

Lägg till följande nyckelvärden i App Configuration Store. Mer information om hur du lägger till nyckelvärden i en lagring med hjälp av Azure-portalen eller CLI finns i Skapa ett nyckelvärde.

Ansluta till appkonfiguration

1. Skapa en ny katalog för projektet.

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

2. Initiera en ny Go-modul.

   go mod init app-configuration-quickstart
   

3. Lägg till Azure App Configuration-providern som ett beroende.

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

4. Skapa en fil med namnet appconfig.go med följande innehåll. Du kan ansluta till appkonfigurationsarkivet med hjälp av Microsoft Entra-ID (rekommenderas) eller en anslutningssträng.

   • Microsoft Entra-ID (rekommenderas)
   • Anslutningssträng

    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
    }
   

Omarshal

Metoden Unmarshal ger ett typsäkert sätt att läsa in konfigurationsvärden i Go-structs. Den här metoden förhindrar körningsfel från feltypade konfigurationsnycklar och gör koden mer underhållsbar. Unmarshal är särskilt värdefullt för komplexa konfigurationer med kapslade strukturer, olika datatyper eller när du arbetar med mikrotjänster som kräver tydliga konfigurationskontrakt mellan komponenter.

Skapa en fil med namnet main.go med följande innehåll:

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

JSON-byte

Metoden GetBytes hämtar din konfiguration som råa JSON-data och erbjuder ett flexibelt alternativ till structbindning. Den här metoden integreras sömlöst med befintliga JSON-bearbetningsbibliotek som standardpaketet encoding/json eller konfigurationsramverk som viper. Det är särskilt användbart när du arbetar med dynamiska konfigurationer, när du behöver lagra konfigurationen tillfälligt eller när du integrerar med befintliga system som förväntar sig JSON-indata. Med GetBytes får du direkt åtkomst till konfigurationen i ett universellt kompatibelt format samtidigt som du drar nytta av Azure App Configurations centraliserade hanteringsfunktioner.

Uppdatera main.go med följande innehåll:

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

Starta programmet

1. Ange miljövariabeln för autentisering.

   • Microsoft Entra-ID (rekommenderas)
   • Anslutningssträng

   Ange miljövariabeln med namnet AZURE_APPCONFIG_ENDPOINT till slutpunkten för din App Configuration-butik som finns i Azure-portalen under Översikt över din butik.

   Om du använder Windows-kommandotolken kör du följande kommando och startar om kommandotolken så att ändringen börjar gälla:

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

   Om du använder PowerShell kör du följande kommando:

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

   Om du använder macOS eller Linux kör du följande kommando:

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

   Kontrollera dessutom att du har loggat in med Azure CLI eller använder miljövariabler för Azure-autentisering:

   az login
   

2. När miljövariabeln har angetts korrekt kör du följande kommando för att köra exemplet Unmarshal och GetBytes :

   go mod tidy
   go run .
   

   Du bör se utdata som liknar följande:

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

Rensa resurser

Om du inte vill fortsätta använda resurserna som skapas i den här artikeln tar du bort resursgruppen som du skapade här för att undvika avgifter.

1. Logga in på Azure Portal och välj Resursgrupper.
2. I rutan Filtrera efter namn anger du namnet på resursgruppen.
3. I resultatlistan väljer du resursgruppens namn för att se en översikt.
4. Välj Ta bort resursgrupp.
5. Du blir ombedd att bekräfta borttagningen av resursgruppen. Ange namnet på resursgruppen för att bekräfta och välj Ta bort.

Efter en liten stund tas resursgruppen och alla dess resurser bort.

Nästa steg

I den här snabbstarten skapade du ett nytt appkonfigurationsarkiv och lärde dig att komma åt nyckelvärden med hjälp av Azure App Configuration Go-providern i ett konsolprogram.

Mer information om Azure App Configuration Go Provider finns i referensdokumentet.