Udostępnij za pomocą

Szybki start: dodawanie flag funkcji do aplikacji konsolowej języka Go

W tym przewodniku po szybkim starcie utworzysz flagę funkcji w usłudze Azure App Configuration i użyjesz jej do dynamicznego kontrolowania dostępności funkcji w konsolowej aplikacji Go.

Obsługa zarządzania funkcjami rozszerza funkcję konfiguracji dynamicznej w usłudze App Configuration. W tym przykładzie pokazano, jak zintegrować flagi funkcji z aplikacją konsolową języka Go z funkcjami monitorowania w czasie rzeczywistym.

Wymagania wstępne

Tworzenie flagi funkcji

Dodaj flagę funkcji o nazwie Beta do sklepu App Configuration i pozostaw pole Etykieta i Opis z ich wartościami domyślnymi. Aby uzyskać więcej informacji na temat dodawania flag funkcji do magazynu przy użyciu portalu Azure lub interfejsu wiersza polecenia, przejdź do Tworzenie flagi funkcji.

Zrzut ekranu przedstawiający tworzenie flagi funkcji.

Używanie flagi funkcji

  1. Utwórz nowy katalog dla projektu Go i przejdź do niego:

    mkdir go-feature-flag-quickstart
cd go-feature-flag-quickstart

  2. Zainicjuj nowy moduł języka Go:

    go mod init go-feature-flag-quickstart

  3. Zainstaluj wymagane pakiety języka Go na potrzeby usługi Azure App Configuration i zarządzania funkcjami:

    go get github.com/microsoft/Featuremanagement-Go/featuremanagement
go get github.com/microsoft/Featuremanagement-Go/featuremanagement/providers/azappconfig

  4. Utwórz plik o nazwie appconfig.go z następującą zawartością. Możesz nawiązać połączenie z magazynem App Configuration przy użyciu identyfikatora Entra firmy Microsoft (zalecane) lub parametrów połączenia.

    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 feature flag options
    options := &azureappconfiguration.Options{
        FeatureFlagOptions: azureappconfiguration.FeatureFlagOptions{
            Enabled: true,
            RefreshOptions: azureappconfiguration.RefreshOptions{
                Enabled: true,
            },
        },
    }

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

    Wskazówka

    Jeśli nie określono selektora w FeatureFlagOptions, ładuje wszystkie flagi funkcjonalności bez etykiety w magazynie App Configuration. Domyślny interwał odświeżania flag funkcji to 30 sekund. To zachowanie można dostosować za pomocą parametru RefreshOptions . Na przykład poniższy fragment kodu ładuje tylko flagi funkcji rozpoczynające się od aplikacji TestApp: w nazwieklucza i mają etykietę dev. Kod zmienia również czas interwału odświeżania na 5 minut. Należy pamiętać, że ten czas interwału odświeżania jest oddzielony od tego dla zwykłych wartości klucz-wartość.

    azureappconfiguration.FeatureFlagOptions{
    Enabled: true,
    Selectors: []azureappconfiguration.Selector{
        {
            KeyFilter:   "TestApp:*",
            LabelFilter: "dev",
        },
    },
    RefreshOptions: azureappconfiguration.RefreshOptions{
        Enabled: true,
        Interval: 5 * time.Minute,
    },
}

  5. Utwórz główny plik main.goaplikacji :

    package main

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

	"github.com/microsoft/Featuremanagement-Go/featuremanagement"
	"github.com/microsoft/Featuremanagement-Go/featuremanagement/providers/azappconfig"
)

func main() {
    ctx := context.Background()

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

    // Create feature flag provider
    featureFlagProvider, err := azappconfig.NewFeatureFlagProvider(appConfig)
    if err != nil {
        log.Fatalf("Error creating feature flag provider: %v", err)
    }

    // Create feature manager
    featureManager, err := featuremanagement.NewFeatureManager(featureFlagProvider, nil)
    if err != nil {
        log.Fatalf("Error creating feature manager: %v", err)
    }

    // Monitor the Beta feature flag
    fmt.Println("Monitoring 'Beta' feature flag (press Ctrl+C to exit):")
    fmt.Println("Toggle the Beta feature flag in Azure portal to see real-time updates...")
    fmt.Println()

    ticker := time.NewTicker(5 * time.Second)
    defer ticker.Stop()

    for {
        select {
        case <-ticker.C:
            // Refresh configuration to get latest feature flag settings
            if err := appConfig.Refresh(ctx); err != nil {
                log.Printf("Error refreshing configuration: %v", err)
                continue
            }

            // Evaluate the Beta feature flag
            isEnabled, err := featureManager.IsEnabled("Beta")
            if err != nil {
                log.Printf("Error checking if Beta feature is enabled: %v", err)
                continue
            }

            // Print timestamp and feature status
            timestamp := time.Now().Format("15:04:05")
            fmt.Printf("[%s] Beta is enabled: %t\n", timestamp, isEnabled)

        case <-ctx.Done():
            fmt.Println("\nShutting down...")
            return
        }
    }
}

Uruchamianie aplikacji

  1. Uruchom aplikację:

    go mod tidy
go run .

  2. Aplikacja uruchamia monitorowanie flagi funkcji beta i wyświetla swój bieżący stan co 5 sekund:

    Monitoring 'Beta' feature flag (press Ctrl+C to exit):
Toggle the Beta feature flag in Azure portal to see real-time updates...

[14:30:15] Beta is enabled: false
[14:30:20] Beta is enabled: false
[14:30:25] Beta is enabled: false

  3. Zaloguj się do witryny Azure Portal. Wybierz pozycję Wszystkie zasoby i wybierz utworzony wcześniej magazyn App Configuration.

  4. Wybierz pozycję Menedżer funkcji i znajdź flagę funkcji beta . Włącz flagę, zaznaczając pole wyboru w obszarze Włączone.

  5. Wróć do aplikacji konsolowej. Po kilku sekundach powinna zostać wyświetlona zmiana stanu flagi funkcji:

    [14:30:30] Beta is enabled: false
[14:30:35] Beta is enabled: true
[14:30:40] Beta is enabled: true

  6. Możesz włączyć i wyłączyć flagę funkcji w witrynie Azure Portal, aby wyświetlić aktualizacje w czasie rzeczywistym w aplikacji konsolowej bez ponownego uruchamiania.

  7. Naciśnij Ctrl+C , aby zatrzymać aplikację.

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 Szybki start utworzono flagę funkcji w usłudze Azure App Configuration i użyto jej w aplikacji konsolowej języka Go. Biblioteka zarządzania funkcjami w języku Go udostępnia zaawansowane funkcje flagi funkcji, które bezproblemowo integrują się z Azure App Configuration. Aby uzyskać więcej funkcji, przejdź do następującego dokumentu.

Dokumentacja zarządzania funkcjami języka Go

Flaga funkcji umożliwia aktywowanie lub dezaktywowanie funkcji w aplikacji, ale możesz dostosować flagę funkcji na podstawie logiki aplikacji. Filtry funkcji umożliwiają warunkowe włączenie flagi funkcji. Aby uzyskać więcej informacji, przejdź do następującego samouczka.

Włączanie funkcji warunkowych z filtrami funkcji

aplikacja systemu Azure Configuration oferuje wbudowane filtry funkcji, które umożliwiają aktywowanie flagi funkcji tylko w określonym okresie lub dla określonej docelowej grupy odbiorców aplikacji. Aby uzyskać więcej informacji, przejdź do następującego samouczka.

Włączanie funkcji zgodnie z harmonogramem

Wdrażanie funkcji dla docelowych odbiorców

  • Last updated on