Teilen über

Schnellstart: Erstellen einer Go-Konsolen-App mit Azure App-Konfiguration

In dieser Schnellstartanleitung verwenden Sie Die Azure-App-Konfiguration, um den Speicher und die Verwaltung von Anwendungseinstellungen mithilfe der Azure App Configuration Go-Anbieter-Clientbibliothek zu zentralisieren.

Der App-Konfigurationsanbieter für Go vereinfacht die Anwendung von Schlüsselwerten aus der Azure App-Konfiguration auf die Go-Anwendung. Es ermöglicht Bindungseinstellungen die Go-Struktur. Er bietet Features wie die Konfigurationskomposition aus mehreren Bezeichnungen, die Kürzung von Schlüsselpräfixen, die automatische Auflösung von Key Vault-Verweisen und vieles mehr.

Voraussetzungen

Schlüsselwerte hinzufügen

Fügen Sie dem App Configuration-Speicher die folgenden Schlüsselwerte hinzu. Weitere Informationen zum Hinzufügen von Schlüssel-Werten zu einem Speicher mithilfe des Azure-Portals oder der CLI finden Sie unter Erstellen eines Schlüssel-Werts.

Schlüssel Wert Inhaltstyp
Config.Message Hallo Welt! Leer lassen
Config.App.Name Go-Konsolen-App Leer lassen
Config.App.Debug STIMMT Leer lassen
Config.App.Settings {"timeout": 30, "retryCount": 3} application/json

Herstellen einer Verbindung mit App Configuration

  1. Erstellen Sie ein neues Verzeichnis für das Projekt.

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

  2. Initialisieren Sie ein neues Go-Modul.

    go mod init app-configuration-quickstart

  3. Fügen Sie den Azure App-Konfigurationsanbieter als Abhängigkeit hinzu.

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

  4. Erstellen Sie eine Datei namens appconfig.go mit folgendem Inhalt. Sie können eine Verbindung mit Ihrem App Configuration-Speicher entweder mithilfe von Microsoft Entra ID (empfohlen) oder mit einer Verbindungszeichenfolge herstellen.

     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
 }

Marshallen rückgängig machen

Die Unmarshal Methode bietet eine typsichere Methode zum Laden von Konfigurationswerten in Go-Strukturen. Dieser Ansatz verhindert Laufzeitfehler aufgrund falsch eingetippter Konfigurationsschlüssel und macht Ihren Code wartbarer. Unmarshal besonders wertvoll für komplexe Konfigurationen mit geschachtelten Strukturen, unterschiedlichen Datentypen oder beim Arbeiten mit Microservices, die klare Konfigurationsverträge über Komponenten hinweg erfordern.

Erstellen Sie eine Datei mit dem Namen main.go und dem folgenden Inhalt:

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

Die GetBytes Methode ruft Ihre Konfiguration als unformatierte JSON-Daten ab und bietet eine flexible Alternative zur Strukturbindung. Dieser Ansatz lässt sich nahtlos in vorhandene JSON-Verarbeitungsbibliotheken wie das Standardpaket encoding/json oder Konfigurationsframeworks wie viper integrieren. Es ist besonders nützlich, wenn Sie mit dynamischen Konfigurationen arbeiten, wenn Sie die Konfiguration vorübergehend speichern müssen oder wenn Sie eine Integration mit vorhandenen Systemen vornehmen, die JSON-Eingaben erwarten. Die Verwendung von GetBytes bietet Ihnen direkten Zugriff auf Ihre Konfiguration in einem universell kompatiblen Format, während Sie weiterhin von den zentralen Verwaltungsfunktionen der Azure App-Konfiguration profitieren.

Aktualisieren Sie main.go mit dem folgenden Inhalt:

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

Ausführen der Anwendung

  1. Legen Sie die Umgebungsvariable für die Authentifizierung fest.

    Legen Sie die Umgebungsvariable namens AZURE_APPCONFIG_ENDPOINT auf den Endpunkt Ihres App-Konfigurationsspeichers fest, der unter der Übersicht über Ihren Store im Azure-Portal zu finden ist.

    Führen Sie bei Verwendung einer Windows-Eingabeaufforderung den folgenden Befehl aus, und starten Sie die Eingabeaufforderung neu, damit die Änderung wirksam wird:

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

    Wenn Sie PowerShell verwenden, führen Sie den folgenden Befehl aus:

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

    Führen Sie bei Verwendung von macOS oder Linux den folgenden Befehl aus:

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

    Stellen Sie außerdem sicher, dass Sie sich mit der Azure CLI angemeldet haben oder Umgebungsvariablen für die Azure-Authentifizierung verwenden:

    az login

  2. Nachdem die Umgebungsvariable ordnungsgemäß festgelegt wurde, führen Sie den folgenden Befehl aus, um das Beispiel "Unmarshal" und "GetBytes" auszuführen:

    go mod tidy
go run .

    Die Ausgabe sollte in etwa wie folgt aussehen:

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

Bereinigen von Ressourcen

Wenn Sie die in diesem Artikel erstellten Ressourcen nicht mehr verwenden möchten, löschen Sie die erstellte Ressourcengruppe, um Kosten zu vermeiden.

Von Bedeutung

Das Löschen einer Ressourcengruppe kann nicht rückgängig gemacht werden. Die Ressourcengruppe und alle darin enthaltenen Ressourcen werden unwiderruflich gelöscht. Achten Sie daher darauf, dass Sie nicht versehentlich die falsche Ressourcengruppe oder die falschen Ressourcen löschen. Falls Sie die Ressourcen für diesen Artikel in einer Ressourcengruppe erstellt haben, die andere beizubehaltende Ressourcen enthält, löschen Sie die Ressourcen einzeln über den entsprechenden Bereich, statt die Ressourcengruppe zu löschen.

  1. Melden Sie sich beim Azure-Portal an, und klicken Sie auf Ressourcengruppen.
  2. Geben Sie im Feld Nach Name filtern den Namen Ihrer Ressourcengruppe ein.
  3. Wählen Sie in der Ergebnisliste den Ressourcengruppennamen aus, um eine Übersicht anzuzeigen.
  4. Wählen Sie die Option Ressourcengruppe löschen.
  5. Sie werden aufgefordert, das Löschen der Ressourcengruppe zu bestätigen. Geben Sie zur Bestätigung den Namen Ihrer Ressourcengruppe ein, und klicken Sie auf Löschen.

Daraufhin werden die Ressourcengruppe und alle darin enthaltenen Ressourcen gelöscht.

Nächste Schritte

In dieser Schnellstartanleitung haben Sie einen neuen App-Konfigurationsspeicher erstellt und erfahren, wie Sie mithilfe des Azure App Configuration Go-Anbieters in einer Konsolenanwendung auf Schlüsselwerte zugreifen können.

Weitere Informationen zu Azure App Configuration Go Provider finden Sie im Referenzdokument.

  • Last updated on