Apache HTTP Server Load Test on a Small VPS: Method and Results
Publication Date:
Updated:
INFORMATION > Apache HTTP Server Load Test on a Small VPS: Method and Results
Bottom line: This article records one VPS experiment, not a universal Apache concurrency limit. Capacity depends on response work, MPM, worker limits, keep-alive, TLS, CPU, memory, storage, network, client placement, and the latency target you define as acceptable.
What you'll learn
- How the original test was arranged and what its observed numbers do—and do not—show.
- Which Apache and operating-system metrics help identify the first bottleneck.
- How to design a repeatable load test with warm-up, percentiles, errors, and server-side telemetry.
Who this is for: Engineers planning a first-pass web-server experiment on a small VPS.
2026 context: The measurements below are preserved from the author's original environment and were not rerun for this update. Do not use them as a current vendor benchmark or production sizing recommendation; test your own application and failure thresholds.
Overview
This historical test measures how many simultaneous requests one Apache server handled in the author’s environment. Treat the results as a case study, not as sizing guidance for a current VPS.
This test covers Apache HTTP Server only. The related Apache and Tomcat test adds an application-server workload.
Table of Contents
1. Test setup
1-1. Test environment
The following is the environment in which the measurements will be made.
■Rental Server Information
| CPU | 2core |
|---|---|
| memory | 1GB |
| SSD | 50GB |
■Server Information
| OS | CentOS 7.4 64bit |
|---|---|
| WEB Server | Apache HTTP Server 2.4.41 |
1-2. Test method
The test uses JMeter, a Java load-testing tool, to increase the number of simultaneous requests until the server can no longer keep up.
Specific conditions include
- Request Interval — 5 sec.
- Number of simultaneous requests — 10 cases (Gradually increase the number of measurements by 10 cases each.)
- Measurement Time — 60 sec.
With a 60-second duration and a 5-second interval, each thread sends 12 requests (60 ÷ 5).
1-3. Observed results
In the end, many people may be wondering about the conclusion of what specs the server can handle and how much it can handle.
| CPU: 2core memory: 1GB SSD: 50GB | Can handle up to 120 simultaneous requests |
|---|
These results describe only the tested request, configuration, and historical VPS environment. They are useful for understanding the observed bottleneck, not for sizing another system.
| CPU: 1core memory: 512MB SSD: 25GB | Up to 60 simultaneous requests can be handled |
|---|---|
| CPU: 2core memory: 1GB SSD: 50GB | Can handle up to 120 simultaneous requests |
| CPU: 3core memory: 2GB SSD: 100GB | Can handle up to 240 simultaneous requests |
In this specific test, the 1-core, 512 MB instance completed the scenario at roughly 60 concurrent clients before the selected failure threshold was reached.
2. Observed result details
The detailed measurements below show how that observation was derived.
2-1. Apache HTTP Server test
Repeated requests were thrown for pages created in HTML. It will be a simple page with no complex PHP processing or JavaScript.
The measurements yielded the following results.
- For 10 simultaneous requests⇒OK
- For 20 simultaneous requests⇒OK
- For 30 simultaneous requests⇒OK
- For 40 simultaneous requests⇒OK
- For 50 simultaneous requests⇒OK
- For 60 simultaneous requests⇒OK
- For 70 simultaneous requests⇒OK
- For 80 simultaneous requests⇒OK
- For 90 simultaneous requests⇒OK
- For 100 simultaneous requests⇒OK
- For 110 simultaneous requests⇒OK
- For 120 simultaneous requests⇒OK
- For 130 simultaneous requests⇒NG
An error occurred on the 130th case. The cause was a connection error to Apache. The status of the server at this time was as follows.
- CPU utilization — 26%
- memory utilization — 100%
The complete lack of memory was the bottleneck.
This is a bit geeky, but here is how Apache's Multi-Processing Module (MPM) is configured. MPM is simply a setting for how much Apache is allowed to process in parallel.
<IfModule mpm_prefork_module>
StartServers 5
MinSpareServers 5
MaxSpareServers 10
MaxRequestWorkers 250
MaxConnectionsPerChild 0
</IfModule>
The setting of interest is "250" for "MaxRequestWorkers". This is a setting for the maximum number of cases Apache can process at the same time. The maximum number of parallel processing is "250," so it seems that 250 cases can be processed in parallel, but looking at the memory usage, about 8 MB of memory was used per case.
It seemed to be using 960MB of memory (8M x 120 processes) and the setting value was "250", but it did not seem to be able to create more than "120" processes.
Note: The server's memory is almost at its maximum limit of 1G.
When actually operating the server, if PHP and Java are also included, the limit is about 100 cases, and if there is room, about 80 cases can be processed concurrently.
When only Apache is installed and running, I found that with the specifications "CPU: 2core, memory: 1GB, SSD: 50GB", the number of simultaneous accesses is limited to "120".
2-2. consideration
The measurements suggest that memory constrained the number of Apache workers in this environment. Additional memory might raise the limit, but that conclusion requires a new load test with the same workload and monitoring.
【present (memory1GB)】
- memory: 1GB
- Number of Apache threads: 120 cases
- Memory consumption per thread in Apache: 8MB
- Apache memory consumption: 960MB (120 cases×8MB)
【After change (memory2GB)】
- memory: 2GB
- Number of Apache threads: 240 cases
- Memory consumption per thread in Apache: 8MB
- Apache memory consumption: 1920MB (240 cases×8MB)
If memory is increased to 2GB, it would be possible to double the number of simultaneous parallel processing to about 240 cases. If the memory is increased to 3GB, more concurrent processing may be possible, but since the "MaxRequestWorkers (maximum number of concurrent processes)" of Apache's MPM is 250, further tuning may be necessary if the memory is increased further. On the other hand, if memory is cut in half, it would be as follows.
【After change (memory512GB)】
- memory: 512GB
- Number of Apache threads: 60 cases
- Memory consumption per thread in Apache: 8MB
- Apache memory consumption: 480MB (60 cases×8MB)
3. Conclusion
The historical Apache-only test reached its selected threshold at about 60 concurrent clients on a 1-core, 512 MB instance. This is not a claim that the configuration supports 60 real users or a production workload.
No competing application workload was included. Production sizing requires representative traffic, resource monitoring, failure criteria, and capacity headroom.
Official references
■INFORMATION
■PROFILE
■CONTACT