Pruebas de carga de API con Locust
Pruebas de carga de API con Locust: Introducción
Probablemente haya estado en esta situación antes: escribe código que hace algo, un punto final, por ejemplo. Prueba su punto final con Postman o Insomnia, y todo funciona bien. Pasa el punto final al desarrollador del lado del cliente, quien luego consume el API y despliega la aplicación. Pero luego, la API falla cuando los usuarios usan la aplicación.
Esta puede ser una situación muy molesta, sin mencionar que es costosa para una empresa. Es por eso que los desarrolladores de software llevan a cabo una variedad de pruebas en los sistemas de software para asegurarse de que funcionen como se espera. Las API no son diferentes. Antes de la implementación, debe realizar al menos pruebas de rendimiento y pruebas de seguridad.
Las pruebas de rendimiento se pueden agrupar en pruebas de funcionalidad y pruebas de carga. Las pruebas de funcionalidad son para lo que sueles usar Postman o Insomnia. Se aseguran de que su API funcione como usted espera. Las pruebas de carga, por otro lado, están más preocupadas por el rendimiento de su API con el uso real y la carga máxima, y de eso trata este artículo. Veamos las pruebas de carga con más detalle.
¿Qué es la prueba de carga de API?
La prueba de carga de API es un tipo de prueba que usan los desarrolladores para simular la carga normal y máxima en los puntos finales. Este tipo de prueba permite a los desarrolladores evaluar el rendimiento real de una API antes de implementarla. Les ayuda a identificar la capacidad operativa máxima de un sistema, los cuellos de botella, si los hubiera, y la degradación del rendimiento. Las pruebas de carga de la API generalmente se realizan creando usuarios virtuales y luego usándolos para probar la funcionalidad de la API al mismo tiempo.
Las pruebas de carga de la API miden métricas como el tiempo de respuesta, los usuarios simultáneos, las tasas de rendimiento, los niveles de utilización de recursos, el tiempo medio entre fallos (MTBF), el tiempo medio hasta el fallo (MTTF), etc. Todas estas métricas se pueden usar para determinar qué tan bien está funcionando la API.
Tipos de pruebas de carga
Hay varios tipos de pruebas de carga, cada uno con sus casos de uso. Echemos un vistazo a algunos de ellos.
Prueba de carga: Esta es la forma básica de una prueba de carga. Se utiliza para evaluar el rendimiento de un sistema (en este caso, una API) con carga normal y carga máxima esperada.
Pruebas de estrés: Esto se utiliza para evaluar el rendimiento de un sistema bajo una carga muy pesada. El objetivo de esta prueba es ver si un sistema se recupera después de una falla y cuánto tiempo lleva hacerlo. La carga generalmente aumenta lentamente hasta que excede las capacidades del sistema.
Prueba de picos: Esto es un poco similar a la prueba de estrés, excepto que se aplica una carga pesada repentinamente, en lugar de aumentarla lentamente. Este tipo de prueba representa lo que sucede cuando hay un aumento repentino en la cantidad promedio de usuarios o visitantes, o cuando hay un ataque DDOS en su sistema.
Prueba de remojo: Esta prueba es diferente a las otras anteriores. Pone su sistema por debajo del 80% (o más o menos) de la carga normal y lo deja funcionando durante un período prolongado, digamos de 12 a 14 horas. Este tipo de prueba determina qué tan confiable es un sistema a lo largo del tiempo.
Prueba de carga de sus API con Locust
Los desarrolladores tienen acceso a una variedad de opciones para realizar pruebas de carga de sus API. Algunas herramientas de prueba de carga comunes son Gatling, JMeter y Locust. Nos centraremos en Locust en este artículo.
Locust es una herramienta de prueba de carga de código abierto basada en Python que utilizan las principales empresas como Google, Microsoft y Riot Games para probar sus API. En este artículo, demostraremos cómo cargar una prueba de API.
Para este tutorial, crearé una API simple con Flask. Puede seguirme o simplemente crear su API con Node, o cualquier marco con el que se sienta cómodo.
Requisitos
3 Python
Configuración e instalación
Primero, debe configurar un entorno virtual en su PC para no estropear su entorno Python global. Para hacer eso, ejecute los siguientes comandos. Tenga en cuenta que estos comandos se aplican a una terminal de Windows.
$ mkdir proyecto
$ cd /d ruta\al\proyecto
$ python -m venv venv
$ venv\Scripts\activar
Primero, creamos un proyecto directorio. Luego cambiamos nuestro directorio actual a proyecto. Luego creamos y activamos un entorno virtual para Python dentro de ese directorio.
Ahora, vamos a pasar a la instalación Frasco(lo usaremos para crear los puntos finales para la prueba de carga) y Langosta misma.
Para instalar Flask, ejecute. Asegúrate de estar en el proyecto donde creaste un entorno virtual.
$ pip instalar matraz
Para instalar Locust, ejecute
$ pip instalar langosta
Una vez hecho esto, escriba los siguientes comandos. Asegúrate de estar en tu proyecto directorio cuando haces esto.
$ copia nul __init__.py
aplicación $ mkdir
$ copiar nul app\app.py
$ copiar aplicación nul\__init__.py
Este comando crea algunos archivos que usaremos para crear nuestros puntos finales usando Flask. Por cierto, también puede crear estos archivos usando su explorador de archivos. Pero, ¿cuál es la diversión en eso? Una vez que haya hecho eso, copie el siguiente código en aplicación.py
de matraz importar Flask, jsonify, solicitud
app = Frasco (__ nombre__)
coches_modelos = [
{ 'marca': 'Tesla', 'modelo': 'Modelo S' }
]
aviones_modelos = [
{ 'marca': 'Boeing', 'modelo': '747' }
]
@app.ruta('/coches')
def get_cars():
devolver jsonify(car_models)
@app.route('/aviones')
def obtener_aviones():
devolver jsonify (plane_models)
if __name__ == '__main__':
app.run (debug = True)
El código anterior contiene un método. conseguir_coches solía obtener una lista de marcas de automóviles y sus modelos, y conseguir_aviones solía obtener una lista de marcas de aviones y sus modelos. Para que podamos cargar la prueba de este punto final, necesitamos ejecutar app.py. Para hacer eso, ejecute el siguiente comando.
$ python ruta\a\app.py
Una vez que lo ejecutes, deberías ver algo como esto:
Si copia la URL desde la terminal y escribe carros or planos después de /, debería poder ver los datos allí. Sin embargo, nuestro objetivo es probar el punto final con Locust, no con el navegador. Así que hagamos eso. Ejecute el siguiente comando en la raíz de su proyecto directorio.
$ copiar nul locust_test.py
Esto crea un archivo 'locust_test.py' en la raíz de su proyecto directorio. Una vez que haya hecho eso, abra el archivo y pegue el código a continuación. Te lo explicamos en breve.
tiempo de importación
from locust import HttpUser, tarea, entre
comportamiento de usuario de clase (HttpUser):
tiempo_espera = entre (5, 10)
@tarea
def get_cars(yo):
self.cliente.get('/coches')
@tarea
def get_planes(yo):
self.cliente.get('/aviones')
Este es un ejemplo básico del uso de Locust para probar una API. Primero creamos una clase comportamiento del usuario, que puede recibir cualquier nombre apropiado pero debe extenderse Usuario Http. UsuarioHttp es la clase que se encarga de instanciar múltiples usuarios virtuales para realizar las tareas que especificamos en el comportamiento del usuario clase.
Una tarea se especifica decorando un método con el @tarea decorador. También tenemos una función llamada Entre() que nos permite especificar un rango de segundos a esperar antes de ejecutar la siguiente tarea. Puede ver que asignamos un rango de 5 a 10 segundos para eso en nuestro código.
Para ejecutar el código, asegúrese de estar todavía en su entorno virtual. Si el que creó está siendo utilizado por el servidor que sirve la API, abra una nueva terminal, cambie su directorio a su proyecto directorio y active el entorno virtual que ha creado. Puede encontrar el comando para activar un entorno virtual arriba. Ahora, ingrese el siguiente comando en su terminal.
$ langosta -f langosta_prueba.py
Debería ver algo como esto:
De forma predeterminada, la interfaz web de Locust se encuentra en http://localhost/8089. Si visita el sitio web, debería ver una interfaz como esta:
Desde la interfaz, podemos especificar la cantidad de usuarios, la tasa de generación (usuarios creados por segundo) y el Host. Puede obtener la dirección de su host comprobando la terminal donde se ejecuta el servidor. En nuestro caso, está en el puerto 5000. Al hacer clic en Empieza a pulular, se le presentará la interfaz a continuación.
Esto le muestra varias métricas útiles, como la cantidad de solicitudes fallidas, el tiempo promedio para una solicitud, el tiempo mínimo para una solicitud, solicitudes por segundo, etc. Una vez que esté satisfecho con lo que ve, puede hacer clic en el botón de detener.
Además de la Estadística pestaña, hay una Gráficas pestaña que muestra más información en forma de gráfico, como la imagen de abajo.
Hay un gráfico de solicitudes totales por segundo, gráfico de tiempo de respuesta, y gráfico de número de usuarios, todo trazado contra el tiempo. Usando los gráficos, puede determinar cuántos usuarios son aceptables para un tiempo de respuesta fijo, o puede observar sus gráficos para un tiempo de respuesta constante a pesar de un número creciente de usuarios y otras ideas como esa. Si quieres compartir estos estadísticas con otra persona, puede descargar un informe de la Descarga de datos .
Para concluir...
La prueba de carga de su API es una actividad crucial en su proceso de desarrollo, así que asegúrese de incorporarla en su ciclo de diseño. Por cierto, también puede realizar otros tipos de pruebas de carga variando los valores para el número de usuarios y la tasa de generación.
Si desea realizar una prueba de aumento, especifique un valor grande (por ejemplo, 2000) para la cantidad de usuarios y luego un valor igualmente grande para su tasa de generación (500, por ejemplo). Esto significa que en 4 segundos, tendría los 2000 usuarios creados y accediendo a sus terminales. Una prueba de estrés será similar, pero con un valor mucho más bajo para la tasa de generación. Para descubrir todo lo que puede hacer, consulte Locust documentación.
