Cuando se trata de analizar el rendimiento y la escalabilidad de nuestras APIs y servicios web, necesitamos herramientas que no solo sean rápidas, sino también fáciles de configurar e integrar en nuestros flujos de trabajo modernos.

Herramientas clásicas como ab (Apache Bench) o wrk han sido el estándar durante años, y opciones más modernas como Vegeta o K6 han aportado mucho valor. Sin embargo, hoy quiero hablaros de Goku, una aplicación de pruebas de carga HTTP escrita en Rust que combina rendimiento extremo, simplicidad y características modernas como soporte para el Model Context Protocol (MCP).

En este artículo, exploraremos qué hace especial a Goku, todas sus funcionalidades en detalle y ejemplos prácticos para que puedas empezar a usarlo hoy mismo en tus proyectos.

¿Por qué Goku?

Goku destaca por varias razones clave:

  1. Rendimiento y Escalabilidad: Al estar escrito en Rust, Goku aprovecha al máximo los recursos de la máquina, permitiendo generar cargas masivas de tráfico con un consumo mínimo de memoria y CPU.
  2. Simplicidad: Puedes lanzar pruebas complejas directamente desde la línea de comandos (CLI) o definir escenarios elaborados en archivos YAML.
  3. Versatilidad: Soporta HTTP/1.1 y HTTP/2, autenticación (Bearer y Basic), y perfiles de carga de tasa constante (limitación de peticiones por segundo).
  4. Integración con IA (MCP): Es una de las primeras herramientas de su clase en ofrecer un servidor MCP integrado, lo que significa que puedes pedirle a un agente de IA (como Claude o ChatGPT) que ejecute pruebas de carga y analice los resultados por ti.

Instalación

Instalar Goku es muy sencillo. Tienes varias opciones:

Instalación automática (Linux, macOS, WSL):

curl -sSL https://raw.githubusercontent.com/jcaromiq/goku/v3.0.0/scripts/install.sh | sh

Usando Cargo (Rust package manager):

cargo install goku-bench

Ejemplos de Uso y Funcionalidades Principales

Vamos a ver cómo utilizar Goku en el día a día, desde lo más básico hasta escenarios avanzados.

1. Pruebas de Carga Básicas

La forma más sencilla de usar Goku es mediante la línea de comandos, especificando el objetivo (--target), la concurrencia (--clients o -c) y el número de iteraciones (--iterations o -i).

# Lanzar 1000 peticiones en total, usando 50 clientes concurrentes
goku -c 50 -i 1000 --target "GET http://localhost:3000/api/users"

Si prefieres realizar la prueba durante un tiempo determinado en lugar de un número fijo de peticiones, puedes usar --duration (-d):

# Mantener 50 clientes concurrentes atacando la API durante 60 segundos
goku -c 50 --duration 60 --target "GET http://localhost:3000/api/users"

2. Control de Tráfico (Rate Limiting y Ramp-Up)

A veces no quieres saturar el servidor de golpe, o quieres probar cómo se comporta bajo una carga constante específica.

Tasa Constante (RPS): Para limitar el número máximo de peticiones por segundo en todos los clientes, usa --rps:

# 20 clientes, 60 segundos, pero limitado estrictamente a 200 peticiones por segundo
goku -c 20 --duration 60 --rps 200 --target http://localhost:3000

Ramp-Up (Arranque gradual): Para simular un pico de tráfico gradual, distribuye el inicio de los clientes a lo largo de un tiempo con --ramp-up:

# 100 clientes que irán arrancando gradualmente durante 10 segundos
goku -c 100 -i 5000 --ramp-up 10 --target http://localhost:3000

3. Peticiones Complejas (Headers, Body y Auth)

Goku soporta peticiones HTTP complejas. Puedes añadir cabeceras, enviar cuerpos de petición y manejar autenticación fácilmente.

Enviando un Payload (JSON):

goku -c 50 -i 1000 \
  --headers "Content-Type:application/json" \
  --request-body payload.json \
  --target "POST http://localhost:3000/api/orders"

Autenticación Integrada: Goku tiene flags dedicados para inyectar cabeceras de autorización comunes:

# Usando Bearer Token (muy común en APIs modernas)
goku --auth-bearer "eyJhbGciOiJIUzI1NiIsIn..." --target http://api.example.com/protected

# Usando Basic Auth
goku --auth-basic "admin:secret_password" --target http://api.example.com/admin

4. Escenarios Avanzados con YAML

Para pruebas más sofisticadas, especialmente las que involucran flujos de usuario (multi-step), es mucho más limpio utilizar un archivo YAML mediante el flag --scenario.

Un archivo de escenario te permite definir secuencias de peticiones y usar variables dinámicas.

ejemplo_escenario.yaml:

clients: 20
duration: 60
ramp_up: 5
live_stats: 10 # Muestra métricas parciales en consola cada 10s
steps:
  # Paso 1: Obtener una lista
  - target: "GET http://api.example.com/users"
  
  # Paso 2: Crear un registro usando plantillas de variables
  - target: "POST http://api.example.com/orders"
    headers:
      - key: "Content-Type"
        value: "application/json"
    # Uso de variables integradas: {{uuid}}, {{seq}}
    body: '{"id": "{{uuid}}", "item": "widget", "sequence": {{seq}}}'

Para ejecutar este escenario:

goku --scenario ejemplo_escenario.yaml

Variables de Plantilla Disponibles: Goku inyecta variables dinámicamente en URLs y cuerpos de petición para cada ejecución:

  • {{uuid}}: Genera un UUID v4 único.
  • {{seq}}: Un número secuencial global.
  • {{timestamp}}: Marca de tiempo actual.
  • {{client}}: El número de ID del trabajador/cliente actual.
  • {{random_int(min,max)}}: Un entero aleatorio entre un rango. Ej: {{random_int(1,500)}}

5. Análisis de Resultados y Comparativas

Goku brilla en la forma en que presenta la información. Por defecto, muestra un informe en texto plano con un histograma ASCII de latencias, percentiles (p50, p95, p99) y desglose de códigos de estado.

Concurrency level      50
Time taken             4 seconds
Total requests         1000
Requests/sec           250.00 req/s

Mean                   169.90 ms
p50 (median)           155 ms
p95                    319 ms
p99                    360 ms

Status codes
  2xx                  998
  5xx                  2

Latency distribution
  10ms  ████████████████████████████████████████ 450
  25ms  █████████████████████████ 280
  200ms ████████ 80

Exportación de Datos: Para integrarlo en procesos CI/CD, puedes exportar los resultados a JSON o CSV:

goku -c 50 -i 1000 --output json --output-file results.json --target http://localhost:3000

Si necesitas datos pormenorizados de cada petición para analizarlos en herramientas externas, usa --results-log para generar un CSV con todas las peticiones (timestamp, status, latencia).

Comparación de Versiones (A/B Testing de Rendimiento): Goku incluye un subcomando compare que es oro puro cuando estás optimizando código. Puedes ejecutar una prueba antes de tus cambios, otra después, y pedirle a Goku que te muestre la diferencia exacta:

# 1. Prueba baseline (rama main)
goku -c 50 -i 1000 --output json --output-file before.json --target http://localhost:3000

# ... despliegas tu nueva versión optimizada ...

# 2. Prueba candidata
goku -c 50 -i 1000 --output json --output-file after.json --target http://localhost:3000

# 3. Comparar
goku compare before.json after.json

6. La revolución: Integración MCP para Agentes de IA

Lo que realmente separa a Goku de otras herramientas es su visión de futuro. Goku incluye un servidor MCP (Model Context Protocol).

Esto significa que puedes conectar Goku a herramientas como Claude Desktop o cualquier agente compatible con MCP. Una vez conectado, en lugar de escribir comandos en la terminal, simplemente puedes conversar con la IA:

“Ejecuta una prueba de carga contra https://api.example.com/users con 50 clientes concurrentes durante 30 segundos y dime si el percentil 95 supera los 200ms.”

El agente de IA invocará la herramienta run_benchmark de Goku, ejecutará la prueba en tu máquina, leerá el JSON de respuesta y te dará un análisis natural del resultado.

Para instalar el servidor MCP de Goku:

curl -sSL https://raw.githubusercontent.com/jcaromiq/goku/v3.0.0/scripts/install_mcp.sh | sh
# O vía cargo: cargo install goku-mcp

Resumen

Goku es una adición fantástica al ecosistema de herramientas de testing. Escrito en Rust para asegurar rendimiento bruto, proporciona la flexibilidad de escenarios en YAML para pruebas complejas, facilidades para CI/CD con salidas JSON/CSV, y una pionera integración con agentes de IA vía MCP.

Si estás trabajando en la optimización de APIs o necesitas asegurar la resiliencia de tus servicios, te recomiendo encarecidamente que le des una oportunidad a Goku en tu próximo proyecto.