Rychlý start: Vytvoření konzolové aplikace Go pomocí azure App Configuration

V tomto rychlém startu použijete Azure App Configuration k centralizaci úložiště a správy nastavení aplikací pomocí klientské knihovny zprostředkovatele Azure App Configuration Go.

Zprostředkovatel konfigurace aplikace pro Go zjednodušuje použití hodnot klíčů z aplikace Azure App Configuration na Go. Umožňuje vázání nastavení na strukturu Go. Nabízí funkce, jako je složení konfigurace z více štítků, oříznutí předpony klíčů, automatické rozlišení odkazů na Key Vault a mnoho dalších funkcí.

Požadavky

Účet Azure s aktivním předplatným. Vytvořte si ho zdarma.
Úložiště konfigurace aplikací. Vytvořte úložiště.
Přejděte na verzi 1.21 nebo novější. Nainstalujte Go.

Přidejte klíčové hodnoty

Do úložiště App Configuration přidejte následující hodnoty klíčů. Další informace o tom, jak přidat hodnoty klíčů do úložiště pomocí webu Azure Portal nebo rozhraní příkazového řádku, najdete v tématu Vytvoření hodnoty klíče.

Klíč	Hodnota	Typ obsahu
Config.Message	Ahoj světe!	Nechejte prázdné.
Config.App.Name	Go Console App	Nechejte prázdné.
Config.App.Debug	pravdivý	Nechejte prázdné.
Config.App.Settings	{"timeout": 30, "retryCount": 3}	application/json

Připojení ke službě App Configuration

Vytvořte pro projekt nový adresář.

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

Inicializace nového modulu Go

go mod init app-configuration-quickstart

Přidejte zprostředkovatele Azure App Configuration jako závislost.

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

Vytvořte soubor s názvem appconfig.go s následujícím obsahem. Ke službě App Configuration Store se můžete připojit pomocí Microsoft Entra ID (doporučeno) nebo připojovací řetězec.

Microsoft Entra ID (doporučeno)
Připojovací řetězec

 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
 }

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

Zrušitmarshal

Metoda Unmarshal poskytuje typově bezpečný způsob, jak načíst hodnoty konfigurace do struktur Go. Tento přístup brání chybám za běhu v chybně zatypovaných konfiguračních klíčích a usnadňuje údržbu kódu. Unmarshal je zvláště cenná pro složité konfigurace s vnořenými strukturami, různými datovými typy nebo při práci s mikroslužbami, které vyžadují jasné kontrakty konfigurace napříč komponentami.

Vytvořte soubor s názvem main.go s následujícím obsahem:

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

Bajty JSON

Metoda GetBytes načte vaši konfiguraci jako nezpracovaná data JSON a nabízí flexibilní alternativu ke svázání se strukturou. Tento přístup se bezproblémově integruje s existujícími knihovnami pro zpracování JSON, jako je standardní balíček encoding/json nebo konfigurační rámce jako viper. Je zvlášť užitečná při práci s dynamickými konfiguracemi, když potřebujete dočasně uložit konfiguraci nebo při integraci se stávajícími systémy, které očekávají vstup JSON. Použití metody GetBytes poskytuje přímý přístup ke konfiguraci v univerzálním kompatibilním formátu, ale stále přináší výhody centralizované správy služby Azure App Configuration.

Aktualizujte main.go následujícím obsahem:

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

Spuštění aplikace

Nastavte systémovou proměnnou prostředí pro ověřování.
- Microsoft Entra ID (doporučeno)
- Připojovací řetězec
Nastavte proměnnou prostředí s názvem AZURE_APPCONFIG_ENDPOINT na koncový bod obchodu App Configuration, který najdete v části Přehled obchodu na webu Azure Portal.

Pokud používáte příkazový řádek systému Windows, spusťte následující příkaz a restartujte příkazový řádek, aby se změna projevila:
```
setx AZURE_APPCONFIG_ENDPOINT "<endpoint-of-your-app-configuration-store>"
```
Pokud používáte PowerShell, spusťte následující příkaz:
```
$Env:AZURE_APPCONFIG_ENDPOINT = "<endpoint-of-your-app-configuration-store>"
```
Pokud používáte macOS nebo Linux, spusťte následující příkaz:
```
export AZURE_APPCONFIG_ENDPOINT='<endpoint-of-your-app-configuration-store>'
```
Dále se ujistěte, že jste přihlášeni pomocí Azure CLI, nebo použijte proměnné prostředí pro ověření Azure.
```
az login
```
Nastavte proměnnou prostředí s názvem AZURE_APPCONFIG_CONNECTION_STRING na připojovací řetězec pro čtení z vašeho úložiště App Configuration, který se nachází pod Nastavení přístupu v Azure portálu.

Pokud používáte příkazový řádek systému Windows, spusťte následující příkaz a restartujte příkazový řádek, aby se změna projevila:
```
setx AZURE_APPCONFIG_CONNECTION_STRING "<connection-string-of-your-app-configuration-store>"
```
Pokud používáte PowerShell, spusťte následující příkaz:
```
$Env:AZURE_APPCONFIG_CONNECTION_STRING = "<connection-string-of-your-app-configuration-store>"
```
Pokud používáte macOS nebo Linux, spusťte následující příkaz:
```
export AZURE_APPCONFIG_CONNECTION_STRING='<connection-string-of-your-app-configuration-store>'
```

Po správném nastavení proměnné prostředí spusťte následující příkaz, který spustí příklad Unmarshal a GetBytes :

go mod tidy
go run .

Měl by se zobrazit výstup podobný následujícímu:

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

Vyčistěte zdroje

Pokud nechcete dál používat prostředky vytvořené v tomto článku, odstraňte skupinu prostředků, kterou jste tady vytvořili, abyste se vyhnuli poplatkům.

Důležité

Odstranění skupiny prostředků je nevratné. Skupina prostředků a všechny prostředky v ní se trvale odstraní. Dávejte pozor, abyste omylem neodstranili nesprávnou skupinu prostředků nebo jednotlivé prostředky. Pokud jste vytvořili prostředky pro tento článek ve skupině prostředků, která obsahuje další prostředky, které chcete zachovat, odstraňte jednotlivé prostředky z příslušného podokna místo odstranění skupiny prostředků.

Přihlaste se k webu Azure Portal a vyberte skupiny prostředků.
Do pole Filtrovat podle názvu zadejte název vaší skupiny prostředků.
V seznamu výsledků vyberte název skupiny prostředků, abyste zobrazili přehled.
Vyberte odstranit skupinu zdrojů.
Zobrazí se výzva k potvrzení odstranění skupiny prostředků. Potvrďte název skupiny prostředků a vyberte Odstranit.

Po několika okamžicích se skupina prostředků a všechny její prostředky vymažou.

Další kroky

V tomto rychlém startu jste vytvořili nový obchod App Configuration Store a zjistili jste, jak přistupovat k hodnotám klíčů pomocí zprostředkovatele Azure App Configuration Go v konzolové aplikaci.

Další informace o poskytovateli Azure App Configuration Go najdete v referenční dokumentaci.

Váš názor

Byla tato stránka užitečná?

Last updated on 2025-07-22