Compartilhar via

Início Rápido: Criar um aplicativo de console Go com a Configuração de Aplicativos do Azure

Neste início rápido, você usará a Configuração de Aplicativos do Azure para centralizar o armazenamento e o gerenciamento das configurações do aplicativo usando a biblioteca de clientes do provedor Go da Configuração de Aplicativos do Azure.

O provedor de Configuração de Aplicativos para Go simplifica o esforço de aplicar valores-chave da Configuração de Aplicativos do Azure ao aplicativo Go. Ele habilita as configurações de associação para o struct Go. Oferece também recursos como composição de configuração com base em vários rótulos, corte de prefixo de chave, resolução automática de referências do Key Vault, entre outros.

Pré-requisitos

Adicionar valores-chave

Adicione os seguintes valores-chave ao repositório de Configuração do Aplicativos. Para mais informações sobre como adicionar valores-chave a um repositório usando o portal do Azure ou a CLI, acesse Criar um valor-chave.

Chave Valor Tipo de conteúdo
Config.Message Olá, Mundo! Deixe o campo vazio
Config.App.Name App de Console Go Deixe o campo vazio
Config.App.Debug verdadeiro Deixe o campo vazio
Config.App.Settings {"timeout": 30, "retryCount": 3} aplicativo/json

Conectar-se à Configuração de Aplicativos

  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 Aplicativos do Azure como uma dependência.

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

  4. Crie um arquivo chamado appconfig.go com o conteúdo a seguir. Você pode se conectar ao seu armazenamento de configuração de aplicativo usando o Microsoft Entra ID (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
}

Realizar unmarshaling

O método Unmarshal fornece uma maneira fortemente tipada de carregar valores de configuração em structs Go. Essa abordagem impede erros de execução de chaves de configuração mal digitadas e torna seu código mais mantível. Unmarshal é particularmente valioso para configurações complexas com estruturas aninhadas, tipos de dados diferentes 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 à associação de struct. 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 fornece acesso direto à sua configuração em um formato universalmente compatível, enquanto ainda se beneficia dos recursos de gerenciamento centralizado da Configuração de Aplicativos 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
	// ...
}

Executar o aplicativo

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

    Defina a variável de ambiente denominada AZURE_APPCONFIG_ENDPOINT para o ponto de extremidade do repositório de Configuração de Aplicativos encontrado na Visão Geral do seu repositório no portal do Azure.

    Se você usar o prompt de comando do Windows, execute o comando a seguir 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 comando a seguir:

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

    Além disso, verifique se você fez logon com a CLI do Azure ou use variáveis de ambiente para autenticação do Azure:

    az login

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

    go run unmarshal_sample.go

    Será exibida uma saída semelhante à 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

    Será exibida uma saída semelhante à seguinte:

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

Limpar os recursos

Se não deseja continuar usando os recursos criados neste artigo, exclua o grupo de recursos que você criou aqui para evitar encargos.

Importante

A exclusão de um grupo de recursos é irreversível. O grupo de recursos e todos os recursos contidos nele são excluídos permanentemente. Certifique-se de não excluir o grupo de recursos ou os recursos incorretos acidentalmente. Se tiver criado os recursos para este artigo dentro de um grupo de recursos que contém outros recursos que você deseja manter, exclua cada um individualmente do respectivo 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..., digite o nome do seu grupo de recursos.
  3. Na lista de resultados, selecione o nome do grupo de recursos para conferir uma visão geral.
  4. Selecione Excluir grupo de recursos.
  5. Você receberá uma solicitação para confirmar a exclusão do grupo de recursos. Insira o nome do grupo de recursos para confirmar e selecione Excluir.

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

Próximas etapas

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

Para saber mais sobre o Provedor Go de Configuração de Aplicativo do Azure, consulte o documento de referência.