Ddosify : outil de test de charge haute performance, QAInsights

Il existe plus de 50 outils et solutions disponibles sur le marché pour tester les performances de votre application et de vos services. Il est maintenant temps de découvrir Ddosify, un outil de test de charge hautes performances qui offre des fonctionnalités gratuites et commerciales pour tester les applications et services Web sur HTTP(S), HTTP/2 et d’autres protocoles sont en route. Dans cet article de blog, examinons en profondeur l’outil Ddosify et voyons s’il satisfait ou non un ingénieur de performance typique.

Avant de voir Ddosify, essayons de comprendre le nom de l’outil. Ddosify contient Ddos terme. DDoS signifie déni de service distribué. Vous trouverez ci-dessous l’entrée Wikipedia pour le déni de service :

En informatique, une attaque par déni de service est une cyberattaque dans laquelle l’auteur cherche à rendre une machine ou une ressource réseau indisponible pour ses utilisateurs prévus en perturbant temporairement ou indéfiniment les services d’un hôte connecté à Internet..

Un attaquant cible une machine et tente de perturber ses services. Le terme distribué signifie Plusieurs sources. Au lieu d’attaquer un système à partir d’une seule source, l’attaquant utilise plusieurs sources.

Si vous essayez d’adapter le DDoS capacités de bonne intention, vous obtiendrez Ddosify.

Qu’est-ce que Ddosify?

Ddosify est un outil de test de charge haute performance écrit en Golang. Il existe en deux versions : open-source et commerciale.

Il prend en charge les protocoles HTTP(S), HTTP/2 (à partir de maintenant) ; d’autres protocoles sont en cours.
Prise en charge de JSON pour la création de scénarios.
Prend en charge divers modèles de charge de travail.

Commencer

Comme Ddosify est basé sur Golang, la condition préalable est d’installer la version la plus récente et la plus stable de Golang si vous souhaitez créer à partir des sources. Sinon, vous pouvez télécharger les binaires pour commencer. Rendez-vous sur https://golang.org/dl/ pour installer le Golang.

Pour installer Ddosify, vous pouvez utiliser Docker ou l’installer à partir de la source.

docker run -it --rm ddosify/ddosify

go install -v go.ddosify.com/[email protected]

Après une installation réussie, vous pouvez vérifier Ddosify en exécutant la commande ci-dessous.

ddosify -version

Démarrage rapide

Commençons un test de charge rapide, ciblant l’application de démonstration. J’exécute un exemple d’application Jetty localement sur le port 8080. Pour commencer les tests à l’aide de Ddosify, vous pouvez exécuter la commande ci-dessous.

ddosify -t http://localhost:8080/test/hello

La commande ci-dessus envoie 100 requêtes en 10 secondes. Ci-dessous la sortie. Pendant le test, Ddosify affiche l’état d’exécution. Une fois le test terminé, il affichera les résultats avec le DNS, la connexion, l’écriture de la demande, le traitement du serveur, le temps de lecture de la réponse et le temps total en secondes.

Pour terminer le test, vous pouvez appuyer sur Ctrl + C.

Ddosify : Outil de test de charge haute performance

Conception de scénario

Concevons maintenant un scénario rapide pour tester l’application de démonstration en JSON. Copiez et collez le JSON ci-dessous et enregistrez-le sous config.json.

Pour lancer le test, lancez ddosify -config .config.json.

{ "request_count": 20, "load_type": "linear", "duration": 5, "output": "stdout", "steps": [ { "id": 1, "url": "http://localhost:8080/test/session/", "protocol": "http", "method": "POST", "headers": { "ContenType": "application/xml", "header1": "header2" }, "payload": "Name=test&Value=test&Action=Set", "timeout": 3, "others": { "keep-alive": true, "disableCompression": false, "h2": true, "disable-redirect": true } } ] }

Le scénario ci-dessus lance 20 requêtes (itérations) sur une période de 5 secondes. Ci-dessous la sortie.

Ddosify : Outil de test de charge haute performance

Vous trouverez ci-dessous les différents drapeaux disponibles pour Ddosify au moment de la rédaction.

DRAPEAU	LA DESCRIPTION	TAPER	DÉFAUT	OBLIGATOIRE?
`-t`	URL du site Web cible. Exemple : https://ddosify.com	`string`	–	Oui
`-n`	Nombre total de demandes	`int`	`100`	Non
`-d`	Durée du test en secondes.	`int`	`10`	Non
`-p`	Protocole de la demande. Les protocoles pris en charge sont HTTP, HTTPS. La prise en charge HTTP/2 n’est disponible qu’en utilisant un fichier de configuration comme décrit. D’autres protocoles seront ajoutés.	`string`	`HTTPS`	Non
`-m`	Méthode de demande. Les méthodes disponibles pour HTTP(s) sont OBTENIR, POSTER, METTRE, SUPPRIMER, METTRE À JOUR, CORRIGER	`string`	`GET`	Non
`-b`	La charge utile du paquet réseau. Corps AKA pour le HTTP.	`string`	–	Non
`-a`	Authentification de base. Usage: `-a username:password`	`string`	–	Non
`-h`	En-têtes de la demande. Vous pouvez fournir plusieurs en-têtes avec plusieurs `-h` drapeau.	`string`	–	Non
`-T`	Délai d’expiration de la demande en secondes.	`int`	`5`	Non
`-P`	Adresse proxy en tant qu’hôte:port. `-P http://user:pass@proxy_host.com:port'`	`string`	–	Non
`-o`	Destination de sortie des résultats du test. D’autres types de sortie seront ajoutés.	`string`	`stdout`	Non
`-l`	Type de test de charge. Ddosify prend en charge 3 types de charges.	`string`	`linear`	Non
`-config`	Fichier de configuration du test de charge.	`string`	–	Non
`-version`	Affiche la version, git commit, date de construction (utc), go information et quitte	–	–	Non

Ddosifier les drapeaux

Modèles de charge de travail

À l’heure actuelle, Ddosify prend en charge trois modèles de charge de travail : linéaire, incrémentiel et ondulé.

Linéaire aide à injecter la charge de manière cohérente sur une période de temps.
Incrémentale injecte la charge en augmentant progressivement.
Les vague modèle injecte la charge comme des pics et des vallées.

Combien de demandes pouvez-vous envoyer depuis votre système ?

Déterminer le nombre de requêtes que vous pouvez générer sur le système dépend uniquement du processeur, de la mémoire et d’autres paramètres. Vous devez effectuer des tests de référence et conclure vos résultats.

J’ai deux cœurs avec 16 Go de RAM. Golang est basé sur un thread léger géré par le runtime Go appelé goroutines. Le golang a une meilleure simultanéité que les autres langues. Vous pouvez facilement lancer des centaines de threads en utilisant un minimum de ressources.

J’ai exécuté un test avec 10000 requêtes. Comme vous le voyez, la charge est proportionnelle au temps.

Test de charge élevée

Lorsque j’ai injecté 10000000, j’ai observé un processeur et une mémoire élevés sur ddosify.exe et le test a pris beaucoup de temps. Je dois terminer le fichier exe. Ce n’est pas un problème DDosify, c’est ma configuration système. J’ai une configuration sous-alimentée qui ne peut pas être utile pour exécuter une charge très élevée.

Globalement

Ddosify peut être une bonne solution si vous souhaitez exécuter rapidement une charge très élevée avec une configuration minimale. Il n’en est qu’à ses débuts, et de nombreuses fonctionnalités manquent (paramétrage, actions logiques, scripts pour n’en citer que quelques-uns). La version commerciale n’est pas encore sortie. Je suis sur liste d’attente. J’espère que l’équipe Ddosify développera les fonctionnalités qui satisferont éventuellement les ingénieurs de performance typiques. Je vous invite à essayer Ddosify pour ddosifier votre application.