Guia de início rápido: adicionar sinalizadores de recursos a um aplicativo Web Go Gin

Neste início rápido, você criará um sinalizador de recurso na Configuração do Aplicativo do Azure e o usará para controlar dinamicamente a disponibilidade de uma nova página da Web em um aplicativo Web Go Gin sem reinicializá-lo ou reimplantá-lo.

O suporte ao gerenciamento de recursos estende o recurso de configuração dinâmica na Configuração do aplicativo. Este exemplo demonstra como integrar sinalizadores de recursos em um aplicativo Web Go Gin com atualizações em tempo real e renderização condicional de página.

Pré-requisitos

Uma conta do Azure com uma assinatura ativa. Crie um gratuitamente.
Uma loja de configuração de aplicativos. Crie uma loja.
Go versão 1.21 ou posterior. Para obter informações sobre como instalar o Go, consulte a página de downloads Go.
Provedor do Azure App Configuration Go v1.1.0 ou posterior.

Criar um marcador de funcionalidade

Adicione um sinalizador de recurso chamado Beta à loja de Configuração do Aplicativo e deixe Rótulo e Descrição com seus valores padrão. Para obter mais informações sobre como adicionar sinalizadores de recursos a uma loja usando o portal do Azure ou a CLI, vá para Criar um sinalizador de recurso.

Criar uma aplicação Web Go

Crie um novo diretório para seu projeto Go e navegue até ele:

mkdir gin-feature-flag-quickstart
cd gin-feature-flag-quickstart

Inicialize um novo módulo Go:

go mod init gin-feature-flag-quickstart

Instale os pacotes Go necessários para a Configuração de Aplicativos do Azure, a estrutura da Web do Gin e o gerenciamento de recursos:

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

Crie um diretório de modelos para seus modelos HTML e adicione os arquivos HTML necessários:
```
mkdir templates
```
Adicione os seguintes arquivos de modelo HTML do repositório GitHub e coloque-os templates no diretório:
- index.html - O modelo de página inicial
- beta.html - O modelo de página beta

Usar um sinalizador de recurso

Crie um arquivo nomeado appconfig.go com o seguinte conteúdo. Você pode se conectar à sua loja de configuração de aplicativos usando a ID do Microsoft Entra (recomendado) ou uma cadeia de conexão.

Microsoft Entra ID (recomendado)
Cadeia de conexão

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
}

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

Sugestão

Quando nenhum seletor é especificado no FeatureFlagOptions, ele carrega todos os sinalizadores de recursos sem rótulo na sua loja de Configuração de Aplicativos. O intervalo de atualização padrão dos sinalizadores de recursos é de 30 segundos. Você pode personalizar esse comportamento por meio do RefreshOptions parâmetro. Por exemplo, o trecho de código a seguir carrega apenas sinalizadores de recursos que começam com TestApp: em seu nome de chave e tem o rótulo dev. O código também altera o tempo do intervalo de atualização para 5 minutos. Observe que esse tempo de intervalo de atualização é separado daquele para valores de chave regulares.

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

Crie um arquivo nomeado main.go com o seguinte conteúdo:

package main

import (
    "context"
    "fmt"
    "log"
    "net/http"
    "os"

    "github.com/Azure/AppConfiguration-GoProvider/azureappconfiguration"
    "github.com/gin-gonic/gin"
    "github.com/microsoft/Featuremanagement-Go/featuremanagement"
    "github.com/microsoft/Featuremanagement-Go/featuremanagement/providers/azappconfig"
)

type WebApp struct {
    featureManager *featuremanagement.FeatureManager
    appConfig      *azureappconfiguration.AzureAppConfiguration
}

func (app *WebApp) refreshMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        go func() {
            ctx := context.Background()
            if err := app.appConfig.Refresh(ctx); err != nil {
                log.Printf("Error refreshing configuration: %v", err)
            }
        }()
        c.Next()
    }
}

func (app *WebApp) featureMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        // Check if Beta feature is enabled
        betaEnabled, err := app.featureManager.IsEnabled("Beta")
        if err != nil {
            log.Printf("Error checking Beta feature: %v", err)
            betaEnabled = false
        }

        // Store feature flag status for use in templates
        c.Set("betaEnabled", betaEnabled)
        c.Next()
    }
}

func (app *WebApp) setupRoutes(r *gin.Engine) {
    r.Use(app.refreshMiddleware())
    r.Use(app.featureMiddleware())

    // Load HTML templates
    r.LoadHTMLGlob("templates/*.html")

    // Routes
    r.GET("/", app.homeHandler)
    r.GET("/beta", app.betaHandler)
}

// Home page handler
func (app *WebApp) homeHandler(c *gin.Context) {
    betaEnabled := c.GetBool("betaEnabled")

    c.HTML(http.StatusOK, "index.html", gin.H{
        "title":       "Feature Management Example App",
        "betaEnabled": betaEnabled,
    })
}

// Beta page handler
func (app *WebApp) betaHandler(c *gin.Context) {
    betaEnabled := c.GetBool("betaEnabled")

    if !betaEnabled {
        return
    }

    c.HTML(http.StatusOK, "beta.html", gin.H{
        "title": "Beta Page",
    })
}

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

    // Create web app
    app := &WebApp{
        featureManager: featureManager,
        appConfig:      appConfig,
    }

    // Set up Gin with default middleware (Logger and Recovery)
    r := gin.Default()

    // Set up routes
    app.setupRoutes(r)

    // Start server
    fmt.Println("Starting server on http://localhost:8080")
    fmt.Println("Open http://localhost:8080 in your browser")
    fmt.Println("Toggle the 'Beta' feature flag in Azure portal to see changes")
    fmt.Println()

    if err := r.Run(":8080"); err != nil {
        log.Fatalf("Failed to start server: %v", err)
    }
}

Execute a aplicação Web

Defina a variável de ambiente para autenticação e execute o aplicativo.
```
go mod tidy
go run .
```
Abra uma janela do navegador e vá para http://localhost:8080. Seu navegador deve exibir uma página semelhante à imagem abaixo.
Inicie sessão no portal Azure. Selecione Todos os recursos e selecione a App Configuration store que criou anteriormente.
Selecione Gerenciador de recursos e localize o sinalizador de recursos Beta . Habilite o sinalizador marcando a caixa de seleção em Habilitado.
Atualize o navegador algumas vezes. Quando a janela de tempo do intervalo de atualização passa, a página é exibida com conteúdo atualizado:
Observe que o item de menu Beta agora aparece na barra de navegação. Clique nele para acessar a página beta:

Limpeza de recursos

Se não quiser continuar a utilizar os recursos criados neste artigo, elimine o grupo de recursos que criou aqui para evitar cobranças.

Importante

A eliminação de um grupo de recursos é irreversível. O grupo de recursos e todos os recursos nele contidos são excluídos permanentemente. Certifique-se de não excluir acidentalmente o grupo de recursos ou recursos errados. Se você criou os recursos para este artigo dentro de um grupo de recursos que contém outros recursos que deseja manter, exclua cada recurso individualmente de seu respetivo painel em vez de excluir o grupo de recursos.

Entre no portal do Azure e selecione Grupos de recursos.
Na caixa Filtrar por nome, introduza o nome do seu grupo de recursos.
Na lista de resultados, selecione o nome do grupo de recursos para ver uma visão geral.
Selecione Eliminar grupo de recursos.
É-lhe pedido que confirme a eliminação do grupo de recursos. Insira o nome do grupo de recursos a ser confirmado e selecione Excluir.

Após alguns momentos, o grupo de recursos e todos os seus recursos são excluídos.

Próximos passos

Neste início rápido, você criou um sinalizador de recurso na Configuração do Aplicativo do Azure e o usou em um aplicativo Web Go Gin. A biblioteca de Gestão de Funcionalidades Go fornece capacidades de sinalização de funcionalidades que se integram perfeitamente à Configuração do Aplicativo do Azure. Para obter mais recursos, continue para o documento a seguir.

Referência do Go Feature Management

Embora um sinalizador de recurso permita que você ative ou desative a funcionalidade em seu aplicativo, convém personalizar um sinalizador de recurso com base na lógica do seu aplicativo. Os filtros de recursos permitem que você habilite um sinalizador de recurso condicionalmente. Para obter mais informações, continue para o tutorial a seguir.

Habilitar recursos condicionais com filtros de recursos

A Configuração de Aplicativo do Azure oferece filtros de recursos internos que permitem ativar um sinalizador de recurso somente durante um período específico ou para um público-alvo específico do seu aplicativo. Para obter mais informações, continue para o tutorial a seguir.

Ativar funcionalidades num agendamento

Lançar funcionalidades para públicos-alvo

Feedback

Esta página foi útil?

Last updated on 2025-08-26