Delen via

Quickstart: Een Go-console-app maken met Azure App Configuration

In deze quickstart gebruikt u Azure App Configuration om de opslag en het beheer van toepassingsinstellingen te centraliseren met behulp van de Clientbibliotheek van de Azure App Configuration Go-provider.

De App Configuration-provider voor Go vereenvoudigt het toepassen van sleutelwaarden van Azure App Configuration op Go-toepassing. Hiermee kunnen bindingsinstellingen aan een Go-struct worden verbonden. Het biedt functies zoals configuratiesamenstelling van meerdere labels, het bijsnijden van sleutelvoorvoegsels, automatische resolutie van Key Vault-verwijzingen en nog veel meer.

Vereiste voorwaarden

Sleutelwaarden toevoegen

Voeg de volgende sleutelwaarden toe aan de App Configuration-opslag. Ga naar Een sleutelwaarde maken voor meer informatie over het toevoegen van sleutelwaarden aan een opslag met de Azure Portal of de CLI.

Sleutelcode Waarde Inhoudstype
Config.Message Hallo wereld! Leeg laten
Config.App.Name Go-console-app Leeg laten
Config.App.Debug waar Leeg laten
Config.App.Settings {"time-out": 30, "retryCount": 3} application/json

Verbinding maken met App Configuration

  1. Maak een nieuwe map voor het project.

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

  2. Initialiseer een nieuwe Go-module.

    go mod init app-configuration-quickstart

  3. Voeg de Azure App Configuration-provider toe als een afhankelijkheid.

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

  4. Maak een bestand met de naam appconfig.go met de volgende inhoud. U kunt verbinding maken met uw App Configuration-archief met behulp van Microsoft Entra ID (aanbevolen) of een verbindingsreeks.

     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
 }

Onmarshal

De Unmarshal methode biedt een typeveilige manier om configuratiewaarden in Go-structs te laden. Met deze methode voorkomt u dat runtimefouten onjuiste configuratiesleutels bevatten en dat uw code beter kan worden onderhouden. Unmarshal is met name waardevol voor complexe configuraties met geneste structuren, verschillende gegevenstypen of bij het werken met microservices waarvoor duidelijke configuratiecontracten tussen onderdelen zijn vereist.

Maak een bestand met de naam main.go met de volgende inhoud:

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-bytes

De GetBytes methode haalt uw configuratie op als onbewerkte JSON-gegevens en biedt een flexibel alternatief voor structbinding. Deze benadering kan naadloos worden geïntegreerd met bestaande JSON-verwerkingsbibliotheken, zoals het standaardpakket encoding/json of configuratieframeworks, zoals viper. Het is met name handig wanneer u met dynamische configuraties werkt, wanneer u de configuratie tijdelijk moet opslaan of wanneer u integreert met bestaande systemen waarvoor JSON-invoer wordt verwacht. Met GetBytes hebt u rechtstreeks toegang tot uw configuratie in een universeel compatibele indeling, terwijl u nog steeds profiteert van de gecentraliseerde beheermogelijkheden van Azure App Configuration.

Werk main.go bij met de volgende inhoud:

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

De toepassing uitvoeren

  1. Stel de omgevingsvariabele in voor verificatie.

    Stel de omgevingsvariabele met de naam AZURE_APPCONFIG_ENDPOINT in op het eindpunt van uw App Configuration-opslag gevonden onder het Overzicht van uw opslag in de Azure-portal.

    Als u de Windows-opdrachtprompt gebruikt, voert u de volgende opdracht uit en start u de opdrachtprompt opnieuw om de wijziging door te voeren:

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

    Als u PowerShell gebruikt, voert u de volgende opdracht uit:

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

    Als u macOS of Linux gebruikt, voert u de volgende opdracht uit:

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

    Zorg er bovendien voor dat u bent aangemeld met de Azure CLI of omgevingsvariabelen voor Azure-verificatie hebt gebruikt:

    az login

  2. Nadat de omgevingsvariabele juist is ingesteld, voert u de volgende opdracht uit om het voorbeeld Unmarshal en GetBytes uit te voeren:

    go mod tidy
go run .

    U zou een uitvoer moeten zien die lijkt op het volgende:

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

De hulpbronnen opschonen

Als u de resources die in dit artikel zijn gemaakt niet wilt blijven gebruiken, verwijdert u de resourcegroep die u hier hebt gemaakt om kosten te voorkomen.

Belangrijk

Het verwijderen van een resourcegroep kan niet ongedaan worden gemaakt. De resourcegroep en alle resources daarin worden permanent verwijderd. Zorg ervoor dat u niet per ongeluk de verkeerde groep of bronnen verwijdert. Als u de resources voor dit artikel in een resourcegroep hebt gemaakt die andere resources bevat die u wilt behouden, moet u elke resource afzonderlijk verwijderen uit het deelvenster in plaats van dat u de resourcegroep verwijdert.

  1. Meld u aan bij de Azure-portal en selecteer Resourcegroepen.
  2. Voer in het vak Filteren op naam de naam van uw resourcegroep in.
  3. Selecteer in de resultatenlijst de resourcegroepnaam om een overzicht te bekijken.
  4. Selecteer Resourcegroep verwijderen.
  5. U wordt gevraagd om het verwijderen van de resourcegroep te bevestigen. Voer de naam van de resourcegroep in die u wilt bevestigen en selecteer Verwijderen.

Na enkele ogenblikken worden de resourcegroep en alle bijbehorende resources verwijderd.

Volgende stappen

In deze quickstart hebt u een nieuw App Configuration-archief gemaakt en geleerd hoe u toegang krijgt tot sleutelwaarden met behulp van de Azure App Configuration Go-provider in een consoletoepassing.

Zie het referentiedocument voor meer informatie over De Go-provider van Azure App Configuration.