Skip to main content

ApacheBench (ab): Simple HTTP Server Benchmarking

ApacheBench (ab) is a single-threaded command-line tool for benchmarking HTTP servers. Originally designed for testing the Apache HTTP Server, it can be used to benchmark any web server. It's a simple and straightforward tool for basic load testing and performance measurement.

Key Features​

  • Simple Command-Line Interface: Easy to use with a straightforward command syntax.
  • Concurrent Requests: Simulates multiple concurrent users making requests to the server.
  • Customizable Requests: Allows customization of HTTP requests, including headers and body data.
  • Performance Metrics: Provides key performance metrics such as requests per second, time per request, and transfer rate.
  • Wide Availability: Comes pre-installed on many Linux distributions and is available for other operating systems.

Use Cases​

  • Basic Load Testing: Simulating a certain number of concurrent users.
  • Performance Measurement: Measuring the requests per second and response times of a web server.
  • Identify Bottlenecks: Identifying performance bottlenecks in the server or application.
  • Comparing Server Configurations: Comparing the performance of different server or application configurations.
  • Simple API Benchmarks: Testing the throughput and response times of simple APIs.

Getting Started​

ab typically comes pre-installed on many Linux systems. If not, install the apache2-utils package:

# Debian/Ubuntu
sudo apt-get install apache2-utils

# CentOS/RHEL
sudo yum install httpd-tools

# macOS (using Homebrew)
brew install apache2

Basic Usage​

The basic syntax for ab is:

ab [options] [url]

For Example

ab -n 1000 -c 10 http://localhost/

This command sends 1000 requests to http://localhost/ with a concurrency of 10 (i.e., 10 concurrent requests).

Important Options​

  • -n requests: The total number of requests to perform.
  • -c concurrency: The number of multiple requests to make at a time (number of concurrent users).
  • -t timelimit: Maximum seconds to spend on benchmarking. This supersedes -n. Use this instead of -n for time-bound tests instead of request-bound tests.
  • -p postfile: File containing data to POST. Remember also to set -T.
  • -T content-type: Content-type header for POST data.
  • -k: Enable HTTP KeepAlive feature, i.e., perform multiple requests within one HTTP session.
  • -H attribute: Add arbitrary header line, such as 'Accept-Encoding: gzip'
  • -v verbosity: How much troubleshooting info to print. Values are 1..3
  • -g filename: Output all results to gnuplot format file.
  • -i: Use HEAD instead of GET.
  • -x attributes: Proxy Server attributes; See below for syntax.
  • -y attributes: Proxy Authentication attributes; See below for syntax.
  • -z attributes: TLS ciphersuite (SSL/TLS only). See openssl ciphers for valid ciphers.
  • -C attribute: Add a cookie line to the request. Typically of the form 'name=value' [repeatable]
  • -X proxy[:port]: Use proxy server for request.
  • -V: Show version number and exit.
  • -w: Print results in HTML tables.
  • -q: Do not show progress when doing more than 150 requests
  • -d: Do not show percentiles served table.
  • -S: Do not show confidence estimators and warnings.
  • -e filename: Output CSV file with percentages served
  • -r: Don't exit on socket receive errors.
  • -Z ciphersuite: Specify SSL/TLS cipher suite (OpenSSL format).
  • -f protocol: Specify SSL/TLS protocol (SSL2, SSL3, TLS1, TLS1.1, TLS1.2, TLS1.3).
  • -E certificate: Specify client SSL/TLS certificate file.
  • -A username:password: Provide HTTP Basic authentication credentials.
  • -P username:password: Provide proxy authentication credentials.

Interpreting Results​

ab provides a detailed output with various metrics. Here are some of the key metrics and their interpretation:

  • Requests per second: The number of requests the server can handle per second. Higher is better. This is a key performance indicator.
  • Time per request: The average time it takes for the server to respond to a request (in milliseconds). Lower is better.
  • Time per request (across all concurrent requests): The average time it takes for the server to respond to a request, taking into account concurrency.
  • Transfer rate: The amount of data transferred per second (in kilobytes). Indicates the server's throughput capacity.
  • Percentage of requests served within a certain time (ms): This shows the distribution of response times, helping identify latency issues.

Examples​

  1. Basic Benchmark with 1000 requests and concurrency of 10:

    ab -n 1000 -c 10 http://localhost/

  2. Benchmark with a maximum time of 30 seconds:

ab -t 30 -c 10 http://localhost/

  1. Sending a POST request with data from a file:

    ab -n 100 -c 10 -p data.txt -T "application/json" http://localhost/api/endpoint

  2. Adding a custom header:

    ab -n 100 -c 10 -H "Accept-Encoding: gzip" http://localhost/

  3. Using KeepAlive:

    ab -n 1000 -c 10 -k http://localhost/

  4. Output results in a table

    ab -n 1000 -c 10 -w http://localhost/

Considerations and Limitations​

  • Single-Threaded: ab is single-threaded, which can be a limitation when testing high-performance servers. It may not fully utilize multi-core systems. Prefer tools that support multithreading for more accurate simulation with high concurrency.
  • Not a Comprehensive Load Testing Tool: Limited in its capabilities compared to more advanced load testing tools.
  • Simple and Useful: Can be useful for quick, ad-hoc, and reproducible HTTP benchmarks on a local intranet.

Alternatives​

For more comprehensive load testing, consider using tools like:

  • JMeter: A powerful and flexible load testing tool with a GUI.
  • Gatling: A high-performance load testing tool written in Scala.
  • Locust: A Python-based load testing tool.
  • wrk: A modern HTTP benchmarking tool particularly good for concurrent tasks.

Summary​

ApacheBench (ab) is a simple and widely available tool for basic HTTP server benchmarking. It's useful for quick performance checks and identifying simple bottlenecks. However, for more comprehensive load testing and performance analysis, consider using more sophisticated tools.