How to load-test web server using ApacheBench (ab)

Load testing is essential to evaluate how a web server handles traffic under stress. ApacheBench, or ab, is a tool used to simulate HTTP requests to measure a server's performance. This helps in understanding key metrics like requests per second and latency.

ApacheBench is included in the Apache HTTP server package and is available on many UNIX-based systems. It allows you to adjust the number of requests and concurrency levels to test different server configurations. This helps identify performance bottlenecks and optimize server settings.

By using ApacheBench, you can run multiple tests to see how well your server manages varying loads. This ensures that the server is prepared for the expected traffic, whether it’s an Apache or another type of HTTP server.

Step-by-step video guide:

Steps to load-test web server using ab:

Verify that ApacheBench is installed on your system.

$ ab -V
This is ApacheBench, Version 2.3 <$Revision: 1843412 $>

Install apache2-utils if ab is not installed.

$ sudo apt update && sudo apt install --assume-yes apache2-utils # Ubuntu and Debian derivatives
$ sudo yum install --assumeyes httpd-tools # CentOS and RedHat derivatives

Get the URL of the web page you want to perform the load test against.
Execute a basic load test by sending multiple requests to the server.
```
$ ab -n 1000 -c 10 https://www.example.com/
```
Request format: ab -n <number_of_request> -c <concurrency>.
This is a basic example of performing a performance test which in this case is to send a total of 1000 requests to the web server with 10 requests being sent concurrently.

Make sure to add a (forward) slash (/) at the end of the URL otherwise it will not be recognised by the command

Analyze the output to review performance metrics.

$ ab -n 1000 -c 10  https://www.example.com/
This is ApacheBench, Version 2.3 <$Revision: 1826891 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking www.example.com (be patient)
Completed 100 requests
Completed 200 requests
Completed 300 requests
Completed 400 requests
Completed 500 requests
Completed 560 requests
Completed 610 requests
Completed 800 requests
Completed 900 requests
Completed 1000 requests
Finished 1000 requests


Server Software:        Apache/2.4.33
Server Hostname:        www.example.com
Server Port:            443

Document Path:          /
Document Length:        12906 bytes

Concurrency Level:      10
Time taken for tests:   19.070 seconds
Complete requests:      1000
Failed requests:        0
Total transferred:      13410000 bytes
HTML transferred:       12905610 bytes
Requests per second:    52.44 [#/sec] (mean)
Time per request:       190.704 [ms] (mean)
Time per request:       19.070 [ms] (mean, across all concurrent requests)
Transfer rate:          686.70 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.0      0       1
Processing:    73  190  41.2    186     348
Waiting:       72  188  41.2    185     346
Total:         73  190  41.2    186     348

Percentage of the requests served within a certain time (ms)
  50%    186
  66%    207
  75%    218
  80%    226
  90%    244
  95%    257
  98%    272
  99%    305
 100%    348 (longest request)

The key metrics to look at include Requests per second, Time per request, and possible Failed requests.

Adjust the concurrency level and the number of requests to test different scenarios.
Enable KeepAlive to reduce network overhead and improve performance.
```
$ ab -n 1000 -c 10 -k https://www.example.com/
```

Re-run the test after each adjustment to evaluate the server’s behavior.

Other options for ab:

$ ab -h
Usage: ab [options] [http[s]://]hostname[:port]/path
Options are:
    -n requests     Number of requests to perform
    -c concurrency  Number of multiple requests to make at a time
    -t timelimit    Seconds to max. to spend on benchmarking
                    This implies -n 50000
    -s timeout      Seconds to max. wait for each response
                    Default is 30 seconds
    -b windowsize   Size of TCP send/receive buffer, in bytes
    -B address      Address to bind to when making outgoing connections
    -p postfile     File containing data to POST. Remember also to set -T
    -u putfile      File containing data to PUT. Remember also to set -T
    -T content-type Content-type header to use for POST/PUT data, eg.
                    'application/x-www-form-urlencoded'
                    Default is 'text/plain'
    -v verbosity    How much troubleshooting info to print
    -w              Print out results in HTML tables
    -i              Use HEAD instead of GET
    -x attributes   String to insert as table attributes
    -y attributes   String to insert as tr attributes
    -z attributes   String to insert as td or th attributes
    -C attribute    Add cookie, eg. 'Apache=1234'. (repeatable)
    -H attribute    Add Arbitrary header line, eg. 'Accept-Encoding: gzip'
                    Inserted after all normal header lines. (repeatable)
    -A attribute    Add Basic WWW Authentication, the attributes
                    are a colon separated username and password.
    -P attribute    Add Basic Proxy Authentication, the attributes
                    are a colon separated username and password.
    -X proxy:port   Proxyserver and port number to use
    -V              Print version number and exit
    -k              Use HTTP KeepAlive feature
    -d              Do not show percentiles served table.
    -S              Do not show confidence estimators and warnings.
    -q              Do not show progress when doing more than 150 requests
    -l              Accept variable document length (use this for dynamic pages)
    -g filename     Output collected data to gnuplot format file.
    -e filename     Output CSV file with percentages served
    -r              Don't exit on socket receive errors.
    -m method       Method name
    -h              Display usage information (this message)
    -I              Disable TLS Server Name Indication (SNI) extension
    -Z ciphersuite  Specify SSL/TLS cipher suite (See openssl ciphers)
    -f protocol     Specify SSL/TLS protocol
                    (SSL2, TLS1, TLS1.1, TLS1.2 or ALL)
    -E certfile     Specify optional client certificate chain and private key

Review the results to identify and address performance issues.

Tips for load-testing web server using ab:

Run ApacheBench from a separate machine to avoid consuming server resources during the test.
Perform a few initial requests to warm up the server and ensure caching mechanisms are active.
Conduct load tests at different times of the day to assess performance under various conditions.
Monitor CPU, memory, and disk I/O during the test to identify hardware limitations.
Keep detailed records of test configurations to ensure reproducibility and accurate comparison.
Pay attention to long-running requests, as they may indicate server issues.
Start with lower loads and gradually increase them to find the server's breaking point.
Account for network latency, especially when testing servers in different geographic locations.
Test with and without SSL/TLS enabled to understand the impact of encryption on performance.
Repeat tests multiple times to ensure consistent results and avoid transient issues.

Author: Mohd Shakir Zakaria
Mohd Shakir Zakaria is an experienced cloud architect with a strong development and open-source advocacy background. He boasts multiple certifications in AWS, Red Hat, VMware, ITIL, and Linux, underscoring his expertise in cloud architecture and system administration.

Discuss the article:

Comment anonymously. Login not required.