Menu

Qu'est-ce que le test d'évolutivité? Comment tester l'évolutivité d'une application

  • Principal
  • Autre
  • Qu'est-ce que le test d'évolutivité? Comment tester l'évolutivité d'une application

what is scalability testing

Essayez Notre Instrument Pour Éliminer Les Problèmes

Introduction aux tests d'évolutivité:

Le test d'évolutivité est une méthodologie de test non fonctionnelle dans laquelle les performances d'une application sont mesurées en termes de capacité à augmenter ou réduire le nombre de demandes des utilisateurs ou d'autres attributs de mesure des performances.

Les tests d'évolutivité peuvent être effectués au niveau du matériel, des logiciels ou de la base de données.

Les paramètres utilisés pour ce test diffèrent d'une application à l'autre, pour une page Web, cela pourrait être le nombre d'utilisateurs, l'utilisation du processeur, l'utilisation du réseau, tandis que pour un serveur Web, ce serait le nombre de requêtes traitées.

Test d

Ce tutoriel vous donnera un aperçu complet de Test d'évolutivité avec ses attributs et les différentes étapes impliquées dans l'exécution du test avec des exemples pratiques pour vous permettre de mieux comprendre le concept.

Ce que vous apprendrez:

Test d'évolutivité vs test de charge

Le test de charge mesure l'application testée sous une charge maximale à laquelle le système tomberait en panne. Le but principal des tests de charge est d'identifier le point de crête après lequel les utilisateurs ne pourraient pas utiliser le système.

comment démarrer les tests d'automatisation à partir de zéro

La charge et l'évolutivité relèvent de la méthodologie de test de performance.

L'évolutivité diffère du test de charge en ce que le test d'évolutivité mesure le système aux charges minimales et maximales à tous les niveaux, y compris les niveaux logiciel, matériel et base de données. Une fois la charge maximale déterminée, les développeurs doivent réagir de manière appropriée pour s'assurer que le système est évolutif après une charge particulière.

Exemple: Si les tests d'évolutivité déterminent que la charge maximale est de 10000 utilisateurs, alors pour que le système soit évolutif, les développeurs doivent prendre des mesures sur des facteurs tels que la diminution du temps de réponse après que la limite de 10000 utilisateurs est atteinte ou l'augmentation de la taille de la RAM pour accueillir les données utilisateur croissantes.

Les tests de charge consistent à placer une charge maximale sur les applications développées en une seule fois, tandis que les tests d'évolutivité impliquent d'augmenter progressivement la charge sur une période de temps.

Les tests de charge déterminent le point auquel l'application se bloque, tandis que l'évolutivité tente d'identifier la raison du plantage de l'application et de prendre des mesures pour résoudre le problème.

En bref, les tests de charge aident à identifier les problèmes de performances tandis que les tests d'évolutivité aident à déterminer si le système peut s'adapter au nombre croissant d'utilisateurs.

Attributs de test d'évolutivité

Les attributs de test d'évolutivité définissent les mesures de performance sur la base desquelles ce test sera effectué.

Voici quelques-uns des attributs communs:

1) temps de réponse:

  • Le temps de réponse est le temps entre la demande de l'utilisateur et la réponse de l'application. Ce test est effectué pour identifier le temps de réponse du serveur sous une charge minimale, une charge seuil et une charge maximale afin d'identifier le point auquel l'application se briserait.
  • Le temps de réponse peut augmenter ou diminuer en fonction de la charge utilisateur variable sur l'application. Idéalement, le temps de réponse d'une application diminuerait à mesure que la charge utilisateur ne cesse d'augmenter.
  • Une application peut être considérée comme évolutive si elle peut fournir le même temps de réponse pour différents niveaux de charge utilisateur.
  • Dans le cas d'environnements en cluster où la charge d'application est répartie entre plusieurs composants de serveur, les tests d'évolutivité doivent mesurer dans quelle mesure l'équilibreur de charge répartit la charge entre plusieurs serveurs. Cela garantira qu'un serveur n'est pas surchargé de demandes pendant que l'autre serveur est inactif en attendant qu'une demande arrive.
  • Le temps de réponse de chaque composant serveur doit être soigneusement mesuré si l'application est hébergée dans un environnement en cluster et les tests d'évolutivité doivent s'assurer que le temps de réponse de chaque composant serveur doit être le même quelle que soit la quantité de charge placée sur chaque serveur.
  • Exemple: Le temps de réponse peut être mesuré comme l'heure à laquelle l'utilisateur entre l'URL sur un navigateur Web à l'heure à laquelle la page Web prend pour charger le contenu. Moins le temps de réponse serait élevé, plus les performances d'une application seraient élevées.

2) Débit:

  • Le débit est la mesure d'un nombre de demandes traitées sur une unité de temps par l'application.
  • Le résultat du débit peut différer d'une application à l'autre. S'il s'agit d'une application Web, le débit est mesuré en termes de nombre de requêtes utilisateur traitées par unité de temps et s'il s'agit d'une base de données. le débit est mesuré en termes de nombre de requêtes traitées en unité de temps.
  • Une application est considérée comme évolutive si elle peut fournir le même débit pour différents niveaux de charge sur les applications internes, le matériel et la base de données.

3) Utilisation du processeur:

  • L'utilisation du processeur est une mesure de l'utilisation du processeur pour exécuter une tâche par une application. L'utilisation du processeur est généralement mesurée en termes de l'unité MegaHertz.
  • Idéalement, plus le code d'application est optimisé, moins l'utilisation du processeur observée sera faible.
  • Pour ce faire, de nombreuses organisations utilisent des pratiques de programmation standard pour minimiser l'utilisation du processeur.
  • Exemple: Suppression du code mort dans l'application et minimisation de l'utilisation de Thread. Les méthodes de mise en veille sont l'une des meilleures pratiques de programmation pour minimiser l'utilisation du processeur.

4) Utilisation de la mémoire:

  • L'utilisation de la mémoire est une mesure de la mémoire consommée pour exécuter une tâche par une application.
  • Idéalement, la mémoire est mesurée en termes d'octets (MegaBytes, GigaBytes ou Tera Bytes) que l'application développée utilise pour accéder à la mémoire vive (RAM).
  • L'utilisation de la mémoire d'une application peut être minimisée en suivant les meilleures pratiques de programmation.
  • Des exemples de bonnes pratiques de programmation seraient de ne pas utiliser de boucles redondantes, de réduire les accès à la base de données, d'utiliser le cache, d'optimiser l'utilisation des requêtes SQL, etc. Une application est réputée évolutive si elle minimise l'utilisation de la mémoire pour le plus possible.
  • Exemple: Si l'espace de stockage disponible pour un nombre spécifié d'utilisateurs est à court de mémoire, le développeur sera obligé d'ajouter un stockage de base de données supplémentaire pour compenser la perte de données.

5) Utilisation du réseau:

  • L'utilisation du réseau est la quantité de bande passante consommée par une application testée.
  • L'objectif de l'utilisation du réseau est de réduire la congestion du réseau. L'utilisation du réseau est mesurée en termes d'octets reçus par seconde, de trames reçues par seconde, de segments reçus et envoyés par seconde, etc.
  • Les techniques de programmation telles que l'utilisation de techniques de compression peuvent aider à réduire la congestion et à minimiser l'utilisation du réseau. Une application est considérée comme évolutive si elle peut fonctionner avec une congestion minimale du réseau et fournir des performances d'application élevées.
  • Exemple: Au lieu de suivre un mécanisme de file d'attente pour traiter les demandes des utilisateurs, un développeur peut écrire le code pour traiter les demandes des utilisateurs au fur et à mesure que la demande arrive dans une base de données.

En dehors de ces paramètres, il existe peu d'autres paramètres moins utilisés tels que le temps de réponse de la demande du serveur, le temps d'exécution de la tâche, le temps de transaction, le temps de chargement de la page Web, le temps de récupérer la réponse de la base de données, le temps de redémarrage, le temps d'impression, le temps de session, la transition d'écran , transactions par seconde, hits par seconde, requêtes par seconde, etc.

Les attributs des tests d'évolutivité peuvent différer d'une application à une autre car la mesure des performances des applications Web peut ne pas être la même que celle d'un ordinateur de bureau ou d'une application client-serveur.

Étapes pour tester l'évolutivité d'une application

Le principal avantage de réaliser ces tests sur une application est de comprendre le comportement de l'utilisateur lorsque la charge maximale est atteinte et les moyens de la résoudre.

En outre, ces tests permettent aux testeurs d'identifier la dégradation côté serveur et le temps de réponse par rapport à la charge utilisateur de l'application. En conséquence, ce test est préféré dans plusieurs organisations à travers le monde.

Vous trouverez ci-dessous la liste des étapes pour tester l'évolutivité d'une application:

  • Créez des scénarios de test répétables pour chacun des attributs de test d'évolutivité.
  • Testez l'application pour différents niveaux de charge tels que des charges faibles, moyennes et élevées et vérifiez le comportement d'une application.
  • Créez un environnement de test suffisamment stable pour résister à l'ensemble du cycle de test d'évolutivité.
  • Configurez le matériel nécessaire pour effectuer ce test.
  • Définissez un ensemble d'utilisateurs virtuels pour vérifier le comportement d'une application sous une charge utilisateur variable.
  • Répétez les scénarios de test pour plusieurs utilisateurs dans des conditions variables d'applications internes, de modifications du matériel et de la base de données.
  • Dans le cas d'un environnement en cluster, vérifiez si l'équilibreur de charge dirige les requêtes utilisateur vers plusieurs serveurs pour vous assurer qu'aucun serveur n'est surchargé par une série de requêtes.
  • Exécutez les scénarios de test dans l'environnement de test.
  • Analysez les rapports générés et vérifiez les domaines d'amélioration, le cas échéant.

Conclusion

En un mot,

=> Le test d'évolutivité est une méthodologie de test non fonctionnelle pour vérifier si une application peut évoluer vers le haut ou vers le bas aux différents attributs. Les attributs utilisés pour ce test varieront d'une application à l'autre.

=> L'objectif principal de ce test est de déterminer quand une application commence à se dégrader à une charge maximale et de prendre les mesures appropriées pour s'assurer que l'application développée est suffisamment évolutive pour s'adapter aux changements dans les applications internes, les logiciels, le matériel et aussi la base de données changements dans le futur.

=> Si ce test est effectué correctement, des erreurs majeures concernant les performances du logiciel, du matériel et de la base de données peuvent être découvertes dans les applications développées.

=> Un inconvénient majeur de ce test serait sa limitation de stockage des données, avec des limites sur la taille de la base de données et l'espace tampon. En outre, les limitations de bande passante du réseau peuvent être un obstacle aux tests d'évolutivité.

=> Le processus de test d'évolutivité diffère d'une organisation à une autre car les attributs de test d'évolutivité d'une application seront différents des autres applications.

comment exécuter des fichiers .jar sur Windows 10

lecture recommandée

^