TL;DR

  • Artillery = pruebas de carga Node.js con escenarios YAML
  • Define usuarios virtuales, fases (ramp-up, carga sostenida), think time
  • Incluido: soporte HTTP, WebSocket, Socket.io
  • Plugins: protocolos personalizados, métricas, reporters
  • Diseño CLI-first, perfecto para pipelines CI/CD

Ideal para: Equipos Node.js, apps web modernas, desarrolladores que prefieren code-as-config Omite si: Necesitas construcción de tests GUI o extenso soporte de protocolos (usa JMeter) Tiempo de lectura: 12 minutos

Tu API necesita pruebas de carga antes del lanzamiento. Eres un equipo Node.js — el XML de JMeter se siente ajeno. Quieres tests versionados en Git, corriendo en CI/CD junto a tu código.

Artillery habla tu idioma. Configs YAML, instalación npm, ejecución CLI. Tests que se leen como documentación, se ejecutan como código.

¿Qué es Artillery?

Artillery es un toolkit moderno de pruebas de carga construido para desarrolladores. Usa YAML para definición de escenarios y corre en Node.js, haciéndolo natural para equipos JavaScript/TypeScript.

Por qué Artillery:

  • Basado en YAML — escenarios legibles, versionables
  • Amigable para desarrolladores — npm install, ejecución CLI
  • Soporte de protocolos — HTTP, WebSocket, Socket.io incluidos
  • Extensible — funciones JavaScript, plugins personalizados
  • CI/CD nativo — output JSON, exit codes, listo para GitHub Actions

Instalación

npm install -g artillery

Verifica instalación:

artillery version

Tu primera prueba de carga

Escenario YAML básico

# load-test.yml
config:
  target: "https://api.example.com"
  phases:
    - duration: 60
      arrivalRate: 10
      name: "Warm up"

scenarios:
  - name: "Get users"
    flow:
      - get:
          url: "/users"

Ejecutar el test

artillery run load-test.yml

Fases de carga

Patrón Ramp-Up

config:
  target: "https://api.example.com"
  phases:
    # Inicio lento
    - duration: 30
      arrivalRate: 5
      name: "Warm up"

    # Subir al pico
    - duration: 60
      arrivalRate: 5
      rampTo: 50
      name: "Ramp up"

    # Carga sostenida
    - duration: 120
      arrivalRate: 50
      name: "Sustained load"

    # Enfriamiento
    - duration: 30
      arrivalRate: 50
      rampTo: 5
      name: "Cool down"

Escenarios de usuario

Requests secuenciales

scenarios:
  - name: "User journey"
    flow:
      - get:
          url: "/products"
      - think: 2  # Esperar 2 segundos
      - get:
          url: "/products/1"
      - post:
          url: "/cart"
          json:
            productId: 1
            quantity: 2

Capturar y reutilizar datos

scenarios:
  - name: "Login and use token"
    flow:
      - post:
          url: "/auth/login"
          json:
            username: "test"
            password: "secret"
          capture:
            - json: "$.token"
              as: "authToken"

      - get:
          url: "/profile"
          headers:
            Authorization: "Bearer {{ authToken }}"

Assertions

Validación de respuesta

scenarios:
  - name: "API health check"
    flow:
      - get:
          url: "/health"
          expect:
            - statusCode: 200
            - contentType: application/json
            - hasProperty: status
            - equals:
                - "{{ status }}"
                - "healthy"

Configuración de entornos

Usando variables

config:
  target: "{{ $processEnvironment.API_URL }}"
  variables:
    apiKey: "{{ $processEnvironment.API_KEY }}"

scenarios:
  - flow:
      - get:
          url: "/data"
          headers:
            X-API-Key: "{{ apiKey }}"

Múltiples entornos

config:
  environments:
    dev:
      target: "https://dev.api.example.com"
    staging:
      target: "https://staging.api.example.com"
    prod:
      target: "https://api.example.com"

artillery run test.yml -e staging

Reportes

Reporte JSON

artillery run load-test.yml --output results.json

Reporte HTML

artillery run load-test.yml --output results.json
artillery report results.json --output report.html

Integración CI/CD

GitHub Actions

name: Load Tests

on:
  schedule:
    - cron: '0 2 * * *'  # Diario a las 2 AM

jobs:
  load-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'

      - name: Install Artillery
        run: npm install -g artillery

      - name: Run load test
        run: artillery run tests/load-test.yml --output results.json
        env:
          API_URL: ${{ secrets.API_URL }}

      - name: Generate report
        run: artillery report results.json --output report.html

      - name: Upload results
        uses: actions/upload-artifact@v4
        with:
          name: load-test-results
          path: |
            results.json
            report.html

Exit Codes para CI

config:
  ensure:
    p95: 500      # Percentil 95 < 500ms
    maxErrorRate: 1  # < 1% errores

Artillery sale con código 1 si se exceden los umbrales — fallando el job de CI.

Artillery con Asistencia de IA

Las herramientas de IA pueden ayudar a escribir y optimizar escenarios de Artillery.

Lo que la IA hace bien:

  • Generar escenarios YAML desde specs de API
  • Crear journeys de usuario realistas
  • Sugerir configuraciones de fases de carga
  • Convertir otros formatos a Artillery YAML

Lo que necesita humanos:

  • Determinar niveles de carga realistas
  • Interpretar resultados en contexto de negocio
  • Decisiones de capacidad de infraestructura
  • Diferencias entre entornos de producción vs test

FAQ

¿Qué es Artillery?

Artillery es una herramienta moderna de pruebas de carga Node.js. Escribes escenarios de test en YAML, definiendo usuarios virtuales y su comportamiento. Soporta HTTP, WebSocket y Socket.io out of the box, con plugins para protocolos personalizados. Los tests corren desde CLI, generan JSON y se integran fácilmente con pipelines CI/CD.

¿Artillery vs JMeter — cuál es mejor?

Artillery usa configuración YAML (amigable para desarrolladores, versionable). JMeter usa GUI (más fácil para no-programadores). Artillery es más ligero, más rápido de configurar y natural para equipos Node.js. JMeter tiene más soporte de protocolos, funciones enterprise y un ecosistema más grande. Elige Artillery para apps web modernas, JMeter para necesidades enterprise complejas.

¿Es Artillery gratuito?

Artillery Core (la herramienta CLI) es gratuito y open-source bajo licencia MPL-2.0. Maneja la mayoría de necesidades de pruebas de carga. Artillery Pro es un servicio pago que agrega ejecución basada en la nube, analytics avanzados, colaboración de equipo y soporte. La mayoría de equipos empiezan con Core y actualizan si necesitan escala en la nube.

¿Puede Artillery testear WebSockets?

Sí, el soporte WebSocket está incorporado. Define pasos de connection, emit y expect en YAML igual que requests HTTP. Testea aplicaciones real-time, sistemas de chat, juegos multiplayer y backends Socket.io. El mismo escenario puede mezclar pasos HTTP y WebSocket para journeys de usuario realistas.

Recursos Oficiales

Ver También