TL;DR: Locust es un framework de load testing Python. Escribe escenarios de usuario como clases Python, ejecuta tests vía web UI o CLI, escala con modo distribuido. Perfecto para equipos Python que quieren tests de performance basados en código con integración CI/CD.

Locust es un framework de load testing open-source basado en Python que permite a los ingenieros definir escenarios complejos de comportamiento de usuarios como código Python en lugar de configuraciones XML o flujos GUI. Con más de 24,000 estrellas en GitHub, se ha convertido en la herramienta de load testing preferida para equipos centrados en Python. Según la JetBrains Developer Ecosystem Survey 2024, Python es usado por el 51% de los desarrolladores para automatización de testing. A diferencia del modelo basado en threads de JMeter, Locust usa greenlets (coroutines ligeras) permitiendo que una sola máquina simule miles de usuarios concurrentes con memoria mínima. Esta guía completa cubre Locust desde el primer test hasta el load testing distribuido en producción.

Introduccion a Locust

Locust es una herramienta de pruebas de carga basada en Python y de código abierto que permite a los desarrolladores escribir escenarios de prueba en código Python puro. A diferencia de herramientas pesadas en GUI como JMeter, Locust (como se discute en Gatling: High-Performance Load Testing with Scala DSL) proporciona un enfoque code-first con potentes capacidades de pruebas distribuidas y monitoreo en tiempo real basado en web.

Para maximizar el valor de tus pruebas de carga con Locust, te recomendamos complementarlas con pruebas de rendimiento de APIs específicas y una estrategia de testing continuo. Integrar Locust en tu pipeline CI/CD junto con pruebas funcionales de APIs proporciona una cobertura completa de calidad.

Prueba de Carga Básica 

# locustfile.py
from locust (como se discute en [K6: Modern Load Testing with JavaScript for DevOps Teams](/es/blog/k6-for-testing/)) import HttpUser, task, between

class WebsiteUser(HttpUser):
    wait_time = between(1, 3)
    host = "https://api.example.com"

    @task(3)
    def view_products(self):
        self.client.get("/api/products")

    @task(1)
    def view_product_detail(self):
        product_id = 123
        self.client.get(f"/api/products/{product_id}")

    @task(2)
    def add_to_cart(self):
        self.client.post("/api/cart", json={
            "product_id": 456,
            "quantity": 1
        })

Comparación Locust vs JMeter

CaracterísticaLocustJMeter
LenguajePythonGUI/XML
Curva de AprendizajeBaja (si conoce Python)Media-Alta
Test as CodeSí (nativo)Limitado
Pruebas DistribuidasIncorporadoIncorporado
UI en Tiempo RealWeb modernaJava Swing anticuado
Control de VersionesExcelente (archivos Python)Pobre (archivos XML)
Uso de RecursosMenorMayor (Java)
Soporte de ProtocolosHTTP/WebSocket (extensible)Extenso incorporado

Mejores Prácticas

1. Simulación Realista de Usuarios 

from locust import HttpUser, task, between
import random

class RealisticUser(HttpUser):
    wait_time = between(1, 5)

    @task(10)
    def browse(self):
        pages = ['/products', '/about', '/contact']
        self.client.get(random.choice(pages))

    @task(1)
    def purchase(self):
        if random.random() < 0.1:
            self.client.post("/api/orders", json={
                "items": [{"id": random.randint(1, 100), "qty": 1}]
            })

Conclusión

Locust proporciona un enfoque moderno basado en Python para pruebas de carga que sobresale en flujos de trabajo code-first, integración con control de versiones y pruebas distribuidas. Su simplicidad y flexibilidad lo hacen ideal para desarrolladores familiarizados con Python que desean definir pruebas de rendimiento como código.

Elige Locust cuando:

  • El equipo se siente cómodo con Python
  • Se prefieren pruebas como código
  • Se desea UI moderna basada en web
  • Se necesita control de versiones fácil
  • Se requieren pruebas distribuidas

Elige JMeter cuando:

  • Se necesita soporte extenso de protocolos
  • El equipo prefiere creación de pruebas basada en GUI
  • Infraestructura JMeter existente grande
  • Se usan intensivamente protocolos no-HTTP

Documentacion Relacionada

Recursos Oficiales

“Lo que me encanta de Locust es que el test ES la documentación. Un locustfile bien escrito muestra exactamente qué flujos de usuario se testearon en el sistema. Esa claridad es invaluable cuando aparece una regresión de performance seis meses después.” — Yuri Kan, Senior QA Lead

FAQ

¿Qué es Locust y cómo funciona?

Locust es un framework de load testing Python donde el comportamiento de usuarios se define como clases Python con métodos de tarea ejecutados concurrentemente via greenlets.

Locust usa la biblioteca gevent de Python (greenlets) para concurrencia en lugar de threads, permitiendo miles de usuarios virtuales por proceso con mínimo overhead. Defines una clase User con métodos decorados con @task representando acciones de usuario.

¿Cómo se compara Locust con JMeter?

Locust usa código Python para tests legibles y versionables; JMeter usa XML con GUI. Locust gana en developer experience; JMeter en variedad de protocolos.

Los tests de Locust son clases Python — legibles en PRs, fáciles de parametrizar con lógica Python. Los tests JMeter son XML (difícil de revisar) con GUI. Locust sobresale para testing de HTTP APIs con lógica compleja de simulación de usuarios. JMeter soporta más protocolos y tiene un ecosistema enterprise más amplio.

¿Cómo ejecuto tests Locust distribuidos?

Inicia un proceso master y múltiples procesos worker. Los workers se conectan automáticamente al master y reciben tareas de simulación de usuarios.

Setup distribuido de Locust: inicia master con locust --master -f locustfile.py, inicia workers en otras máquinas con locust --worker --master-host=MASTER_IP -f locustfile.py. El master distribuye usuarios equitativamente entre workers.

¿Qué métricas reporta Locust?

Requests/s, percentiles de tiempo de respuesta (mediana, 95°), tasa de fallo y recuento de usuarios. Exporta a CSV o integra con Grafana para dashboards.

Locust reporta métricas por endpoint y agregadas: recuento de requests, recuento de fallos, tiempo de respuesta (mediana, percentiles 90°, 95°, 99°), requests/s y fallos/s. La web UI muestra gráficos en tiempo real. Usa --csv=results para exportar CSVs.

Ver También