Feature Flags em Serviços Go

Feature flags permitem que equipes Go implantem código em produção mantendo o novo comportamento desativado até que a validação seja concluída - ou alternem um kill switch sem recompilar o binário.

Resumo

Uma feature flag é uma decisão em tempo de execução: dada uma chave de flag e um contexto de avaliação (usuário, tenant, região), retorna habilitado ou desabilitado.

Serviços Go avaliam flags em handlers, workers e interceptores gRPC.

OpenFeature fornece um SDK neutro em relação ao fornecedor; LaunchDarkly, Flagsmith e serviços de configuração internos se conectam como provedores.

Flags complementam deploys canary: canary muda o tráfego entre binários; flags mudam o comportamento dentro do mesmo binário.

Receita

Cartão de receita de referência rápida - pronto para copiar e colar.

import (
    "context"
    "github.com/open-feature/go-sdk/openfeature"
)
 
func checkoutHandler(client *openfeature.Client) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        enabled, _ := client.BooleanValue(r.Context(), "new-checkout", false, openfeature.EvaluationContext{})
        if enabled {
            newCheckout(w, r)
            return
        }
        legacyCheckout(w, r)
    }
}

Quando usar isso:

• Lançamento de recursos em modo oculto (dark-launching) durante deploys canary ou blue-green
• Rollouts graduais por porcentagem para tenants corporativos
• Kill switches para integrações arriscadas sem necessidade de reimplantar em emergências
• Experimentos A/B em comportamento de API ou formato de resposta
• Toggles controlados por operações (modo de manutenção, modo somente leitura)

Exemplo de Trabalho

package main
 
import (
    "context"
    "log/slog"
    "net/http"
    "os"
    "sync"
    "time"
)
 
// InMemoryProvider é um backend de flag mínimo para demonstrações e testes.
type InMemoryProvider struct {
    mu    sync.RWMutex
    flags map[string]bool
}
 
func NewInMemoryProvider() *InMemoryProvider {
    return &InMemoryProvider{flags: map[string]bool{}}
}
 
func (p *InMemoryProvider) Set(key string, val bool) {
    p.mu.Lock()
    p.flags[key] = val
    p.mu.Unlock()
}
 
func (p *InMemoryProvider) BooleanEvaluation(_ context.Context, flag string, defaultValue bool, _ map[string]interface{}) (bool, error) {
    p.mu.RLock()
    defer p.mu.RUnlock()
    if v, ok := p.flags[flag]; ok {
        return v, nil
    }
    return defaultValue, nil
}
 
type FlagClient struct {
    provider *InMemoryProvider
}
 
func (c *FlagClient) Enabled(ctx context.Context, key string, def bool) bool {
    val, err := c.provider.BooleanEvaluation(ctx, key, def, nil)
    if err != nil {
        slog.Warn("erro na avaliação da flag", "key", key, "err", err)
        return def
    }
    return val
}
 
func main() {
    provider := NewInMemoryProvider()
    // Desligado por padrão - dark launch
    provider.Set("new-pricing", false)
    flags := &FlagClient{provider: provider}
 
    mux := http.NewServeMux()
    mux.HandleFunc("GET /price", func(w http.ResponseWriter, r *http.Request) {
        if flags.Enabled(r.Context(), "new-pricing", false) {
            w.Write([]byte(`{"amount":99,"engine":"v2"}`))
            return
        }
        w.Write([]byte(`{"amount":100,"engine":"v1"}`))
    })
    mux.HandleFunc("POST /admin/flags/{key}", func(w http.ResponseWriter, r *http.Request) {
        if r.Header.Get("X-Admin-Token") != os.Getenv("ADMIN_TOKEN") {
            http.Error(w, "proibido", http.StatusForbidden)
            return
        }
        key := r.PathValue("key")
        provider.Set(key, r.URL.Query().Get("value") == "true")
        w.WriteHeader(http.StatusNoContent)
    })
 
    srv := &http.Server{Addr: ":8080", Handler: mux, ReadHeaderTimeout: 5 * time.Second}
    slog.Info("escutando", "addr", srv.Addr)
    if err := srv.ListenAndServe(); err != nil {
        slog.Error("servidor parado", "err", err)
        os.Exit(1)
    }
}

O que isso demonstra:

• Padrão false para novas flags - postura segura de dark launch.
• Erros de avaliação de flag retornam ao padrão (falha segura para o caminho legado).
• Endpoint de administração protegido por token para habilitação controlada (produção usa UI do fornecedor ou GitOps).
• O mesmo binário atende a ambos os caminhos de código; alternar não requer reimplantar.

Mergulho Profundo

Como Funciona

1. Provedor busca definições de flags de LaunchDarkly, Flagsmith, S3 JSON ou etcd.
2. SDK armazena em cache avaliações e transmite atualizações (SSE ou polling).
3. Aplicação chama BooleanValue / StringValue em pontos de decisão com um contexto de avaliação (ID do usuário, organização, região).
4. Observabilidade registra a chave da flag e a variante em campos estruturados para correlação de incidentes.

Contexto de Avaliação

Passe o contexto de claims JWT ou chaves de API - nunca avalie flags sem identidade para comportamento voltado ao usuário.

OpenFeature vs SDK do Fornecedor

Notas de Go

// Avalie uma vez por requisição, passe a decisão adiante - evite chamadas N+1 ao provedor
func middleware(flags *FlagClient) func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            ctx := context.WithValue(r.Context(), pricingFlagKey,
                flags.Enabled(r.Context(), "new-pricing", false))
            next.ServeHTTP(w, r.WithContext(ctx))
        })
    }
}

• Injete *openfeature.Client ou sua interface em main - teste com um provedor falso.
• Para gRPC, avalie em interceptores unários e anexe a context.Context.

Armadilhas

• Padrão true para novas flags - uma interrupção do provedor habilita código arriscado para todos. Correção: padrão false; opt-in explícito por ambiente.
• Verificações de flag em loops intensivos - chamando o provedor em cada linha do banco de dados. Correção: avalie uma vez por requisição ou armazene em cache com TTL respeitando atualizações de stream.
• Estado de flag inconsistente entre pods - cache desatualizado após kill switch. Correção: use streaming do provedor; defina TTL de cache curto para flags críticas.
• Sem trilha de auditoria - ninguém sabe quem habilitou payments-v2. Correção: use logs de auditoria do fornecedor ou GitOps para configuração de flags.
• Flags permanentes - ramos if flag se tornam espaguete. Correção: tickets de aposentadoria de flags; exclua caminhos mortos após o rollout completo.
• Flags sensíveis em logs - registrar o contexto de avaliação completo vaza PII. Correção: registre apenas a chave da flag e o resultado.

Alternativas

FAQs

Relacionados

• Noções Básicas de Entrega Empresarial - exemplo de flag com suporte a ambiente
• Enviando Serviços Go com Segurança em Escala Empresarial - flags na cadeia de entrega
• Estratégia de Lançamento: Blue-Green e Canary para Go - mudança de tráfego
• Entrega Progressiva e Verificação Automatizada - verifique antes de habilitar flags
• Runbooks de Rollback para Deployments Go - desative flags durante incidentes

Versões da Stack: Esta página foi escrita para Go 1.26.x (padrão GC Green Tea, go fix modernizers - verifique o patch na compilação), chi (última versão - verifique na compilação), gin (última versão - verifique na compilação), echo (última versão - verifique na compilação), google.golang.org/grpc (última versão - verifique na compilação), sigs.k8s.io/controller-runtime (última versão - verifique na compilação), kubebuilder (última versão - verifique na compilação), tinygo (última versão - verifique os alvos de placa na compilação), wazero (última versão - verifique na compilação) e golangci-lint (última versão - verifique o conjunto de linters na compilação).