Snabbstart: Skapa en Go-webbapp med Azure App Configuration

2025-06-16

I den här snabbstarten använder du Azure App Configuration för att centralisera lagring och hantering av programinställningar för ett Go-webbprogram med hjälp av Gin-ramverket och Azure App Configuration Go-providern.

Appkonfigurationsprovidern för Go förenklar arbetet med att tillämpa nyckelvärden från Azure App Configuration till Go-programmet. Det aktiverar bindningsinställningar för Go-struct. Det erbjuder funktioner som konfigurationssammansättning från flera etiketter, trimning av nyckelprefix, automatisk upplösning av Key Vault-referenser och mycket mer.

Förutsättningar

Ett Azure-konto med en aktiv prenumeration. Skapa en kostnadsfritt.
En konfigurationsbutik för appar. Skapa en butik.
Gå 1.21 eller senare. Installera Go.

Lägga till nyckelvärden

Lägg till följande nyckelvärden i App Configuration Store och lämna Etikett och Innehållstyp med sina standardvärden. Mer information om hur du lägger till nyckelvärden i en lagring med hjälp av Azure-portalen eller CLI finns i Skapa ett nyckelvärde.

Nyckel	Värde
Konfig.Meddelande	Hej från Azure App Configuration
Config.App.Name	Gin-exempelapp
Config.App.Port	8080

Skapa ett Go-webbprogram

Skapa en ny katalog för webbappen.

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

Initiera en ny Go-modul.
```
go mod init app-configuration-web
```

Lägg till nödvändiga beroenden.

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

Skapa en mallkatalog för dina HTML-mallar.
```
mkdir templates
```

Skapa en HTML-mall för startsidan. Lägg till följande innehåll i 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>

Anslut till en App Configuration-lagring

Skapa en fil med namnet appconfig.go med följande innehåll. Du kan ansluta till appkonfigurationsarkivet med hjälp av Microsoft Entra-ID (rekommenderas) eller en anslutningssträng.

Microsoft Entra-ID (rekommenderas)
Anslutningssträng

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
}

Skapa ett webbprogram med Gin

Skapa en fil med namnet main.go med följande innehåll:

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

Köra webbprogrammet

Ange miljövariabeln för autentisering.
- Microsoft Entra-ID (rekommenderas)
- Anslutningssträng
Ange miljövariabeln med namnet AZURE_APPCONFIG_ENDPOINT till slutpunkten för din App Configuration-butik som finns i Azure-portalen under Översikt över din butik.

Om du använder Windows-kommandotolken kör du följande kommando och startar om kommandotolken så att ändringen börjar gälla:
```
setx AZURE_APPCONFIG_ENDPOINT "<endpoint-of-your-app-configuration-store>"
```
Om du använder PowerShell kör du följande kommando:
```
$Env:AZURE_APPCONFIG_ENDPOINT = "<endpoint-of-your-app-configuration-store>"
```
Om du använder macOS eller Linux kör du följande kommando:
```
export AZURE_APPCONFIG_ENDPOINT='<endpoint-of-your-app-configuration-store>'
```
Kontrollera dessutom att du har loggat in med Azure CLI eller använder miljövariabler för Azure-autentisering:
```
az login
```
Ange miljövariabeln med namnet AZURE_APPCONFIG_CONNECTION_STRING till den skrivskyddade anslutningssträngen i appkonfigurationsarkivet som finns under Åtkomstinställningar för din butik i Azure-portalen.

Om du använder Windows-kommandotolken kör du följande kommando och startar om kommandotolken så att ändringen börjar gälla:
```
setx AZURE_APPCONFIG_CONNECTION_STRING "<connection-string-of-your-app-configuration-store>"
```
Om du använder PowerShell kör du följande kommando:
```
$Env:AZURE_APPCONFIG_CONNECTION_STRING = "<connection-string-of-your-app-configuration-store>"
```
Om du använder macOS eller Linux kör du följande kommando:
```
export AZURE_APPCONFIG_CONNECTION_STRING='<connection-string-of-your-app-configuration-store>'
```

Kör programmet.

go mod tidy
go run .

Du bör se utdata som liknar följande:

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

Öppna en webbläsare och navigera till http://localhost:8080. Webbsidan ser ut så här:

Rensa resurser

Om du inte vill fortsätta använda resurserna som skapas i den här artikeln tar du bort resursgruppen som du skapade här för att undvika avgifter.

Viktigt!

Att ta bort en resursgrupp kan inte ångras. Resursgruppen och alla resurser i den tas bort permanent. Se till att du inte oavsiktligt tar bort fel resursgrupp eller resurser. Om du har skapat resurserna för den här artikeln i en resursgrupp som innehåller andra resurser som du vill behålla tar du bort varje resurs individuellt från respektive fönster i stället för att ta bort resursgruppen.

Logga in på Azure Portal och välj Resursgrupper.
I rutan Filtrera efter namn anger du namnet på resursgruppen.
I resultatlistan väljer du resursgruppens namn för att se en översikt.
Välj Ta bort resursgrupp.
Du blir ombedd att bekräfta borttagningen av resursgruppen. Ange namnet på resursgruppen för att bekräfta och välj Ta bort.

Efter en liten stund tas resursgruppen och alla dess resurser bort.

Nästa steg

I den här snabbstarten skapade du ett Go-webbprogram med Azure App Configuration. Du har lärt dig att:

Läsa in konfiguration från Azure App Configuration i ett webbprogram
Använd starkt typad konfiguration med Unmarshal
Konfigurera ditt webbprogram baserat på centralt lagrade inställningar

Mer information om Azure App Configuration Go Provider finns i referensdokumentet.

Feedback

Var den här sidan till hjälp?