Feature Flags en Servicios Go

Los feature flags permiten a los equipos de Go desplegar código en producción manteniendo el nuevo comportamiento desactivado hasta que se complete la validación, o activar un interruptor de emergencia sin necesidad de reconstruir el binario.

Resumen

Un feature flag es una decisión en tiempo de ejecución: dada una clave de flag y un contexto de evaluación (usuario, tenant, región), devuelve habilitado o deshabilitado.

Los servicios Go evalúan flags en handlers, workers e interceptores gRPC.

OpenFeature proporciona un SDK neutral al proveedor; LaunchDarkly, Flagsmith y servicios de configuración internos se conectan como proveedores.

Los flags complementan los despliegues canary: canary cambia el tráfico entre binarios; los flags cambian el comportamiento dentro del mismo binario.

Receta

Tarjeta de receta de referencia rápida - lista para copiar y pegar.

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

Cuándo usar esto:

• Lanzamiento en modo oscuro de funcionalidades durante despliegues canary o blue-green.
• Despliegues graduales por porcentaje a tenants empresariales.
• Interruptores de emergencia para integraciones de riesgo sin necesidad de un redeploy de emergencia.
• Experimentos A/B en el comportamiento de la API o la forma de la respuesta.
• Controles de operaciones (modo de mantenimiento, modo de solo lectura).

Ejemplo de Trabajo

package main
 
import (
    "context"
    "log/slog"
    "net/http"
    "os"
    "sync"
    "time"
)
 
// InMemoryProvider es un backend de flags mínimo para demos y pruebas.
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("error de evaluación de flag", "key", key, "err", err)
        return def
    }
    return val
}
 
func main() {
    provider := NewInMemoryProvider()
    // Desactivado por defecto - lanzamiento en modo oscuro
    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, "prohibido", 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("escuchando", "addr", srv.Addr)
    if err := srv.ListenAndServe(); err != nil {
        slog.Error("servidor detenido", "err", err)
        os.Exit(1)
    }
}

Lo que esto demuestra:

• false por defecto para nuevos flags - postura segura de lanzamiento en modo oscuro.
• Los errores de evaluación de flags vuelven al valor por defecto (fallo seguro a la ruta heredada).
• Endpoint de administración protegido por token para habilitación controlada (producción usa UI del proveedor o GitOps).
• El mismo binario sirve a ambas rutas de código; el cambio de estado no requiere redeploy.

Análisis Profundo

Cómo Funciona

1. Proveedor obtiene definiciones de flags de LaunchDarkly, Flagsmith, JSON de S3 o etcd.
2. SDK almacena en caché las evaluaciones y transmite actualizaciones (SSE o polling).
3. Aplicación llama a BooleanValue / StringValue en los puntos de decisión con un contexto de evaluación (ID de usuario, organización, región).
4. Observabilidad registra la clave del flag y la variante en campos estructurados para la correlación de incidentes.

Contexto de Evaluación

Pasa el contexto desde reclamaciones JWT o claves de API - nunca evalúes flags sin identidad para el comportamiento visible para el usuario.

OpenFeature vs SDK del Proveedor

Notas sobre Go

// Evalúa una vez por solicitud, pasa la decisión hacia abajo - evita llamadas N+1 al proveedor
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))
        })
    }
}

• Inyecta *openfeature.Client o tu interfaz en main - prueba con un proveedor falso.
• Para gRPC, evalúa en interceptores unarios y adjunta a context.Context.

Errores Comunes

• Valor por defecto true para nuevos flags - una interrupción del proveedor habilita código arriesgado para todos. Solución: valor por defecto false; opción de habilitación explícita por entorno.
• Comprobaciones de flags en bucles intensivos - llamar al proveedor en cada fila de la base de datos. Solución: evalúa una vez por solicitud o almacena en caché con TTL que respete las actualizaciones en streaming.
• Estado de flag inconsistente entre pods - caché obsoleto después de un interruptor de emergencia. Solución: usa streaming del proveedor; establece un TTL de caché corto para flags críticos.
• Sin rastro de auditoría - nadie sabe quién habilitó payments-v2. Solución: usa registros de auditoría del proveedor o GitOps para la configuración de flags.
• Flags permanentes - las ramas if flag se convierten en espagueti. Solución: tickets de retiro de flags; elimina rutas muertas después del despliegue completo.
• Flags sensibles en logs - registrar el contexto de evaluación completo filtra PII. Solución: registra solo la clave del flag y el resultado.

Alternativas

Preguntas Frecuentes

Relacionado

• Conceptos Básicos de Entrega Empresarial - ejemplo de flag respaldado por entorno
• Envío Seguro de Servicios Go a Escala Empresarial - flags en la cadena de entrega
• Estrategia de Lanzamiento: Blue-Green y Canary para Go - cambio de tráfico
• Entrega Progresiva y Verificación Automatizada - verifica antes de habilitar flags
• Runbooks de Reversión para Despliegues Go - desactiva flags durante incidentes

Versiones de Stack: Esta página fue escrita para Go 1.26.x (GC por defecto Green Tea, modernizadores go fix - verifica el parche en la compilación), chi (última versión - verifica en la compilación), gin (última versión - verifica en la compilación), echo (última versión - verifica en la compilación), google.golang.org/grpc (última versión - verifica en la compilación), sigs.k8s.io/controller-runtime (última versión - verifica en la compilación), kubebuilder (última versión - verifica en la compilación), tinygo (última versión - verifica objetivos de placa en la compilación), wazero (última versión - verifica en la compilación) y golangci-lint (última versión - verifica el conjunto de linters en la compilación).