Udostępnij za pośrednictwem

Szybki start: tworzenie aplikacji konsolowej języka Go za pomocą usługi Azure App Configuration

W tym przewodniku szybkiego startu użyjesz usługi Azure App Configuration do scentralizowanego przechowywania i zarządzania ustawieniami aplikacji przy użyciu biblioteki klienta Azure App Configuration Go.

Dostawca usługi App Configuration dla języka Go upraszcza proces stosowania klucz-wartości z usługi Azure App Configuration do aplikacji Go. Umożliwia powiązanie ustawień ze strukturą w języku Go. Oferuje funkcje, takie jak tworzenie konfiguracji z wielu etykiet, przycinanie prefiksów kluczy, automatyczne rozwiązywanie odwołań do Key Vault i wiele innych.

Wymagania wstępne

Dodawanie kluczy i wartości

Dodaj następujące wartości klucza do magazynu App Configuration. Aby uzyskać więcej informacji na temat dodawania par klucz-wartość do magazynu przy użyciu portalu Azure lub interfejsu wiersza polecenia, przejdź do Utwórz parę klucz-wartość.

Klawisz Wartość Typ zawartości
Config.Message Cześć ludzie! Pozostaw pole puste
Config.App.Name Przejdź do aplikacji konsolowej Pozostaw pole puste
Config.App.Debug prawdziwy Pozostaw pole puste
Config.App.Settings {"timeout": 30, "retryCount": 3} application/json

Nawiązywanie połączenia z usługą App Configuration

  1. Utwórz nowy katalog dla projektu.

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

  2. Zainicjuj nowy moduł Go.

    go mod init app-configuration-quickstart

  3. Dodaj dostawcę usługi Azure App Configuration jako zależność.

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

  4. Utwórz plik o nazwie appconfig.go z następującą zawartością. Możesz połączyć się ze swoim magazynem App Configuration przy użyciu identyfikatora Entra firmy Microsoft (zalecane) lub parametry połączenia.

package main

import (
	"context"
	"fmt"
	"log"
	"os"
	"time"

	"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

Metoda Unmarshal zapewnia typ-bezpieczny sposób ładowania wartości konfiguracyjnych do struktur Go. Takie podejście uniemożliwia błędy środowiska uruchomieniowego z błędnie wtypowanych kluczy konfiguracji i sprawia, że kod jest bardziej konserwowalny. Unmarshal jest szczególnie cenna w przypadku złożonych konfiguracji ze strukturami zagnieżdżonymi, różnorodnymi typami danych lub podczas pracy z mikrousługami, które wymagają jasnych kontraktów konfiguracyjnych między składnikami.

Utwórz plik o nazwie unmarshal_sample.go o następującej zawartości:

package main

import (
	"context"
	"fmt"
	"log"
	"time"
)

// Configuration structure that matches your key-values in App Configuration
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 pobiera konfigurację w formie surowych danych JSON, oferując elastyczną alternatywę dla bezpośredniego powiązania ze strukturą. Takie podejście bezproblemowo integruje się z istniejącymi bibliotekami przetwarzania JSON, takimi jak standardowy pakiet encoding/json lub frameworki konfiguracji, takie jak viper. Jest to szczególnie przydatne podczas pracy z konfiguracjami dynamicznymi, gdy trzeba tymczasowo przechowywać konfigurację lub podczas integracji z istniejącymi systemami, które oczekują danych wejściowych JSON. Korzystanie z funkcji GetBytes zapewnia bezpośredni dostęp do konfiguracji w uniwersalnym formacie zgodnym, a jednocześnie korzysta ze scentralizowanych funkcji zarządzania usługi Azure App Configuration.

Utwórz plik o nazwie getbytes_sample.go o następującej zawartości:

package main

import (
	"context"
	"fmt"
	"log"
	"time"
	
	"github.com/spf13/viper"
)

func main() {
	// Create a context with timeout
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	// Load configuration using the common function
	provider, err := loadAzureAppConfiguration(ctx)
	if err != nil {
		log.Fatalf("Error loading configuration: %v", err)
	}

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

Uruchamianie aplikacji

  1. Ustaw zmienną środowiskową na potrzeby uwierzytelniania.

    Ustaw zmienną środowiskową o nazwie AZURE_APPCONFIG_ENDPOINT na punkt końcowy Twojego sklepu App Configuration, który znajdziesz w sekcji Przegląd w portalu Azure.

    Jeśli używasz wiersza polecenia systemu Windows, uruchom następujące polecenie i uruchom ponownie wiersz polecenia, aby zezwolić na wprowadzenie zmian:

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

    Jeśli używasz programu PowerShell, uruchom następujące polecenie:

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

    Jeśli używasz systemu macOS lub Linux, uruchom następujące polecenie:

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

    Ponadto upewnij się, że zalogowano się przy użyciu interfejsu wiersza polecenia platformy Azure lub użyj zmiennych środowiskowych na potrzeby uwierzytelniania platformy Azure:

    az login

  2. Po poprawnym ustawieniu zmiennej środowiskowej uruchom następujące polecenie, aby uruchomić przykład Unmarshal :

    go run unmarshal_sample.go

    Powinny zostać wyświetlone dane wyjściowe podobne do następujących:

    Configuration Values:
---------------------
Message: Hello World!
App Name: Go Console App
Debug Mode: true
Timeout: 30 seconds
Retry Count: 3

  3. Uruchom przykład getbytes :

    go run getbytes_sample.go

    Powinny zostać wyświetlone dane wyjściowe podobne do następujących:

    Raw JSON Configuration:
------------------------
{"App":{"Debug":true,"Name":"Go Console App","Settings":{"retryCount":3,"timeout":30}},"Message":"Hello World!"}

Uprzątnij zasoby

Jeśli nie chcesz nadal korzystać z zasobów utworzonych w tym artykule, usuń utworzoną tutaj grupę zasobów, aby uniknąć naliczania opłat.

Ważne

Usunięcie grupy zasobów jest nieodwracalne. Grupa zasobów i wszystkie zasoby w niej są trwale usuwane. Upewnij się, że nie usuniesz przypadkowo niewłaściwej grupy zasobów lub zasobów. Jeśli zasoby dla tego artykułu zostały utworzone w grupie zasobów zawierającej inne zasoby, które chcesz zachować, usuń każdy zasób oddzielnie z odpowiedniego okienka zamiast usuwać grupę zasobów.

  1. Zaloguj się do witryny Azure Portal i wybierz pozycję Grupy zasobów.
  2. W polu Filtruj według nazwy wprowadź nazwę grupy zasobów.
  3. Na liście wyników wybierz nazwę grupy zasobów, aby wyświetlić przegląd.
  4. Wybierz pozycję Usuń grupę zasobów.
  5. Poproszono Cię o potwierdzenie usunięcia grupy zasobów. Wprowadź nazwę grupy zasobów, aby potwierdzić, a następnie wybierz pozycję Usuń.

Po kilku chwilach grupa zasobów i wszystkie jej zasoby zostaną usunięte.

Dalsze kroki

W tym szybkim starcie utworzyłeś nowy magazyn App Configuration i nauczyłeś się, jak uzyskiwać dostęp do par klucz-wartości przy użyciu dostawcy Go usługi Azure App Configuration w aplikacji konsolowej.

Aby dowiedzieć się więcej na temat dostawcy języka Go usługi Azure App Configuration, zobacz dokumentację referencyjną.