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 de Aplicativos do Azure e o usará para controlar dinamicamente a disponibilidade de uma nova página da Web em um aplicativo Web Go Gin sem reiniciá-lo ou reimplantá-lo.

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

Pré-requisitos

Uma conta do Azure com uma assinatura ativa. Crie um gratuitamente.
Um repositório de Configuração de Aplicativos. Criar um repositório.
Acesse 1.21 ou posterior. Para obter informações sobre como instalar o Go, consulte a página de downloads do Go.
Provedor Go de Configuração de Aplicativo do Azure v1.1.0 ou posterior.

Criar um sinalizador de recurso

Adicione um sinalizador de recurso chamado Beta ao repositório de Configuração de Aplicativos e deixe Rótulo e Descrição com seus valores padrão. Para obter mais informações sobre como adicionar sinalizadores de recursos a um repositório usando o portal do Azure ou a CLI, acesse Criar um sinalizador de recurso.

Criar um aplicativo 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

Inicializar 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 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 no templates diretório:
- index.html - O template da página inicial
- beta.html - O modelo de página beta

Usar um sinalizador de recurso

Crie um arquivo nomeado appconfig.go com o conteúdo a seguir. Você pode se conectar ao seu armazenamento de configuração de aplicativo usando o Microsoft Entra ID (recomendado) ou uma cadeia de conexão.

ID do Microsoft Entra (recomendado)
string 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
}

Dica

Quando nenhum seletor é especificado em FeatureFlagOptions, ele carrega todos os sinalizadores de recursos sem rótulo no seu repositório de configuração de aplicativos. O intervalo de atualização padrão dos sinalizadores de recursos é de 30 segundos. Você pode personalizar esse comportamento com o parâmetro RefreshOptions. Por exemplo, o snippet de código a seguir carrega apenas sinalizadores de recursos que começam com TestApp: em seu nome de chave e têm o rótulo dev. O código também altera o intervalo de atualização para 5 minutos. Observe que esse intervalo de atualização é separado daquele dos valores-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)
    }
}

Executar o aplicativo 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. O navegador deverá exibir uma página semelhante à imagem abaixo.
Entre no portal do Azure. Selecione Todos os recursos e selecione o repositório de Configuração de Aplicativos que você criou anteriormente.
Selecione o Gerenciador de Recursos e localize o sinalizador de recurso Beta . Habilite o sinalizador selecionando 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 o 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:

Limpar os recursos

Se não deseja continuar usando os recursos criados neste artigo, exclua o grupo de recursos que você criou aqui para evitar encargos.

Importante

A exclusão de um grupo de recursos é irreversível. O grupo de recursos e todos os recursos contidos nele são excluídos permanentemente. Certifique-se de não excluir o grupo de recursos ou os recursos incorretos acidentalmente. Se tiver criado os recursos para este artigo dentro de um grupo de recursos que contém outros recursos que você deseja manter, exclua cada um individualmente do respectivo painel em vez de excluir o grupo de recursos.

Entre no portal do Azure e selecione Grupos de recursos.
Na caixa Filtrar por nome..., digite o nome do seu grupo de recursos.
Na lista de resultados, selecione o nome do grupo de recursos para conferir uma visão geral.
Selecione Excluir grupo de recursos.
Você receberá uma solicitação para confirmar a exclusão do grupo de recursos. Insira o nome do grupo de recursos para confirmar e selecione Excluir.

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

Próximas etapas

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

Referência de Gerenciamento dos Recursos Go

Embora um sinalizador de recurso permita ativar ou desativar a funcionalidade em seu aplicativo, convém personalizar um sinalizador de recurso com base na lógica do aplicativo. Os filtros de recursos permitem habilitar um sinalizador de recurso condicionalmente. Para saber mais, continue no tutorial a seguir.

Habilitar recursos condicionais com filtros de recursos

A Configuração de Aplicativos 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 saber mais, continue no tutorial a seguir.

Habilitar os recursos em um agendamento

Distribuir os recursos para os públicos-alvo

Comentários

Esta página foi útil?

Last updated on 2025-08-26