Evaluating website performance using Apache Bench

Introduction

Apache Bench, commonly abbreviated as ab, is a single-threaded command-line tool provided by the Apache HTTP Server project. It is designed to perform benchmarks on your Apache Hypertext Transfer Protocol (HTTP) server. Apache Bench measures how well your server can handle the load by simulating multiple requests to a server. This is known as stress testing or load testing. It is like a fire drill for your website, ensuring that your server can handle the onslaught when real traffic hits.

The importance of benchmarking

Imagine driving a car without a speedometer, tachometer, or fuel gauge. You’d be in the dark about how fast you’re going, how hard the engine is working, and how much gas you have left. Benchmarking your website is similar to using this tool. It provides you with vital performance readings. It helps you understand:

• Capacity: The number of visitors your site can handle before the user experience degrades.
• Stability: How your system performs under varying levels of traffic, especially sudden unexpected spikes.
• Bottlenecks: Which part of your system (e.g., database, server software, network) is limiting performance?.

Regular benchmarking isn’t just about keeping up with the numbers. It’s about ensuring that your website remains available, reliable, and fast, even under the most demanding conditions. By doing so, you’ll not only keep your current users happy, but you’ll also scale confidently as your user base grows.

Step 1 – Install Apache Bench

Before we start the benchmark, we need to make sure that Apache Bench (ab) is installed on your system. Apache Bench usually comes bundled with the Apache HTTP server, but it can be installed separately if you are not using Apache as your web server. Here is how to install Apache Bench on different operating systems:

• Debian-based distributions (Ubuntu, Debian) Apache Bench is part of the apache2-utils package. To install it, open your terminal and run the following command:

sudo apt-get update sudo apt-get install apache2-utils

• Red Hat-based distributions (Fedora, CentOS) On Red Hat-based systems, you can use yum or dnf (on Fedora) to install Apache Bench as follows:

sudo yum install httpd-tools

sudo dnf install httpd-tools

• Arch Linux For Arch Linux users, Apache Bench can be installed using pacman:

sudo pacman -S apache-tools

• Apache Bench comes pre-installed on many macOS systems. To check if it's already installed, open your terminal and type ab . If it's installed, you'll see information about using the command. If it's not installed or you want to update to the latest version, you can install it using Homebrew:

brew install homebrew/apache/ab

Step 2 – Setting up the test environment

Before you start benchmarking your web server with Apache Bench, it's crucial to create a controlled test environment. This ensures that your test results are as accurate and consistent as possible.

• Choosing a test server

Isolation: Choose a server environment that is isolated from production traffic to avoid interference with real users and achieve consistent results.

Iteration: Ensure that the test server reflects the production environment as closely as possible in terms of hardware, software, and network configuration.

• Network considerations

Bandwidth: Check that your network has enough bandwidth available. Network congestion can skew the results.

Latency: Consider the latency between the test client (where Apache Bench is running) and the test server. High latency can affect the accuracy of the connection time.

• Resource monitoring

Server resources: Set up monitoring of server resources (CPU, memory, disk I/O, network I/O) to identify potential bottlenecks during testing.

Baseline Performance: Record the server's baseline performance without load. This gives you a point of comparison for your benchmark results.

Step 3 – Identify benchmark goals

Clear objectives help guide your benchmarking process and enable you to interpret the results effectively. For example:

• Maximum Concurrent Users: Set the maximum number of users your server can have simultaneously without significantly reducing performance.
• Response time: Determine an acceptable response time for your web application under different loading conditions.
• Throughput: Decide on the throughput (requests per second) that your server should support.
• Peak traffic: Plan to test peak traffic scenarios to make sure your web server can handle high loads.

Step 4 – Understand the benchmark criteria

Apache Bench provides benchmarks that quantify the performance of your web server. Here's a breakdown of some of the key metrics you'll encounter:

• Throughput: The number of requests your server can handle per second. Higher values indicate better performance and the server's ability to handle more traffic.
• Time per request: The average time taken to process a single request. Lower values indicate faster response times and a more responsive server.
• Concurrent Requests: The number of requests sent to the server simultaneously. This metric helps understand how well the server is performing under concurrent load.
• Transfer rate: The amount of data transferred per second during the test. It indicates the server's capacity to deliver content. It is very important for bandwidth-intensive applications.
• Success/Error Rate: The ratio of successful requests to error responses (e.g., 404, 500). A high success rate is crucial for user satisfaction and reliability.

Understanding these metrics will help you interpret the results from Apache Bench and determine whether your server is meeting the performance goals you have set. Keep in mind that these metrics should be considered together, as they collectively provide a profile of your server's performance.

Step 5 – Run a simple test

To get started, open a terminal window. Select the URL you want to benchmark. This page should represent typical usage. For this example, we'll use http://example.com. To run a simple benchmark test, enter the following command:

ab -n 100 -c 10 http://example.com/

Document Path:          /
Document Length:        108 bytes

Concurrency Level:      10
Time taken for tests:   12.905 seconds
Complete requests:      100
Failed requests:        0
Non-2xx responses:      100
Total transferred:      29500 bytes
HTML transferred:       10800 bytes
Requests per second:    7.75 [#/sec] (mean)
Time per request:       1290.527 [ms] (mean)
Time per request:       129.053 [ms] (mean, across all concurrent requests)
Transfer rate:          2.23 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:      645  757 109.5    740    1401
Processing:   173  219 205.1    200    2246
Waiting:      172  218 205.1    196    2246
Total:        834  976 227.1    929    2939

Percentage of the requests served within a certain time (ms)
  50%    929
  66%    973
  75%    988
  80%    988
  90%   1022
  95%   1069
  98%   1622
  99%   2939
 100%   2939 (longest request)

ab -c <number_of_concurrent_users> http://example.com/

ab -c 100 http://example.com/

ab -t 600 http://example.com/

Example: Combining with concurrency to simulate a real-world scenario:

ab -c 100 -t 600 http://example.com/

Testing with different HTTP methods

Understanding HTTP methods

1. GET: This is the default method used to retrieve data from the server.
2. POST: Used to send data to a specified resource for processing.

How to test with POST method

1. Prepare data for submission: Create a file containing the data to be submitted.
2. Command: Use -p to specify your data file and the -T flag to set the content type.

Example:

ab -p postdata.txt -T application/x-www-form-urlencoded

Step 8 – Act on the result

After running Apache Bench, you can identify bottlenecks by looking for the following:

• High values for each request: This may indicate slow processing or server resource limitations.
• Low requests per second: This could indicate that your server is not optimized to effectively handle high traffic loads.
• Wide distribution in the percentage of requests served at given times: If many requests take significantly longer to serve, this could indicate inconsistent server performance.

So you can decide to increase server performance. For example:

• Server Configuration: Adjust settings based on performance. For example, you may need to change settings like KeepAlive or MaxClients.
• Scaling: Determine if your server hardware can handle your peak load or if you need to scale up or down.
• Optimization: Identify slow-performing scripts or database queries that need optimization.

Result

During this tutorial, you learned how to install Apache Bench, run basic and advanced benchmark tests, interpret the results, and make informed decisions to optimize your server performance. Benchmarking is an iterative process. Encourage yourself to constantly monitor your website performance and test different configurations. Stay informed about new optimization techniques and tools to keep your skills sharp and your website running smoothly. Remember, a well-performing website provides a better user experience, which can lead to increased user satisfaction and retention. Keep pushing the boundaries of your website performance.