Golang Learning Pratique de test de performance des applications Web

Golang Learning Web Application Performance Testing Practice

Avec le développement de l'ère Internet, l'importance des applications Web est devenue de plus en plus importante. Les applications Web dans les environnements de production doivent avoir des performances élevées et des capacités de concurrence élevées pour satisfaire les besoins des utilisateurs. Si vous souhaitez garantir les hautes performances et la haute simultanéité des applications Web, vous devez effectuer des tests de performances.

Cet article expliquera comment utiliser le langage Go pour effectuer des tests de performances d'applications Web et fournir aux lecteurs une expérience pratique.

1. Préparation

Tout d'abord, nous devons installer l'environnement de développement du langage Go et certains frameworks couramment utilisés pour ce type de développement d'applications. Il est recommandé d'utiliser le framework Gin pour le développement d'applications Web.

Après avoir installé l'environnement de langage Go et le framework Gin, nous devons installer certains outils de test de performances, parmi lesquels ceux couramment utilisés incluent ApacheBench (ab), wrk, etc.

2. Test de performances

Avant d'utiliser l'outil de test de performances, nous devons d'abord démarrer notre application Web. Voici un exemple de code pour une application Web créée à l'aide du framework Gin :

package main

import "github.com/gin-gonic/gin"

func main() {
    r := gin.Default()
    r.GET("/hello", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "message": "Hello world!",
        })
    })
    r.Run() // listen and serve on 0.0.0.0:8080
}

Cette application Web simple fournit uniquement une méthode GET pour renvoyer les informations "Bonjour tout le monde !"

Ensuite, nous pouvons utiliser l'outil ApacheBench pour effectuer des tests de performances. ApacheBench est un outil développé par Apache Software Foundation pour tester rapidement et facilement les serveurs Web. Sous la ligne de commande, nous pouvons utiliser la commande suivante pour tester :

ab -n 1000 -c 100 http://localhost:8080/hello

Parmi elles, -n représente le nombre de requêtes, -c représente le nombre de simultanéités, et http://localhost:8080/hello est l'adresse de notre application Web.

Après avoir exécuté cette commande, nous pouvons voir qu'ApacheBench affichera les résultats suivants :

Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /hello
Document Length:        26 bytes

Concurrency Level:      100
Time taken for tests:   0.431 seconds
Complete requests:      1000
Failed requests:        0
Total transferred:      190000 bytes
HTML transferred:       26000 bytes
Requests per second:    2321.25 [#/sec] (mean)
Time per request:       43.128 [ms] (mean)
Time per request:       0.431 [ms] (mean, across all concurrent requests)
Transfer rate:          431.51 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.2      0       2
Processing:     8   42  11.1     40      71
Waiting:        8   42  10.8     40      71
Total:          8   42  11.1     40      72

Percentage of the requests served within a certain time (ms)
  50%     40
  66%     49
  75%     53
  80%     55
  90%     60
  95%     68
  98%     71
  99%     72
 100%     72 (longest request)

Parmi eux, la signification de chaque indicateur est la suivante :

• Logiciel serveur : Le nom du logiciel du serveur.
• Nom d'hôte du serveur : le nom d'hôte du serveur.
• Port du serveur : le numéro de port du serveur.
• Chemin du document : le chemin du document demandé.
• Longueur du document : La longueur du document demandée.
• Niveau de concurrence : nombre de concurrence.
• Temps pris pour les tests : Temps pris pour les tests.
• Demandes complètes : Nombre de demandes complétées.
• Demandes ayant échoué : nombre de demandes ayant échoué.
• Total transféré : la quantité de données transférées.
• HTML transféré : la quantité de données HTML transférées.
• Requêtes par seconde : Nombre de requêtes par seconde.
• Temps par demande : Le temps passé sur chaque demande.
• Durée par requête : le temps moyen pris par chaque requête (y compris toutes les requêtes simultanées).
• Taux de transfert : taux de transfert.

Parmi eux, l'indicateur le plus important est le nombre de requêtes par seconde. Il représente la puissance de traitement du serveur, et plus elle est élevée, meilleures sont les performances du serveur. Dans le même temps, le temps par demande (temps pris pour chaque demande) et le temps par demande (temps moyen pris pour chaque demande) sont également des indicateurs très importants. Ils représentent les performances de traitement d'une seule demande, c'est-à-dire la vitesse de réponse de. le serveur. Plus il est faible, plus le serveur est lent, meilleures sont les performances.

En plus d'ApacheBench, nous pouvons également utiliser l'outil wrk pour effectuer des tests de performances des applications Web. wrk est un outil de test de référence HTTP moderne présentant les avantages d'une concurrence élevée et de hautes performances.

Encore une fois, nous devons d'abord démarrer notre application Web. Sous la ligne de commande, nous pouvons utiliser la commande suivante pour tester :

wrk -t 4 -c 1000 -d 10s http://localhost:8080/hello

Parmi elles, -t représente le nombre de threads, -c représente le nombre de simultanéités, -d représente la durée du test, http://localhost:8080 /hello est notre application web L'adresse du programme.

Après avoir exécuté cette commande, nous pouvons voir que wrk affichera les résultats suivants :

Running 10s test @ http://localhost:8080/hello
  4 threads and 1000 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency     4.97ms   51.05us   5.57ms   78.15%
    Req/Sec    50.73k     2.10k   54.41k    79.00%
  2034638 requests in 10.00s, 381.47MB read
  Socket errors: connect 748, read 1969, write 0, timeout 0
Requests/sec: 203513.06
Transfer/sec:     38.14MB

Parmi eux, la signification de chaque indicateur est la suivante :

• Statistiques du fil : informations sur les statistiques du fil.
• Latence : Latence de traitement.
• Req/Sec : Nombre de requêtes par seconde.
• requêtes en 10h00 : Nombre de requêtes en 10 secondes.
• Mo de lecture : la quantité de données lues.
• Requêtes/sec : nombre de requêtes par seconde.
• Transfert/sec : taux de transfert.

De même, les requêtes/s (nombre de requêtes par seconde) et la latence (délai de traitement) sont les indicateurs les plus importants. Parmi eux, les requêtes/s (nombre de requêtes par seconde) sont également un indicateur important pour mesurer les performances du serveur.

3. Résumé

Cet article présente comment utiliser le langage Go pour tester les performances des applications Web, y compris les méthodes et les précautions pour les tests de performances à l'aide d'ApacheBench et de wrk. Lors des tests de performances, nous devons prêter attention à la configuration matérielle et logicielle de l'environnement de test, ainsi qu'aux paramètres et à l'interprétation des résultats pendant le processus de test. Dans le même temps, dans la pratique, nous devons également effectuer des tests de performances basés sur différents besoins et scénarios commerciaux afin d'améliorer les performances et la fiabilité des applications Web.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!