Golang Learning Web Application Performance Testing Practice

Golang Learning Web Application Performance Testing Practice

With the development of the Internet era, the importance of Web applications has become more and more prominent. Web applications in production environments need to have high performance and high performance. Concurrency capabilities to meet user needs. If you want to ensure the high performance and high concurrency of web applications, you must conduct performance testing.

This article will introduce how to use Go language to perform performance testing of web applications and provide readers with some practical experience.

1. Preparation

First, we need to install the Go language development environment and some commonly used frameworks for this type of application development. It is recommended to use the Gin framework for web application development.

After installing the Go language environment and Gin framework, we need to install some performance testing tools, commonly used ones include ApacheBench (ab), wrk, etc.

2. Performance Test

Before using the performance testing tool, we need to start our web application. The following is a sample code for a web application built using the Gin framework:

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
}

This simple web application only provides a GET method for returning "Hello world!" information in JSON format.

Next, we can use the ApacheBench tool to conduct performance testing. ApacheBench is a tool developed by the Apache Software Foundation for quickly and easily stress testing web servers. Under the command line, we can use the following command to test:

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

Among them, -n represents the number of requests, -c represents the number of concurrency, http://localhost:8080/hello is the number of our web application address.

After executing this command, we can see that ApacheBench will output the following results:

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)

Among them, the meaning of each indicator is as follows:

• Server Software: The software name of the server.
• Server Hostname: The host name of the server.
• Server Port: The port number of the server.
• Document Path: The requested document path.
• Document Length: Requested document length.
• Concurrency Level: Number of concurrencies.
• Time taken for tests: Time taken for tests.
• Complete requests: Number of completed requests.
• Failed requests: Number of failed requests.
• Total transferred: The amount of data transferred.
• HTML transferred: The amount of HTML data transferred.
• Requests per second: Number of requests per second.
• Time per request: The time spent on each request.
• Time per request: The average time taken by each request (including all concurrent requests).
• Transfer rate: transfer rate.

Among them, the most important indicator is Requests per second. It represents the processing power of the server, and the higher it is, the better the performance of the server. At the same time, Time per request (time taken for each request) and Time per request (average time taken for each request) are also very important indicators. They represent the processing performance of a single request, that is, the response speed of the server. The lower it is, the slower the server is. The better the performance.

In addition to ApacheBench, we can also use the wrk tool to perform performance testing of web applications. wrk is a modern HTTP benchmark testing tool with the advantages of high concurrency and high performance.

Again, we need to start our web application first. Under the command line, we can use the following command to test:

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

Among them, -t represents the number of threads, -c represents the number of concurrency, and -d represents the test duration, http://localhost:8080/hello is the address of our web application.

After executing this command, we can see that wrk will output the following results:

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

Among them, the meaning of each indicator is as follows:

• Thread Stats: Thread statistics.
• Latency: Processing delay.
• Req/Sec: Number of requests per second.
• requests in 10.00s: Number of requests within 10 seconds.
• MB read: The amount of data read.
• Requests/sec: Number of requests per second.
• Transfer/sec: transfer rate.

Similarly, Requests/sec (number of requests per second) and Latency (processing delay) are the most important indicators. Among them, Requests/sec (number of requests per second) is also an important indicator for measuring server performance.

3. Summary

This article introduces how to use Go language for performance testing of web applications, including methods and precautions for performance testing using ApacheBench and wrk. When conducting performance testing, we need to pay attention to the hardware and software configuration of the test environment, as well as parameter settings and result interpretation during the test process. At the same time, in practice we also need to conduct performance testing based on different business needs and scenarios in order to improve the performance and reliability of web applications.

The above is the detailed content of Golang Learning Web Application Performance Testing Practice. For more information, please follow other related articles on the PHP Chinese website!