Quickstart: Een Go-web-app maken met Azure App Configuration

2025-06-16

In deze quickstart gebruikt u Azure App Configuration om de opslag en het beheer van toepassingsinstellingen voor een Go-webtoepassing te centraliseren met behulp van het Gin-framework en de Azure App Configuration Go-provider.

De App Configuration-provider voor Go vereenvoudigt het toepassen van sleutelwaarden van Azure App Configuration op Go-toepassing. Hiermee kunnen bindingsinstellingen aan een Go-struct worden verbonden. Het biedt functies zoals configuratiesamenstelling van meerdere labels, het bijsnijden van sleutelvoorvoegsels, automatische resolutie van Key Vault-verwijzingen en nog veel meer.

Vereiste voorwaarden

Een Azure-account met een actief abonnement. Maak gratis een account.
Een App Configuration-winkel. Een winkel maken.
Ga 1.21 of hoger. Installeer Go.

Sleutelwaarden toevoegen

Voeg de volgende sleutelwaarden toe aan het App Configuration-archief en laat label en inhoudstype ongewijzigd met de standaardwaarden. Ga naar Een sleutelwaarde maken voor meer informatie over het toevoegen van sleutelwaarden aan een opslag met de Azure Portal of de CLI.

Sleutelcode	Waarde
Configuratie.Bericht	Hallo van Azure App Configuration
Config.App.Name	Gin-voorbeeld-app
Config.App.Port	8080

Een Go-webtoepassing maken

Maak een nieuwe map voor uw webtoepassing.

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

Initialiseer een nieuwe Go-module.
```
go mod init app-configuration-web
```

Voeg de vereiste afhankelijkheden toe.

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

Maak een map met sjablonen voor uw HTML-sjablonen.
```
mkdir templates
```

Maak een HTML-sjabloon voor de startpagina. Voeg de volgende inhoud toe aan 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>

Verbinding maken met een App Configuration-winkel

Maak een bestand met de naam appconfig.go met de volgende inhoud. U kunt verbinding maken met uw App Configuration-archief met behulp van Microsoft Entra ID (aanbevolen) of een verbindingsreeks.

Microsoft Entra-id (aanbevolen)
Verbindingsstring

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
}

Een webtoepassing maken met Gin

Maak een bestand met de naam main.go met de volgende inhoud:

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

De webtoepassing uitvoeren

Stel de omgevingsvariabele in voor verificatie.
- Microsoft Entra-id (aanbevolen)
- Verbindingsstring
Stel de omgevingsvariabele met de naam AZURE_APPCONFIG_ENDPOINT in op het eindpunt van uw App Configuration-opslag gevonden onder het Overzicht van uw opslag in de Azure-portal.

Als u de Windows-opdrachtprompt gebruikt, voert u de volgende opdracht uit en start u de opdrachtprompt opnieuw om de wijziging door te voeren:
```
setx AZURE_APPCONFIG_ENDPOINT "<endpoint-of-your-app-configuration-store>"
```
Als u PowerShell gebruikt, voert u de volgende opdracht uit:
```
$Env:AZURE_APPCONFIG_ENDPOINT = "<endpoint-of-your-app-configuration-store>"
```
Als u macOS of Linux gebruikt, voert u de volgende opdracht uit:
```
export AZURE_APPCONFIG_ENDPOINT='<endpoint-of-your-app-configuration-store>'
```
Zorg er bovendien voor dat u bent aangemeld met de Azure CLI of omgevingsvariabelen voor Azure-verificatie hebt gebruikt:
```
az login
```
Stel de omgevingsvariabele met de naam AZURE_APPCONFIG_CONNECTION_STRING in op de alleen-lezen verbindingsreeks van uw App Configuration-opslagplaats in de Toegangsinstellingen van uw winkel in de Azure Portal.

Als u de Windows-opdrachtprompt gebruikt, voert u de volgende opdracht uit en start u de opdrachtprompt opnieuw om de wijziging door te voeren:
```
setx AZURE_APPCONFIG_CONNECTION_STRING "<connection-string-of-your-app-configuration-store>"
```
Als u PowerShell gebruikt, voert u de volgende opdracht uit:
```
$Env:AZURE_APPCONFIG_CONNECTION_STRING = "<connection-string-of-your-app-configuration-store>"
```
Als u macOS of Linux gebruikt, voert u de volgende opdracht uit:
```
export AZURE_APPCONFIG_CONNECTION_STRING='<connection-string-of-your-app-configuration-store>'
```

Voer de toepassing uit.

go mod tidy
go run .

De uitvoer ziet er ongeveer als volgt uit:

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

Open een webbrowser en navigeer naar http://localhost:8080. De webpagina ziet er als volgt uit:

De hulpbronnen opschonen

Als u de resources die in dit artikel zijn gemaakt niet wilt blijven gebruiken, verwijdert u de resourcegroep die u hier hebt gemaakt om kosten te voorkomen.

Belangrijk

Het verwijderen van een resourcegroep kan niet ongedaan worden gemaakt. De resourcegroep en alle resources daarin worden permanent verwijderd. Zorg ervoor dat u niet per ongeluk de verkeerde groep of bronnen verwijdert. Als u de resources voor dit artikel in een resourcegroep hebt gemaakt die andere resources bevat die u wilt behouden, moet u elke resource afzonderlijk verwijderen uit het deelvenster in plaats van dat u de resourcegroep verwijdert.

Meld u aan bij de Azure-portal en selecteer Resourcegroepen.
Voer in het vak Filteren op naam de naam van uw resourcegroep in.
Selecteer in de resultatenlijst de resourcegroepnaam om een overzicht te bekijken.
Selecteer Resourcegroep verwijderen.
U wordt gevraagd om het verwijderen van de resourcegroep te bevestigen. Voer de naam van de resourcegroep in die u wilt bevestigen en selecteer Verwijderen.

Na enkele ogenblikken worden de resourcegroep en alle bijbehorende resources verwijderd.

Volgende stappen

In deze quickstart hebt u een Go-webtoepassing gemaakt met Azure App Configuration. U hebt geleerd hoe u het volgende kunt doen:

Configuratie laden vanuit Azure App Configuration in een webtoepassing
Sterk getypte configuratie gebruiken met Unmarshal
Uw webtoepassing configureren op basis van centraal opgeslagen instellingen

Zie het referentiedocument voor meer informatie over De Go-provider van Azure App Configuration.