Proba de carga da API con Locust
Proba de carga da API con Locust: introdución
Probablemente xa estiveches nesta situación antes: escribes código que fai algo, un punto final, por exemplo. Probas o teu punto final usando Postman ou Insomnia e todo funciona ben. Pasas o punto final ao desenvolvedor do lado do cliente, que logo consume o API e desprega a aplicación. Pero entón, a API falla cando os usuarios usan a aplicación.
Esta pode ser unha situación súper molesta para estar, sen mencionar o custoso para un negocio. É por iso que os desenvolvedores de software realizan unha variedade de probas nos sistemas de software para asegurarse de que funcionan como se espera. As API non son diferentes. Antes da implantación, debes facer polo menos probas de rendemento e probas de seguridade.
As probas de rendemento pódense agrupar en probas de funcionalidade e probas de carga. As probas de funcionalidade son para o que adoita usar Postman ou Insomnia. Aseguran que a túa API funcione como esperas. As probas de carga, por outra banda, están máis preocupadas polo rendemento da túa API co uso do mundo real e a carga máxima, e diso trata este artigo. Vexamos as probas de carga con máis detalle.
Que é a proba de carga da API?
As probas de carga da API son un tipo de probas que usan os desenvolvedores para simular a carga normal e máxima nos puntos finais. Este tipo de probas permite aos desenvolvedores avaliar o rendemento real dunha API antes de que se implemente. Axúdalles a identificar a máxima capacidade operativa dun sistema, os pescozos de botella, se os houber, e a degradación do rendemento. As probas de carga da API adoitan facerse creando usuarios virtuais e despois usándoos para probar a funcionalidade da API ao mesmo tempo.
As probas de carga da API miden métricas como o tempo de resposta, os usuarios simultáneos, as taxas de rendemento, os niveis de utilización de recursos, o tempo medio entre fallos (MTBF), o tempo medio ata o fallo (MTTF), etc. Todas estas métricas pódense usar para determinar o ben que está a facer a API.
Tipos de probas de carga
Existen varios tipos de probas de carga, cada un cos seus casos de uso. Vexamos algúns deles.
Proba de carga: Esta é a forma básica dunha proba de carga. Utilízase para avaliar o rendemento dun sistema (neste caso, unha API) baixo carga normal e carga máxima esperada.
Probas de estrés: Isto úsase para avaliar o rendemento dun sistema baixo unha carga moi pesada. O obxectivo desta proba é ver se un sistema se recupera despois dun fallo e canto tempo leva facelo. A carga adoita aumentar lentamente ata que supera as capacidades do sistema.
Proba de picos: Isto é un pouco semellante ás probas de esforzo, excepto que se aplica carga pesada de súpeto, en lugar de aumentar lentamente. Este tipo de proba representa o que ocorre cando hai un aumento repentino no número medio de usuarios ou visitantes, ou cando hai un ataque DDOS no seu sistema.
Proba de remollo: Esta proba é diferente das outras anteriores. Pon o teu sistema por debaixo do 80% (ou máis ou menos) da carga normal e déixao funcionando durante un longo período, digamos de 12 a 14 horas. Este tipo de proba determina a fiabilidade dun sistema ao longo do tempo.
Carga probando as túas API con Locust
Os desenvolvedores teñen acceso a unha variedade de opcións para probar a carga das súas API. Algunhas ferramentas comúns de proba de carga son Gatling, JMeter e Locust. Centrarémonos en Locust neste artigo.
Locust é unha ferramenta de proba de carga de código aberto baseada en Python que usan as principais empresas como Google, Microsoft e Riot Games para probar as súas API. Neste artigo, demostraremos como probar a carga dunha API.
Para este tutorial, vou crear unha API sinxela con Flask. Podes seguir comigo ou simplemente crear a túa API con Node, ou calquera marco co que esteas cómodo.
requisitos
python 3
Configuración e instalación
En primeiro lugar, cómpre configurar un ambiente virtual no seu PC para non estropear o seu ambiente global de Python. Para iso, execute os seguintes comandos. Teña en conta que estes comandos aplícanse a un terminal de Windows.
proxecto $ mkdir
$ cd /d ruta\a\proxecto
$ python -m venv venv
$ venv\Scripts\activate
En primeiro lugar, creamos un proxecto directorio. Despois cambiamos o noso directorio actual a proxecto. Despois creamos e activamos un ambiente virtual para Python dentro dese directorio.
Agora pasaremos á instalación Frasco(empregarémolo para crear os puntos finais para probar a carga) e gafanhoto si.
Para instalar Flask, executa. Asegúrate de estar no proxecto onde creaches un ambiente virtual.
matraz de instalación $ pip
Para instalar Locust, executa
$ pip instalar langosta
Unha vez feito isto, escriba os seguintes comandos. Asegúrate de estar no teu proxecto directorio cando fas isto.
$ copy nul __init__.py
aplicación $ mkdir
$ copy nul app\app.py
$ copiar a aplicación nula\__init__.py
Este comando crea algúns ficheiros que usaremos para crear os nosos puntos finais usando Flask. Tamén podes crear estes ficheiros usando o teu explorador de ficheiros. Pero que é a diversión niso? Unha vez feito isto, copie o seguinte código aplicación.py
from flask import Flask, jsonify, request
aplicación = Frasco (__nome__)
modelos_de_coches = [
{ 'marca': 'Tesla', 'modelo': 'Modelo S'}
]
plano_modelos = [
{'marca': 'Boeing', 'modelo': '747'}
]
@app.route('/coches')
def get_cars():
devolver jsonify(modelos_de_coches)
@app.route('/planes')
def get_planes():
devolver jsonify(plane_models)
if __name__ == '__main__':
app.run(debug=Verdadero)
O código anterior contén un método conseguir_coches usado para obter unha lista de marcas de coches e os seus modelos, e get_planes usado para obter unha lista de marcas de avións e os seus modelos. Para que poidamos probar a carga deste punto final, necesitamos executar app.py. Para iso, execute o seguinte comando.
$ ruta de python\a\app.py
Unha vez que o executes, deberías ver algo como isto:
Se copias o URL do terminal e escribes coches or avións despois do /, deberías poder ver os datos alí. Non obstante, o noso obxectivo é probar o punto final con locust, non co navegador. Entón imos facelo. Executa o seguinte comando na raíz do teu proxecto directorio.
$ copy nul locust_test.py
Isto crea un ficheiro 'locust_test.py' na raíz do teu ficheiro proxecto directorio. Unha vez feito isto, abre o ficheiro e pega o seguinte código. Explicarémolo en breve.
tempo de importación
de importación de langosta HttpUser, tarefa, entre
clase UserBehaviour(HttpUser):
tempo_espera = entre (5, 10)
@tarefa
def get_cars(self):
self.client.get('/coches')
@tarefa
def get_planes(self):
self.client.get('/planes')
Este é un exemplo básico de uso de Locust para probar a carga dunha API. En primeiro lugar, creamos unha clase Comportamento do usuario, ao que se lle pode dar calquera nome apropiado pero que debe ampliar HttpUser. HttpUser é a clase que se encarga de instanciar varios usuarios virtuais para realizar as tarefas que especificamos no Comportamento do usuario clase.
Unha tarefa especifícase decorando un método co @tarefa decorador. Tamén temos unha función chamada entre () que nos permite especificar un intervalo de segundos para esperar antes de executar a seguinte tarefa. Podes ver que no noso código asignamos un intervalo de 5 a 10 segundos para iso.
Para executar o código, asegúrate de estar aínda no teu ambiente virtual. Se o que creaches está a ser usado polo servidor que serve a API, abre un novo terminal, cambia o teu directorio ao teu proxecto directorio e active o ambiente virtual que creou. Podes atopar o comando para activar un ambiente virtual arriba. Agora, introduza o seguinte comando no seu terminal.
$ locust -f locust_test.py
Debería ver algo así:
De forma predeterminada, a interface web de locust está situada en http://localhost/8089. Se visitas o sitio web, deberías ver unha interface como esta:
Desde a interface, podemos especificar o número de usuarios, a taxa de aparición (usuarios creados por segundo) e o Host. Podes obter o enderezo do teu servidor comprobando o terminal onde se está a executar o servidor. No noso caso, está no porto 5000. Cando fai clic en Comeza a pulular, presentarase a seguinte interface.
Isto móstrache varias métricas útiles, como o número de solicitudes erradas, o tempo medio dunha solicitude, o tempo mínimo para unha solicitude, as solicitudes por segundo, etc. Unha vez que estea satisfeito co que ve, pode facer clic no botón de parar.
Ademais do Estatística ficha, hai un Charts pestana que mostra máis información en forma de gráfico, como a imaxe de abaixo.
hai un Total de solicitudes por segundo gráfico, gráfico de tempo de resposta, gráfico de número de usuarios, todo trazado contra o tempo. Usando os gráficos, pode determinar cantos usuarios son aceptables para un tempo de resposta fixo, ou pode observar os seus gráficos para un tempo de resposta constante a pesar dun número crecente de usuarios, e outras informacións como esa. Se queres compartir estes Estatísticas con outra persoa, podes descargar un informe desde o Descarga de datos Tab
Concluír...
A proba de carga da túa API é unha actividade crucial no teu proceso de desenvolvemento, así que asegúrate de que se incorpore ao teu ciclo de deseño. Por certo, tamén podes realizar outros tipos de probas de carga variando os valores do número de usuarios e da taxa de aparición.
Se queres facer unha proba de picos, especifique un valor grande (por exemplo 2000) para o número de usuarios e, a continuación, un valor igualmente grande para a túa taxa de aparición (500 por exemplo). Isto significa que en 4 segundos, terías os 2000 usuarios creados e accedendo aos teus puntos finais. Unha proba de esforzo será similar, pero cun valor moito menor para a taxa de desova. Para saber todo o que podes facer, consulta o Locust documentación.
