Partilhar via

Guia de início rápido: criar um aplicativo de console Go com a Configuração do Aplicativo do Azure

Neste início rápido, você usa a Configuração de Aplicativo do Azure para centralizar o armazenamento e o gerenciamento de configurações de aplicativo usando a biblioteca de cliente do provedor do Azure App Configuration Go.

O provedor de Configuração de Aplicativo para Go simplifica o esforço de aplicar valores-chave do aplicativo Azure App Configuration to Go. Ele permite a configuração de vinculação para estruturas Go. Oferece funcionalidades como a composição de configurações a partir de múltiplos rótulos, eliminação de prefixos de chave, resolução automática de referências do Cofre de Chaves e muito mais.

Pré-requisitos

Adicionar valores-chave

Adicione os seguintes valores-chave à App Configuration store. Para obter mais informações sobre como adicionar valores-chave a uma loja usando o portal do Azure ou a CLI, vá para Criar um valor-chave.

Chave Valor Tipo de conteúdo
Config.Message Olá, mundo! Deixar em branco
Config.App.Name Aplicação Go Console Deixar em branco
Config.App.Debug verdadeiro Deixar em branco
Config.App.Settings {"tempo limite": 30, "retryCount": 3} Aplicação/JSON

Conectar-se à configuração do aplicativo

  1. Crie um novo diretório para o projeto.

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

  2. Inicialize um novo módulo Go.

    go mod init app-configuration-quickstart

  3. Adicione o provedor de Configuração de Aplicativo do Azure como uma dependência.

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

  4. Crie um arquivo nomeado appconfig.go com o seguinte conteúdo. Você pode se conectar à sua loja de configuração de aplicativos usando a ID do Microsoft Entra (recomendado) ou uma cadeia de conexão.

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

O Unmarshal método fornece uma maneira segura de tipo para carregar valores de configuração em estruturas Go. Essa abordagem evita erros de tempo de execução de chaves de configuração digitadas incorretamente e torna seu código mais fácil de manter. Unmarshal é particularmente valioso para configurações complexas com estruturas aninhadas, diferentes tipos de dados ou ao trabalhar com microsserviços que exigem contratos de configuração claros entre componentes.

Crie um arquivo nomeado unmarshal_sample.go com o seguinte conteúdo:

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

Bytes JSON

O GetBytes método recupera sua configuração como dados JSON brutos, oferecendo uma alternativa flexível à vinculação estrutural. Essa abordagem integra-se perfeitamente com bibliotecas de processamento JSON existentes, como o pacote padrão encoding/json ou estruturas de configuração, como viper. É particularmente útil ao trabalhar com configurações dinâmicas, quando você precisa armazenar a configuração temporariamente ou ao integrar com sistemas existentes que esperam entrada JSON. O uso do GetBytes oferece acesso direto à sua configuração em um formato universalmente compatível, enquanto ainda se beneficia dos recursos de gerenciamento centralizado da Configuração de Aplicativo do Azure.

Crie um arquivo nomeado getbytes_sample.go com o seguinte conteúdo:

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

Execute o aplicativo

  1. Defina a variável de ambiente para autenticação.

    Defina a variável de ambiente chamada AZURE_APPCONFIG_ENDPOINT para o ponto de extremidade da sua loja de Configuração de Aplicativos encontrado em Visão geral da sua loja no portal do Azure.

    Se você usar o prompt de comando do Windows, execute o seguinte comando e reinicie o prompt de comando para permitir que a alteração entre em vigor:

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

    Se você usar o PowerShell, execute o seguinte comando:

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

    Se você usa macOS ou Linux, execute o seguinte comando:

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

    Além disso, certifique-se de ter iniciado sessão com a CLI do Azure ou utilize variáveis de ambiente para autenticação do Azure:

    az login

  2. Depois que a variável de ambiente estiver definida corretamente, execute o seguinte comando para executar o exemplo Unmarshal :

    go run unmarshal_sample.go

    Deverá ver um resultado similar ao seguinte:

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

  3. Execute o exemplo GetBytes :

    go run getbytes_sample.go

    Deverá ver um resultado similar ao seguinte:

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

Limpeza de recursos

Se não quiser continuar a utilizar os recursos criados neste artigo, elimine o grupo de recursos que criou aqui para evitar cobranças.

Importante

A eliminação de um grupo de recursos é irreversível. O grupo de recursos e todos os recursos nele contidos são excluídos permanentemente. Certifique-se de não excluir acidentalmente o grupo de recursos ou recursos errados. Se você criou os recursos para este artigo dentro de um grupo de recursos que contém outros recursos que deseja manter, exclua cada recurso individualmente de seu respetivo painel em vez de excluir o grupo de recursos.

  1. Entre no portal do Azure e selecione Grupos de recursos.
  2. Na caixa Filtrar por nome, introduza o nome do seu grupo de recursos.
  3. Na lista de resultados, selecione o nome do grupo de recursos para ver uma visão geral.
  4. Selecione Eliminar grupo de recursos.
  5. É-lhe pedido que confirme a eliminação do grupo de recursos. Insira o nome do grupo de recursos a ser confirmado e selecione Excluir.

Após alguns momentos, o grupo de recursos e todos os seus recursos são excluídos.

Próximos passos

Neste início rápido, você criou um novo repositório de Configuração de Aplicativo e aprendeu como acessar valores-chave usando o provedor Azure App Configuration Go em um aplicativo de console.

Para saber mais sobre o Azure App Configuration Go Provider, consulte o documento de referência.