Feature Flags
DevOps
Deploy
Continuous Delivery
Monitoramento

Implementación de indicadores de funciones e implementaciones graduales en producción

Implementación de indicadores de funciones e implementaciones graduales en producción

Los indicadores de funciones son una técnica poderosa que le permite controlar la disponibilidad de funciones en tiempo real. Exploremos cómo implementarlos de manera efectiva en su entorno de producción.

¿Qué son los indicadores de funciones?

Los indicadores de funciones (o alternancias de funciones) son mecanismos que permiten:

  • Activar/desactivar funciones sin implementación
  • Probar funciones con usuarios específicos.
  • Realizar retrocesos rápidos en caso de problemas
  • Implementar implementaciones graduales

Tipos de indicadores de funciones

1. Por entorno

interface EnvironmentFlag {
  name: string;
  environments: {
    development: boolean;
    staging: boolean;
    production: boolean;
  };
  default: boolean;
}

2. Por usuario

interface UserFlag {
  name: string;
  type: 'percentage' | 'specific' | 'custom';
  rules: {
    percentage?: number;
    userIds?: string[];
    customRule?: (user: User) => boolean;
  };
}

Implementación práctica

1. Estructura básica

class FeatureFlagManager {
  private flags: Map<string, FeatureFlag>;
  
  constructor() {
    this.flags = new Map();
  }

  isEnabled(flagName: string, context: FlagContext): boolean {
    const flag = this.flags.get(flagName);
    if (!flag) return false;
    
    return flag.evaluate(context);
  }

  async updateFlag(flagName: string, config: FlagConfig): Promise<void> {
    // Implementação da atualização
  }
}

2. Integración de backend

// Exemplo com Express
app.use(async (req, res, next) => {
  const context = {
    userId: req.user?.id,
    environment: process.env.NODE_ENV,
    timestamp: Date.now()
  };
  
  req.featureFlags = await featureFlagManager.getFlags(context);
  next();
});

Implementaciones graduales

1. Estrategias de implementación

Un lanzamiento gradual avanza por etapas, ampliando la exposición a medida que crece la confianza. Una progresión típica comienza desde la función terminada y es así:

  1. 5%, usuarios beta, el primer grupo en recibir la noticia.
  2. 25%, usuarios activos, con la funcionalidad ya validada en el grupo inicial.
  3. 50%, mayoría de usuarios.
  4. 100%, disponibilidad para toda la base.

Cada salto sólo ocurre después de que las métricas de la etapa anterior confirmen la estabilidad.

2. Monitoreo

interface RolloutMetrics {
  flagName: string;
  totalUsers: number;
  enabledUsers: number;
  errorRate: number;
  performanceMetrics: {
    responseTime: number;
    errorCount: number;
  };
}

Herramientas y servicios

1. Autohospedado

  • 🏠 Desata

    • Código abierto
    • Control total
    • API REST
    • Panel de control

  • 🏢 Flagero

    • SDK para múltiples idiomas
    • Pruebas A/B
    • Análisis

2. Basado en la nube

  • ☁️ LanzarDarkly

    • Gestión centralizada
    • Análisis avanzado
    • Integraciones listas para usar

  • 🌐 Split.io

    • Experimentación
    • Segmentación avanzada
    • Monitoreo en tiempo real

##Buenas Prácticas

1. Nomenclatura

// Exemplos de nomes claros
const FLAGS = {
  NEW_CHECKOUT_FLOW: 'new-checkout-flow-v2',
  DARK_MODE_BETA: 'dark-mode-beta-test',
  PAYMENT_GATEWAY_MIGRATION: 'payment-gateway-migration'
};

2. Documentación

Cada bandera merece un formulario breve y estandarizado. Para new-checkout-flow-v2, por ejemplo, la documentación cubriría:

  • Descripción: implementación de la nueva versión del flujo de pago.
  • Estados: Desarrollo habilitado, Staging habilitado, Producción en despliegue gradual (25%).
  • Dependencias: Pasarela de Pago v2 y Servicio de Validación de Dirección.
  • Plan de implementación: 5 % (beta), 25 % (activo), 50 % (mayoría), 100 % (todos).

Este registro evita que las banderas se conviertan en deuda técnica olvidada y brinda contexto a quienes necesitan decidir si seguir adelante o eliminar la bandera.

Monitoreo y Alertas

1. Métricas esenciales

interface FlagMetrics {
  name: string;
  enabledCount: number;
  totalRequests: number;
  errorRate: number;
  performanceImpact: {
    p50: number;
    p95: number;
    p99: number;
  };
}

2. Alertas

alerts:
  - name: high_error_rate
    condition: error_rate > 1%
    action: disable_flag
    
  - name: performance_degradation
    condition: p95 > 500ms
    action: notify_team

Casos de uso

1. Implementación segura

El ciclo de implementación segura cierra un ciclo de retroalimentación entre cuatro actores. El desarrollador activa la bandera para una fracción inicial de usuarios (5%). El indicador de función alimenta el sistema de monitoreo con métricas de uso, errores y rendimiento. El monitoreo compara estos números con los umbrales definidos y, cada vez que se excede un límite, el sistema de alerta notifica al desarrollador, quien decide adelantar el lanzamiento o revertirlo. Es este bucle continuo el que hace que la entrega incremental sea segura.

2. Reversión rápida

async function handleError(flagName: string, error: Error) {
  // Desativa flag imediatamente
  await featureFlagManager.disable(flagName);
  
  // Notifica equipe
  await notifyTeam({
    type: 'FLAG_ERROR',
    flagName,
    error: error.message,
    timestamp: new Date()
  });
  
  // Registra métricas
  await metrics.recordRollback(flagName);
}

Conclusión

Las banderas de funciones son esenciales para:

  1. Implementación segura
  2. Pruebas de producción
  3. Retrocesos rápidos
  4. Experimentos controlados
  5. Monitoreo efectivo

Próximos pasos

  1. Elige tu herramienta
  2. Definir estándares de nomenclatura
  3. Implementar monitoreo
  4. Crear documentación
  5. Entrena al equipo

¿Quieres compartir tu experiencia con las banderas de funciones? ¡Deja un comentario a continuación!

Lea también

GitHub
LinkedIn
X
youtube