Avvio rapido: Creare un'app Web Go con la Configurazione app di Azure

In questa guida introduttiva si usa Configurazione app di Azure per centralizzare l'archiviazione e la gestione delle impostazioni dell'applicazione per un'applicazione Web Go usando il framework Gin e il provider Go di Configurazione app di Azure.

Il provider di configurazione delle app per Go semplifica l'applicazione delle coppie chiave-valore dalla configurazione delle app di Azure all'applicazione Go. Abilita le impostazioni di associazione allo struct Go. Offre funzionalità come la composizione della configurazione da più etichette, la rimozione dei prefissi di chiave, la risoluzione automatica dei riferimenti a Key Vault e molte altre ancora.

Prerequisiti

Un account Azure con una sottoscrizione attiva. Creane uno gratis.
Un servizio di configurazione delle app. Creare un negozio.
Passare alla versione 1.21 o successiva. Installare Go.

Aggiungere coppie chiave-valore

Aggiungere il valore chiave seguente all'archivio di Configurazione app e lasciare Etichetta e Tipo di contenuto con i valori predefiniti. Per altre informazioni su come aggiungere valori chiave a un archivio usando il portale di Azure o l’interfaccia della riga di comando, andare a Creare un valore chiave.

Chiave	Valore
Config.Message	Saluti da Azure App Configuration
Config.App.Name	App di esempio Gin
Config.App.Port	8080

Creare un'applicazione Web Go

Creare una nuova directory per l'applicazione Web.

mkdir app-configuration-web
cd app-configuration-web

Inizializzare un nuovo modulo Go.
```
go mod init app-configuration-web
```

Aggiungere le dipendenze necessarie.

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

Creare una directory di modelli per i modelli HTML.
```
mkdir templates
```

Creare un modello HTML per la home page. Aggiungere il contenuto seguente a templates/index.html:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{{.Title}}</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            margin: 0;
            padding: 0;
            background-color: #f5f5f5;
        }
        .container {
            margin: 50px auto;
            max-width: 800px;
            text-align: center;
            background-color: white;
            padding: 30px;
            border-radius: 8px;
            box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
        }
        h1 {
            color: #333;
        }
        p {
            color: #666;
            font-size: 18px;
        }
    </style>
</head>
<body>
    <div class="container">
        <h1>{{.Message}}</h1>
        <p>{{.App}}</p>
    </div>
</body>
</html>

Connettersi a un archivio di Configurazione app

Creare un file denominato appconfig.go con il contenuto seguente. È possibile connettersi all'archivio di Configurazione app usando Microsoft Entra ID (scelta consigliata) o una stringa di connessione.

Microsoft Entra ID (scelta consigliata)
Stringa di connessione

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
}

package main

import (
	"context"
	"log"
	"os"

	"github.com/Azure/AppConfiguration-GoProvider/azureappconfiguration"
)

func loadAzureAppConfiguration(ctx context.Context) (*azureappconfiguration.AzureAppConfiguration, error) {
	// Get the connection string from environment variable
	connectionString := os.Getenv("AZURE_APPCONFIG_CONNECTION_STRING")
	if connectionString == "" {
		log.Fatal("AZURE_APPCONFIG_CONNECTION_STRING environment variable is not set")
	}

	// Set up authentication options with connection string
	authOptions := azureappconfiguration.AuthenticationOptions{
		ConnectionString: connectionString,
	}

	// Configure which keys to load and trimming options
	options := &azureappconfiguration.Options{
		Selectors: []azureappconfiguration.Selector{
			{
				KeyFilter:   "Config.*",
			},
		},
		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
}

Creare un'applicazione Web con Gin

Creare un file denominato main.go con il contenuto seguente:

package main

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

	"github.com/gin-gonic/gin"
)

type Config struct {
	App     App
	Message string
}

type App struct {
	Name      string
	Port      int
}

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

	// Load configuration from Azure App Configuration
	provider, err := loadAzureAppConfiguration(ctx)
	if err != nil {
		log.Fatalf("Error loading configuration: %v", err)
	}

	// Unmarshal the configuration into the application-specific struct
	var config Config
	if err := provider.Unmarshal(&config, nil); err != nil {
		log.Fatalf("Failed to unmarshal configuration: %v", err)
	}

	// Initialize Gin router
	r := gin.Default()

	// Load HTML templates
	r.LoadHTMLGlob("templates/*")

	// Define a route for the homepage
	r.GET("/", func(c *gin.Context) {
		c.HTML(200, "index.html", gin.H{
			"Title":   "Home",
			"Message": config.Message,
			"App":     config.App.Name,
		})
	})

	// Use the port from configuration
	portStr:= fmt.Sprintf(":%d", config.App.Port)
	
	// Start the server on configured port
	log.Printf("Starting %s on http://localhost%s", config.App.Name, portStr)
	if err := r.Run(portStr); err != nil {
		log.Fatalf("Error starting server: %v", err)
	}
}

Eseguire l'applicazione Web

Impostare la variabile di ambiente per l'autenticazione.
- Microsoft Entra ID (scelta consigliata)
- Stringa di connessione
Impostare la variabile di ambiente denominata AZURE_APPCONFIG_ENDPOINT sull'endpoint dell'archivio di Configurazione app disponibile in Panoramica dello store nel portale di Azure.

Se si usa il prompt dei comandi di Windows, eseguire il comando seguente e riavviare il prompt per rendere effettiva la modifica:
```
setx AZURE_APPCONFIG_ENDPOINT "<endpoint-of-your-app-configuration-store>"
```
Se si usa PowerShell, eseguire il comando seguente:
```
$Env:AZURE_APPCONFIG_ENDPOINT = "<endpoint-of-your-app-configuration-store>"
```
Se si usa macOS o Linux, eseguire il comando seguente:
```
export AZURE_APPCONFIG_ENDPOINT='<endpoint-of-your-app-configuration-store>'
```
Assicurarsi inoltre di aver eseguito l'accesso con l'interfaccia della riga di comando di Azure o di usare le variabili di ambiente per l'autenticazione di Azure:
```
az login
```
Impostare la variabile di ambiente denominata AZURE_APPCONFIG_CONNECTION_STRING sulla stringa di connessione di sola lettura dell'archivio di Configurazione app disponibile in Impostazioni di accesso dell'archivio nel portale di Azure.

Se si usa il prompt dei comandi di Windows, eseguire il comando seguente e riavviare il prompt per rendere effettiva la modifica:
```
setx AZURE_APPCONFIG_CONNECTION_STRING "<connection-string-of-your-app-configuration-store>"
```
Se si usa PowerShell, eseguire il comando seguente:
```
$Env:AZURE_APPCONFIG_CONNECTION_STRING = "<connection-string-of-your-app-configuration-store>"
```
Se si usa macOS o Linux, eseguire il comando seguente:
```
export AZURE_APPCONFIG_CONNECTION_STRING='<connection-string-of-your-app-configuration-store>'
```

Eseguire l'applicazione.

go mod tidy
go run .

Verrà visualizzato un output simile al seguente:

Running in DEBUG mode
Starting Gin Web App on http://localhost:8080
[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.
[GIN-debug] [WARNING] Running in "debug" mode. Switch to "release" mode in production.
- using env:	export GIN_MODE=release
- using code:	gin.SetMode(gin.ReleaseMode)
[GIN-debug] Loading templates from ./templates/*
[GIN-debug] GET    /                         --> main.main.func1 (3 handlers)
[GIN-debug] [WARNING] You trusted all proxies, this is NOT safe. We recommend you to set a value.
Please check https://pkg.go.dev/github.com/gin-gonic/gin#readme-don-t-trust-all-proxies for details.
[GIN-debug] Listening and serving HTTP on :8080

Aprire un Web browser e passare a http://localhost:8080. La pagina Web avrà un aspetto simile al seguente:

Pulire le risorse

Se non si vuole continuare a usare le risorse create in questo articolo, eliminare il gruppo di risorse creato qui per evitare addebiti.

Importante

L'eliminazione di un gruppo di risorse è irreversibile. Il gruppo di risorse e tutte le risorse in esso contenute vengono eliminati in modo permanente. Assicurarsi di non eliminare accidentalmente il gruppo di risorse o le risorse sbagliate. Se le risorse per questo articolo sono state create in un gruppo di risorse che contiene altre risorse che si vogliono mantenere, eliminare ogni risorsa singolarmente dal rispettivo riquadro anziché eliminare il gruppo di risorse.

Accedere al portale di Azure e selezionare Gruppi di risorse.
Nella casella Filtra per nome immettere il nome del gruppo di risorse.
Nell'elenco dei risultati selezionare il nome del gruppo di risorse per visualizzare una panoramica.
Selezionare Elimina gruppo di risorse.
Verrà chiesto di confermare l'eliminazione del gruppo di risorse. Immettere il nome del gruppo di risorse per confermare e selezionare Elimina.

Dopo qualche istante, il gruppo di risorse e tutte le risorse che contiene vengono eliminati.

Passaggi successivi

In questo avvio rapido, hai creato un'applicazione web Go con Azure App Configuration. Ecco cosa hai imparato a fare:

Caricare la configurazione da Configurazione app di Azure in un'applicazione Web
Usare una configurazione fortemente tipizzata con Unmarshal
Configurare l'applicazione Web in base alle impostazioni archiviate centralmente

Per altre informazioni sul provider Go di Configurazione app di Azure, vedere la documentazione di riferimento.

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2025-06-16