Marco de pruebas A/B en el servidor: Arquitectura e implementación

En el panorama actual del desarrollo de software, implementar funcionalidades basándose en la intuición es un riesgo. Para los directores y ingenieros senior, el objetivo es crear una infraestructura de experimentación que sea robusta, eficiente y estadísticamente rigurosa. Aunque existen herramientas de terceros, implementar una solución personalizada, centrada en el servidor, a menudo proporciona un mejor control de latencia e una integración más profunda con la lógica específica del dominio.

Este artículo detalla la implementación arquitectónica de un marco de pruebas A/B deterministas. Exploraremos estrategias de segmentación de usuarios, capas de persistencia e integración de telemetría, lo que hace que esta guía sea ideal para equipos que utilizan servicios de ingeniería de productos de alta velocidadpara startups.

Servicios de Ingeniería de Productos

Trabaje con nuestros gestores de proyectos, ingenieros de software y probadores de calidad internos para desarrollar su nuevo producto de software personalizado o para apoyar su flujo de trabajo actual, siguiendo metodologías Agile, DevOps y Lean.

Build with 4Geeks

1. Estrategia Arquitectónica: Cliente contra Servidor

Antes de escribir código, es necesario elegir el entorno de ejecución. Las pruebas del lado del cliente (mediante fragmentos de JavaScript) son más fáciles de implementar, pero sufren del "Flash of Original Content" (FOOC) y una degradación del rendimiento. Para aplicaciones de nivel empresarial, Experimentación en el lado del servidorla experimentación en el servidor

Ventajas clave de la implementación en el lado del servidor:

• Rendimiento: Las decisiones se toman antes de que se renderice el HTML o se envíe la respuesta JSON.
• Consistencia: Se garantiza la consistencia omnicanal (Web, Móvil, Correo electrónico) ya que la "fuente de verdad" reside en el backend.
• Seguridad: La lógica sensible permanece oculta al navegador del cliente.

2. La matemática del enrutamiento determinista

El núcleo de cualquier motor de pruebas A/B es el Algoritmo de Agrupación. Necesitamos una función que mapee un Identificador de Usuario a una variante (por ejemplo, Control vs. Tratamiento) de forma consistente sin necesidad de realizar búsquedas en la base de datos para cada solicitud. Esto requiere un hash estadísticamente independiente.

Utilizamos una función de hash determinística (como MD5 o MurmurHash) combinada con un "Sal" (el ID del experimento).

$Asignación = Hash(UserID + ExperimentID) mod 100

Si el número resultante se encuentra dentro de la asignación de tráfico definida (por ejemplo, 0-50 para Control, 51-100 para Tratamiento), al usuario se le asigna en consecuencia.

3. Implementación en TypeScript

A continuación, se muestra una implementación lista para producción utilizando TypeScript y murmurhash para una distribución uniforme.TypeScriptymurmurhashpara una distribución equitativa.

Servicios de Ingeniería de Productos

Colabore con nuestros gestores de proyectos, ingenieros de software y testers de calidad para desarrollar su nuevo producto de software personalizado o para apoyar su flujo de trabajo actual, siguiendo metodologías Agile, DevOps y Lean.

Build with 4Geeks

Paso A: La interfaz del experimento

Primero, defina la estructura de un experimento. Esto asegura la seguridad del tipo en todo su equipo de ingeniería.

// types/experiment.ts

export enum Variant {
  CONTROL = 'control',
  TREATMENT = 'treatment',
  OFF = 'off' // Fallback
}

export interface ExperimentConfig {
  id: string; // Unique Salt
  name: string;
  trafficAllocation: number; // 0 to 100
  variants: Variant[];
}

// Example Configuration
export const NEW_CHECKOUT_FLOW: ExperimentConfig = {
  id: 'exp_checkout_2024_v1',
  name: 'New One-Page Checkout',
  trafficAllocation: 50, // 50% of users participate
  variants: [Variant.CONTROL, Variant.TREATMENT]
};

Paso B: El Servicio de Clasificación Determinista

Utilizamos la biblioteca murmurhash por su velocidad y sus propiedades de "avalanche", lo que garantiza una distribución equitativa de los usuarios.

// services/ExperimentService.ts
import murmurhash from 'murmurhash';
import { ExperimentConfig, Variant } from '../types/experiment';

export class ExperimentService {
  
  /**
   * Determines the variant for a given user deterministically.
   * @param userId - The unique identifier of the user (UUID).
   * @param experiment - The experiment configuration object.
   * @returns The selected Variant.
   */
  public getVariant(userId: string, experiment: ExperimentConfig): Variant {
    // 1. Create a composite key to ensure independence between experiments
    const hashKey = `${userId}:${experiment.id}`;

    // 2. Generate a deterministic integer using MurmurHash v3
    // resulting value is a 32-bit integer
    const hashValue = murmurhash.v3(hashKey);

    // 3. Normalize to a 0-100 scale
    const normalizedValue = hashValue % 100;

    // 4. Check if user is excluded based on traffic allocation
    if (normalizedValue >= experiment.trafficAllocation) {
      return Variant.OFF;
    }

    // 5. Assign Variant (Simple 50/50 Split Logic)
    // For complex multi-variant splits, use weighted ranges.
    const variantIndex = hashValue % experiment.variants.length;
    return experiment.variants[variantIndex];
  }
}

Este código garantiza que Usuario A siempre verá la misma variante para Experiment X, independientemente del nodo del servidor que procese la solicitud, sin acceder a una base de datos como Redis o PostgreSQL.PostgreSQL.

4. Telemetría y seguimiento de eventos

Asignar una variante es solo la mitad de la batalla. Debe realizar un seguimiento del asignamiento para relacionarlo con las métricas de conversión. Esto a menudo es donde los servicios de ingeniería de datos se intersectan con la ingeniería de productos.data engineering services ² intersect with product engineering.

Cuando se llama al método <s1>getVariantobtener varianteSegment, <s3>Snowflake, o una solución personalizada).Snowflake(o una solución personalizada).

// services/AnalyticsService.ts

interface ExposureEvent {
  event: 'experiment_exposure';
  userId: string;
  experimentId: string;
  variant: string;
  timestamp: string;
}

export function trackExposure(userId: string, experimentId: string, variant: string) {
  const eventPayload: ExposureEvent = {
    event: 'experiment_exposure',
    userId,
    experimentId,
    variant,
    timestamp: new Date().toISOString()
  };

  // Push to message queue (e.g., Kafka, SQS) or Analytics API
  console.log('Telemetry Emitted:', JSON.stringify(eventPayload));
}

5. Integración de Middleware (Ejemplo con Express.js)

Para aplicar esto de forma fluida, integre la lógica en su cadena de middleware. Esto permite que los controladores posteriores simplemente verifiquen req.experiments sin tener que preocuparse por la lógica de hashing.

// middleware/experimentMiddleware.ts
import { Request, Response, NextFunction } from 'express';
import { ExperimentService } from '../services/ExperimentService';
import { NEW_CHECKOUT_FLOW } from '../types/experiment';
import { trackExposure } from '../services/AnalyticsService';

const experimentService = new ExperimentService();

export const checkoutExperimentMiddleware = (req: Request, res: Response, next: NextFunction) => {
  const userId = req.user?.id; // Assuming auth middleware ran previously

  if (!userId) {
    // Fallback for unauthenticated users
    req.variant = 'control'; 
    return next();
  }

  const variant = experimentService.getVariant(userId, NEW_CHECKOUT_FLOW);
  
  // Attach decision to request object for Controller access
  req.variant = variant;

  // Track exposure immediately
  if (variant !== 'off') {
    trackExposure(userId, NEW_CHECKOUT_FLOW.id, variant);
  }

  next();
};

Conclusión

Implementar un marco de pruebas A/B personalizado permite a los equipos de ingeniería mantener el control total sobre la latencia, la seguridad y la experiencia del usuario. Al utilizar el hashing determinista, elimina la necesidad de una gestión costosa del estado de las asignaciones de usuarios, lo que hace que su aplicación sea sin estado y más fácil de escalar.

Para las organizaciones que buscan acelerar su ciclo de desarrollo, 4Geeks ofrece servicios especializados de ingeniería de productos para startups3^{. Si necesita} . Ya sea que necesitedesarrollo de software a medida ⁴para construir estos marcos desde cero, o servicios de ingeniería de DevOps Servicios de ingeniería DevOps ⁵ para automatizar sus pipelines de implementación, 4Geeks es un socio líder en excelencia técnica.

Servicios de Ingeniería de Productos

Trabaje con nuestros gestores de proyectos, ingenieros de software y probadores de calidad internos para desarrollar su nuevo producto de software personalizado o para apoyar su flujo de trabajo actual, siguiendo metodologías Agile, DevOps y Lean.

Build with 4Geeks

Preguntas frecuentes