Rychlý start: Vytvoření webové aplikace Go pomocí Azure App Configuration

V tomto rychlém startu použijete Azure App Configuration k centralizaci úložiště a správy nastavení aplikací pro webovou aplikaci Go pomocí architektury Gin a poskytovatele Azure App Configuration Go.

Zprostředkovatel konfigurace aplikace pro Go zjednodušuje použití hodnot klíčů z aplikace Azure App Configuration na Go. Umožňuje vázání nastavení na strukturu Go. Nabízí funkce, jako je složení konfigurace z více štítků, oříznutí předpony klíčů, automatické rozlišení odkazů na Key Vault a mnoho dalších funkcí.

Požadavky

Účet Azure s aktivním předplatným. Vytvořte si ho zdarma.
Úložiště konfigurace aplikací. Vytvořte úložiště.
Přejděte na verzi 1.21 nebo novější. Nainstalujte Go.

Přidejte klíčové hodnoty

Přidejte do obchodu App Configuration následující klíčové hodnoty a ponechte Label a Content Type s jejich výchozími hodnotami. Další informace o tom, jak přidat hodnoty klíčů do úložiště pomocí webu Azure Portal nebo rozhraní příkazového řádku, najdete v tématu Vytvoření hodnoty klíče.

Klíč	Hodnota
Konfig.Zpráva	Ahoj z Azure App Configuration
Config.App.Name	Ukázková aplikace Gin
Config.App.Port	8080

Vytvoření webové aplikace Go

Vytvořte nový adresář pro webovou aplikaci.

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

Inicializace nového modulu Go
```
go mod init app-configuration-web
```

Přidejte požadované závislosti.

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

Vytvořte adresář šablon pro šablony HTML.
```
mkdir templates
```

Vytvořte šablonu HTML pro domovskou stránku. Přidejte následující obsah do 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>

Připojení ke službě App Configuration Store

Vytvořte soubor s názvem appconfig.go s následujícím obsahem. Ke službě App Configuration Store se můžete připojit pomocí Microsoft Entra ID (doporučeno) nebo připojovací řetězec.

Microsoft Entra ID (doporučeno)
Připojovací řetězec

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
}

Vytvoření webové aplikace pomocí Ginu

Vytvořte soubor s názvem main.go s následujícím obsahem:

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

Spuštění webové aplikace

Nastavte systémovou proměnnou prostředí pro ověřování.
- Microsoft Entra ID (doporučeno)
- Připojovací řetězec
Nastavte proměnnou prostředí s názvem AZURE_APPCONFIG_ENDPOINT na koncový bod obchodu App Configuration, který najdete v části Přehled obchodu na webu Azure Portal.

Pokud používáte příkazový řádek systému Windows, spusťte následující příkaz a restartujte příkazový řádek, aby se změna projevila:
```
setx AZURE_APPCONFIG_ENDPOINT "<endpoint-of-your-app-configuration-store>"
```
Pokud používáte PowerShell, spusťte následující příkaz:
```
$Env:AZURE_APPCONFIG_ENDPOINT = "<endpoint-of-your-app-configuration-store>"
```
Pokud používáte macOS nebo Linux, spusťte následující příkaz:
```
export AZURE_APPCONFIG_ENDPOINT='<endpoint-of-your-app-configuration-store>'
```
Dále se ujistěte, že jste přihlášeni pomocí Azure CLI, nebo použijte proměnné prostředí pro ověření Azure.
```
az login
```
Nastavte proměnnou prostředí s názvem AZURE_APPCONFIG_CONNECTION_STRING na připojovací řetězec pro čtení z vašeho úložiště App Configuration, který se nachází pod Nastavení přístupu v Azure portálu.

Pokud používáte příkazový řádek systému Windows, spusťte následující příkaz a restartujte příkazový řádek, aby se změna projevila:
```
setx AZURE_APPCONFIG_CONNECTION_STRING "<connection-string-of-your-app-configuration-store>"
```
Pokud používáte PowerShell, spusťte následující příkaz:
```
$Env:AZURE_APPCONFIG_CONNECTION_STRING = "<connection-string-of-your-app-configuration-store>"
```
Pokud používáte macOS nebo Linux, spusťte následující příkaz:
```
export AZURE_APPCONFIG_CONNECTION_STRING='<connection-string-of-your-app-configuration-store>'
```

Aplikaci spusťte.

go mod tidy
go run .

Zobrazený výstup by měl vypadat nějak takto:

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

Otevřete webový prohlížeč a přejděte na http://localhost:8080. Webová stránka vypadá takto:

Vyčistěte zdroje

Pokud nechcete dál používat prostředky vytvořené v tomto článku, odstraňte skupinu prostředků, kterou jste tady vytvořili, abyste se vyhnuli poplatkům.

Důležité

Odstranění skupiny prostředků je nevratné. Skupina prostředků a všechny prostředky v ní se trvale odstraní. Dávejte pozor, abyste omylem neodstranili nesprávnou skupinu prostředků nebo jednotlivé prostředky. Pokud jste vytvořili prostředky pro tento článek ve skupině prostředků, která obsahuje další prostředky, které chcete zachovat, odstraňte jednotlivé prostředky z příslušného podokna místo odstranění skupiny prostředků.

Přihlaste se k webu Azure Portal a vyberte skupiny prostředků.
Do pole Filtrovat podle názvu zadejte název vaší skupiny prostředků.
V seznamu výsledků vyberte název skupiny prostředků, abyste zobrazili přehled.
Vyberte odstranit skupinu zdrojů.
Zobrazí se výzva k potvrzení odstranění skupiny prostředků. Potvrďte název skupiny prostředků a vyberte Odstranit.

Po několika okamžicích se skupina prostředků a všechny její prostředky vymažou.

Další kroky

V tomto rychlém startu jste vytvořili webovou aplikaci Go pomocí azure App Configuration. Naučili jste se:

Načtení konfigurace z Azure App Configuration ve webové aplikaci
Použijte silně typovanou konfiguraci s Unmarshal
Konfigurace webové aplikace na základě centrálně uložených nastavení

Další informace o poskytovateli Azure App Configuration Go najdete v referenční dokumentaci.

Váš názor

Byla tato stránka užitečná?

Last updated on 2025-06-16