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

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 recursos em um aplicativo de console Go.

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 de console Go com recursos de monitoramento em tempo real.

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.

Usar um sinalizador de recurso

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

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

Inicialize um novo módulo Go:
```
go mod init go-feature-flag-quickstart
```

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

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

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 o arquivo main.goprincipal do aplicativo :

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

Execute o aplicativo

Execute a aplicação:
```
go mod tidy
go run .
```

O aplicativo começa a monitorar o sinalizador de recurso Beta e exibe seu estado atual a cada 5 segundos:

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

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.
Retorne ao aplicativo do console. Depois de alguns segundos, você verá a alteração do status do sinalizador de recurso:
```
[14:30:30] Beta is enabled: false
[14:30:35] Beta is enabled: true
[14:30:40] Beta is enabled: true
```
Você pode ativar e desativar o sinalizador de recurso no portal do Azure para ver atualizações em tempo real em seu aplicativo de console sem reiniciá-lo.
Pressione Ctrl+C para parar o aplicativo.

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 de console Go. A biblioteca Feature Management Go fornece capacidades avançadas de flags de funcionalidades que se integram perfeitamente com o Azure App Configuration. Para obter mais funcionalidades, consulte o documento seguinte.

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