Compartir a través de

Inicio rápido: Creación de una aplicación de consola de Go con Azure App Configuration

En este inicio rápido, usa Azure App Configuration para centralizar el almacenamiento y la administración de la configuración de aplicaciones mediante la biblioteca cliente del proveedor Go de App Configuration.

El proveedor de App Configuration para Go simplifica el esfuerzo de aplicar los valores de clave de Azure App Configuration a la aplicación Go. Habilita la configuración de enlace a la estructura Go. Ofrece características como la composición de configuración a partir de varias etiquetas, el recorte de prefijos clave, la resolución automática de referencias de Key Vault y muchas más.

Prerrequisitos

Agregar pares de clave-valor

Agregue los siguientes pares de clave-valor al almacén de App Configuration. Para obtener más información sobre cómo agregar pares clave-valor a un almacén mediante Azure Portal o la CLI, vaya a Creación de un par clave-valor.

Clave Importancia Tipo de contenido
Config.Message Hola mundo Dejar en blanco
Config.App.Name Aplicación de consola de Go Dejar en blanco
Config.App.Debug verdadero Dejar en blanco
Config.App.Settings {"timeout": 30, "retryCount": 3} application/json

Conexión a App Configuration

  1. Cree un nuevo directorio para el proyecto.

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

  2. Inicialice un nuevo módulo de Go.

    go mod init app-configuration-quickstart

  3. Agregue el proveedor de Azure App Configuration como dependencia.

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

  4. Cree un archivo llamado appconfig.go con el siguiente contenido. Puede conectarse al almacén de App Configuration mediante Microsoft Entra ID (recomendado) o una cadena de conexión.

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
}

Deserializar

El Unmarshal método proporciona una manera segura de cargar valores de configuración en estructuras de Go. Este enfoque evita los errores en tiempo de ejecución relacionados con claves de configuración mal escritas y hace que tu código sea más fácil de mantener. Unmarshal es especialmente útil para configuraciones complejas con estructuras anidadas, tipos de datos diferentes o cuando se trabaja con microservicios que requieren contratos de configuración claros entre componentes.

Cree un archivo denominado unmarshal_sample.go con el siguiente contenido:

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

El GetBytes método recupera su configuración en formato JSON sin procesar, lo que ofrece una alternativa flexible al enlace de estructuras. Este enfoque se integra perfectamente con bibliotecas de procesamiento JSON existentes, como el paquete estándar encoding/json o marcos de configuración, como viper. Es especialmente útil cuando se trabaja con configuraciones dinámicas, cuando es necesario almacenar la configuración temporalmente o cuando se integra con sistemas existentes que esperan la entrada JSON. El uso de GetBytes proporciona acceso directo a la configuración en un formato compatible universalmente, a la vez que se beneficia de las funcionalidades de administración centralizadas de Azure App Configuration.

Cree un archivo denominado getbytes_sample.go con el siguiente contenido:

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

Ejecutar la aplicación

  1. Establezca la variable de entorno para la autenticación.

    Establezca la variable de entorno denominada AZURE_APPCONFIG_ENDPOINT en el punto de conexión del almacén de App Configuration que se encuentra en la Información general del almacén en Azure Portal.

    Si usa el símbolo del sistema de Windows, ejecute el siguiente comando y reinícielo para que se aplique el cambio:

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

    Si usa PowerShell, ejecute el siguiente comando:

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

    Si usa macOS o Linux, ejecute el siguiente comando:

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

    Además, asegúrese de haber iniciado sesión con la CLI de Azure o de usar variables de entorno para la autenticación de Azure:

    az login

  2. Una vez establecida correctamente la variable de entorno, ejecute el siguiente comando para ejecutar el ejemplo Unmarshal :

    go run unmarshal_sample.go

    Debería ver un resultado similar al siguiente:

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

  3. Ejecute el ejemplo GetBytes :

    go run getbytes_sample.go

    Debería ver un resultado similar al siguiente:

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

Limpieza de recursos

Si no quiere seguir usando los recursos que se han creado en este artículo, elimine el grupo de recursos que creó aquí para evitar cargos.

Importante

La eliminación de un grupo de recursos es irreversible. El grupo de recursos y todos los recursos que contiene se eliminan permanentemente. Asegúrese de que no elimina por accidente el grupo de recursos o los recursos equivocados. Si creó los recursos para este artículo en un grupo de recursos que contenga los recursos que desee conservar, elimine cada recurso de forma individual desde su panel respectivo, en lugar de eliminar el grupo de recursos.

  1. Inicie sesión en Azure Portal y después seleccione Grupos de recursos.
  2. En el cuadro de texto Filtrar por nombre, escriba el nombre del grupo de recursos.
  3. En la lista resultados, seleccione el nombre del grupo de recursos para ver la información general.
  4. Seleccione Eliminar grupo de recursos.
  5. Se le pedirá que confirme la eliminación del grupo de recursos. Escriba el nombre del grupo de recursos para confirmar y seleccione Eliminar.

Transcurridos unos instantes, el grupo de recursos y todos sus recursos se eliminan.

Pasos siguientes

En este inicio rápido, ha creado un almacén de App Configuration y ha aprendido a acceder a los valores clave mediante el proveedor de Go de Azure App Configuration en una aplicación de consola.

Para más información sobre el proveedor go de Azure App Configuration, consulte la documentación de referencia.