Udostępnij za pośrednictwem

Szybki start: tworzenie aplikacji internetowej w języku Go za pomocą usługi Azure App Configuration

W tym szybkim starcie użyjesz Azure App Configuration, aby scentralizować magazyn i zarządzanie ustawieniami aplikacji webowej Go przy użyciu platformy Gin i dostawcy Azure App Configuration Go.

Dostawca usługi App Configuration dla języka Go upraszcza proces stosowania klucz-wartości z usługi Azure App Configuration do aplikacji Go. Umożliwia powiązanie ustawień ze strukturą w języku Go. Oferuje funkcje, takie jak tworzenie konfiguracji z wielu etykiet, przycinanie prefiksów kluczy, automatyczne rozwiązywanie odwołań do Key Vault i wiele innych.

Wymagania wstępne

Dodawanie kluczy i wartości

Dodaj następujące wartości klucza do magazynu App Configuration i pozostaw Etykieta oraz Typ zawartości z ich wartościami domyślnymi. Aby uzyskać więcej informacji na temat dodawania par klucz-wartość do magazynu przy użyciu portalu Azure lub interfejsu wiersza polecenia, przejdź do Utwórz parę klucz-wartość.

Klawisz Wartość
Konfiguracja.Wiadomość Witaj z usługi Azure App Configuration
Config.App.Name Przykładowa aplikacja gin
Config.App.Port 8080

Tworzenie aplikacji internetowej w języku Go

  1. Utwórz nowy katalog dla aplikacji internetowej.

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

  2. Zainicjuj nowy moduł Go.

    go mod init app-configuration-web

  3. Dodaj wymagane zależności.

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

  4. Utwórz katalog szablonów dla szablonów HTML.

    mkdir templates

  5. Utwórz szablon HTML dla strony głównej. Dodaj następującą zawartość do pliku 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>

Nawiązanie połączenia ze sklepem App Configuration

Utwórz plik o nazwie appconfig.go z następującą zawartością. Możesz połączyć się ze swoim magazynem App Configuration przy użyciu identyfikatora Entra firmy Microsoft (zalecane) lub parametry połączenia.

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
}

Tworzenie aplikacji internetowej za pomocą ginu

Utwórz plik o nazwie main.go o następującej zawartości:

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

Uruchamianie aplikacji internetowej

  1. Ustaw zmienną środowiskową na potrzeby uwierzytelniania.

    Ustaw zmienną środowiskową o nazwie AZURE_APPCONFIG_ENDPOINT na punkt końcowy Twojego sklepu App Configuration, który znajdziesz w sekcji Przegląd w portalu Azure.

    Jeśli używasz wiersza polecenia systemu Windows, uruchom następujące polecenie i uruchom ponownie wiersz polecenia, aby zezwolić na wprowadzenie zmian:

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

    Jeśli używasz programu PowerShell, uruchom następujące polecenie:

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

    Jeśli używasz systemu macOS lub Linux, uruchom następujące polecenie:

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

    Ponadto upewnij się, że zalogowano się przy użyciu interfejsu wiersza polecenia platformy Azure lub użyj zmiennych środowiskowych na potrzeby uwierzytelniania platformy Azure:

    az login

  2. Uruchom aplikację.

    go run main.go

    Powinny zostać wyświetlone dane wyjściowe podobne do następujących:

    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

  3. Otwórz przeglądarkę internetową i przejdź pod adres http://localhost:8080. Strona internetowa wygląda następująco:

    Zrzut ekranu przedstawiający przeglądarkę. Uruchamianie aplikacji Szybki start lokalnie.

Uprzątnij zasoby

Jeśli nie chcesz nadal korzystać z zasobów utworzonych w tym artykule, usuń utworzoną tutaj grupę zasobów, aby uniknąć naliczania opłat.

Ważne

Usunięcie grupy zasobów jest nieodwracalne. Grupa zasobów i wszystkie zasoby w niej są trwale usuwane. Upewnij się, że nie usuniesz przypadkowo niewłaściwej grupy zasobów lub zasobów. Jeśli zasoby dla tego artykułu zostały utworzone w grupie zasobów zawierającej inne zasoby, które chcesz zachować, usuń każdy zasób oddzielnie z odpowiedniego okienka zamiast usuwać grupę zasobów.

  1. Zaloguj się do witryny Azure Portal i wybierz pozycję Grupy zasobów.
  2. W polu Filtruj według nazwy wprowadź nazwę grupy zasobów.
  3. Na liście wyników wybierz nazwę grupy zasobów, aby wyświetlić przegląd.
  4. Wybierz pozycję Usuń grupę zasobów.
  5. Poproszono Cię o potwierdzenie usunięcia grupy zasobów. Wprowadź nazwę grupy zasobów, aby potwierdzić, a następnie wybierz pozycję Usuń.

Po kilku chwilach grupa zasobów i wszystkie jej zasoby zostaną usunięte.

Dalsze kroki

W tym przewodniku szybkiego startu utworzono aplikację internetową napisaną w języku Go za pomocą usługi Azure App Configuration. Nauczyłeś się, jak:

  • Ładowanie konfiguracji z usługi Azure App Configuration w aplikacji internetowej
  • Używanie silnie typizowanej konfiguracji z funkcją Unmarshal
  • Konfigurowanie aplikacji internetowej na podstawie centralnie przechowywanych ustawień

Aby dowiedzieć się więcej na temat dostawcy języka Go usługi Azure App Configuration, zobacz dokumentację referencyjną.