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 de Aplicativos 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 de Aplicativos. Este exemplo demonstra como integrar sinalizadores de recursos a 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.
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 do Go da Configuração de Aplicativos do Azure v1.1.0-beta.1 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.

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

Inicializar 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 chamado 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.

Microsoft Entra ID (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 o arquivo main.gode aplicativo principal:

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

Executar o aplicativo

Execute o aplicativo:
```
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

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.
Retorne ao seu aplicativo de console. Após alguns segundos, você deverá 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 recursos no portal do Azure para ver atualizações em tempo real em seu aplicativo de console sem reiniciá-lo.
Pressione Ctrl+C para interromper o aplicativo.

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 de console Go. A biblioteca Go de Gerenciamento de Recursos fornece recursos avançados de sinalizador de recursos que se integram perfeitamente à Configuração de Aplicativos do Azure. Para obter mais recursos, prossiga 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-07-22