DEV Community

Cover image for Unlock Go's HTTP Potential: See Our Performance Benchmarks ✨
Evilmagics
Evilmagics

Posted on

Unlock Go's HTTP Potential: See Our Performance Benchmarks ✨

#programming #go #api #performance

Performance is a critical factor when choosing an HTTP framework for Go applications. This comprehensive benchmark study evaluates six popular Go HTTP frameworks across different workload scenarios to provide data-driven insights for framework selection. Think of it as a scientific experiment, but instead of lab rats, we're testing HTTP handlers! 🔬

Framework Comparison Overview 📊

This benchmark evaluates the following Go HTTP frameworks - our contestants in this digital gladiator arena:

Active Test Subjects 🥊

  • Net/Http - Go's standard library HTTP package (go1.24.3) 📚
  • Gin - Lightweight HTTP web framework (v1.10.1) 🍸
  • Fiber - Express-inspired web framework (v2.52.8) ⚡
  • GoFr - Modern Go framework (v1.42.1) 🐹
  • Beego - Full-featured web framework (v2.3.8) 🐝
  • Echo - High performance, minimalist framework (v4.13.4) 🔊

Planned for Future Testing 🚧

  • Chi - Lightweight router 🔗
  • Gorilla Mux - Powerful HTTP router 🦍
  • Fasthttp - High-performance HTTP server 🏎️
  • HttpRouter - High performance HTTP request router 🛤️
  • Goji - Minimalistic web framework 🎋

Testing Methodology 🔬

Like any good scientific experiment, we need a controlled environment. No lab coats required, but we did wear our lucky debugging socks! 🧦

Hardware Environment 💻

  • CPU: Intel(R) Core(TM) i5-12500H @ 2.50GHz
  • RAM: 16GB
  • OS: Windows 11

Software Tools 🛠️

Our digital weapons of choice:

  • Go v1.24.3 - Runtime environment 🏃
  • Bombardier v1.2.6 - Primary load testing tool 💣
  • Go-wrk v0.9 - Secondary benchmarking tool 🔨
  • Vegeta v12.12.0 - HTTP load testing tool (Attack mode: ON) 🥷

Test Scenarios 🎯

The benchmark includes three distinct workload patterns - think of them as different difficulty levels in a video game:

1. Hello World Endpoint 👋

Tests basic routing and response generation with minimal processing overhead. The "tutorial level" of HTTP handlers - if you can't handle this, you probably shouldn't be serving HTTP traffic!

# Basic traffic test
benchmark.sh -c 100 -r 10000 -d 30 -t 3 -m "GET" -o "results/summary_${TARGET_NAME}_hello_world_basic.txt" "${TARGET_BASE}/hello-world"

# High traffic test
benchmark.sh -c 1000 -r 100000 -d 30 -t 3 -m GET -o "results/summary_${TARGET_NAME}_hello_world_high_traffic.txt" "${TARGET_BASE}/hello-world"
Enter fullscreen mode Exit fullscreen mode

2. Structured Response Endpoint 🏗️

Evaluates JSON serialization performance and framework overhead. Now we're getting into the real world - because let's be honest, nobody builds applications that only return "Hello World".

# Basic traffic test
benchmark.sh -c 100 -r 10000 -d 30 -t 3 -m GET -o "results/summary_${TARGET_NAME}_structured_responses_basic.txt" "${TARGET_BASE}/structured-messages"

# High traffic test
benchmark.sh -c 1000 -r 100000 -d 30 -t 3 -m GET -o "results/summary_${TARGET_NAME}_structured_responses_high_traffic.txt" "${TARGET_BASE}/structured-messages"
Enter fullscreen mode Exit fullscreen mode

3. Large Process Endpoint 🏋️

Tests POST request handling and computational workload processing. This is where we separate the frameworks from the toys - the "boss level" of our benchmark.

# Basic traffic test
benchmark.sh -c 100 -r 10000 -d 30 -t 15 -m POST -o "results/summary_${TARGET_NAME}_large_process_basic.txt" "${TARGET_BASE}/large-process"

# High traffic test
benchmark.sh -c 1000 -r 100000 -d 30 -t 15 -m POST -o "results/summary_${TARGET_NAME}_large_process_high_traffic.txt" "${TARGET_BASE}/large-process"
Enter fullscreen mode Exit fullscreen mode

Traffic Patterns 🚦

  • Small Traffic: 10,000 requests with 100 concurrent connections (A gentle warm-up) 🚶
  • High Traffic: 100,000 requests with 1,000 concurrent connections (The real stress test) 🏃‍♂️

Key Performance Metrics 📈

  • Average Requests/Second: Mean request processing rate ⚡
  • Peak Requests/Second: Maximum observed request rate 🚀
  • Success Rate: Percentage of successful HTTP responses ✅
  • Average Latency: Mean response time in milliseconds ⏱️
  • Throughput: Data transfer rate in MB/s 📊

Benchmark Results Analysis 📊

Time for the main event! Performance graph jump to Performance Analysis.Let's see how our contestants performed in this digital colosseum:

Fiber Framework 🚀

Fiber demonstrates exceptional performance across all test scenarios, particularly excelling in high-throughput environments. It's like the sports car of HTTP frameworks - fast, sleek, and impressive at parties.

Performance Characteristics:

  • Hello-World Basic: 100% success rate, 0.94ms average latency
  • High Traffic: 96% success rate, peak performance of 3.2M req/sec

Net/Http (Standard Library) 📚

The standard library shows remarkably competitive performance, maintaining high success rates under load. Sometimes the best solution is the one that was there all along - who would have thought?

Performance Characteristics:

  • Hello-World Basic: 100% success rate, 1.32ms average latency
  • High Traffic: 92% success rate, 10.99ms average latency

Echo Framework 🔊

Echo provides consistent performance with excellent stability under varying load conditions. The reliable workhorse that just keeps delivering without drama.

Performance Characteristics:

  • Hello-World Basic: 100% success rate, 2.53ms average latency
  • High Traffic: 95% success rate, 11.71ms average latency

Gin Framework 🍸

Gin shows adequate performance for moderate traffic but experiences significant degradation under heavy load. Great for cocktail parties, less great for rock concerts.

Performance Characteristics:

  • Hello-World Basic: 100% success rate, 6.07ms average latency
  • High Traffic: 42% success rate under high load

Beego Framework 🐝

Beego maintains reasonable performance for basic operations but shows increased latency under load. Like a busy bee - works hard but gets overwhelmed when the hive gets too active.

Performance Characteristics:

  • Hello-World Basic: 100% success rate, 1.89ms average latency
  • High Traffic: 75% success rate, 15.36ms average latency

GoFr Framework 🐹

GoFr shows the highest latency in basic scenarios and significant performance degradation under load. Still finding its groove in the performance game - everyone starts somewhere!

Performance Characteristics:

  • Hello-World Basic: 100% success rate, 14.62ms average latency
  • High Traffic: 22.5% success rate

Performance Analysis 🔍

Request Total

Request total chart

Fiber tends to handle requests consistently during less demanding processes. This allows Fiber to receive more requests quickly. Echo and Net/Http also offer stable and fast performance, but in some cases, Fiber handles them better.

Request/seconds

Request per second chart

In relatively standard processing cases (<50ms), all libraries delivered stable performance when handling requests. Fiber, Gin GoFr, and Net/Http appeared to struggle with heavy-duty requests, resulting in a drastic drop in requests received per second.

Success Rate

Success rate chart

Heavy processing results in Fiber and Gin failing to process incoming requests. There is a high probability of a timeout when processing goroutines. Meanwhile, GoFr and Net/Http managed to process about 10% of the total incoming requests. Congratulations! Beego and Echo still managed to process almost all incoming requests with good performance.

Latency

Latency chart

Echo and Beego tend to provide relatively small latency compared to their competitors which are more than 1000ms for heavy processes. While for standard and small processes, Fiber and Net/Http provide relatively low latency.

Key Findings 💡

  1. Raw Performance Leader: Fiber consistently outperforms other frameworks in throughput and latency metrics. It's the Usain Bolt of HTTP frameworks! 🏃‍♂️

  2. Standard Library Strength: Net/Http proves highly competitive, often matching or exceeding framework performance. Never underestimate the power of simplicity! 💪

  3. Stability Under Load: Echo maintains the most consistent performance across different traffic patterns. The tortoise that actually wins the race! 🐢

  4. Load Sensitivity: Success rates generally decrease under high traffic, with some frameworks showing significant degradation. Even the strongest servers have their breaking point! 😅

  5. Latency Patterns: Response times increase substantially under high load conditions across all frameworks. Physics still applies in the digital world! ⚖️

Framework Selection Guidelines 🎯

High-Performance Applications 🏎️

For applications requiring maximum throughput and minimal latency, Fiber or Net/Http are optimal choices. Fiber provides the best raw performance, while Net/Http offers excellent performance with standard library reliability. Choose Fiber if you want to brag about your RPS numbers at meetups!

Production Stability 🛡️

For applications prioritizing reliability and consistent performance, Echo provides the best balance of performance and stability. Net/Http is also suitable for applications where framework features are less critical. Sometimes boring is beautiful! 😌

Feature-Rich Applications 🎨

For applications requiring extensive framework features and middleware support, Beego and Gin offer comprehensive functionality, though with performance trade-offs. Remember: more features often mean more overhead - choose wisely!

Development Considerations 🤔

When choosing a framework, consider:

  • Team familiarity with the framework (developer happiness matters!) 😊
  • Available middleware and ecosystem 🔧
  • Long-term maintenance requirements 🔄
  • Specific performance requirements 📊

Configuration Details ⚙️

Server Configuration 🌐 

HostHttp = "0.0.0.0:6000"
HostGin = "0.0.0.0:6001"
HostFiber = "0.0.0.0:6002"
HostGoFr = "0.0.0.0:6003"
HostBeego = "0.0.0.0:6004"
HostEcho = "0.0.0.0:6005"
Enter fullscreen mode Exit fullscreen mode

Running Test Servers 🏃‍♂️ 

# Net/Http
source ./scripts/run.sh -n "net-http" -b "http://127.0.0.1:6000"

# Gin
source ./scripts/run.sh -n "gin" -b "http://127.0.0.1:6001"

# Fiber
source ./scripts/run.sh -n "fiber" -b "http://127.0.0.1:6002"

# GoFr
source ./scripts/run.sh -n "gofr" -b "http://127.0.0.1:6003"

# Beego
source ./scripts/run.sh -n "beego" -b "http://127.0.0.1:6004"

# Echo
source ./scripts/run.sh -n "echo" -b "http://127.0.0.1:6005"
Enter fullscreen mode Exit fullscreen mode

Conclusion 🎯

This benchmark provides data-driven insights into Go HTTP framework performance characteristics. The results demonstrate that framework selection should balance raw performance requirements with development productivity and application complexity needs.

Key Takeaways: 📝

  • Fiber excels in high-performance scenarios 🚀
  • Net/Http provides excellent performance without external dependencies 📚
  • Echo offers the best stability-performance balance ⚖️
  • Framework choice should align with specific application requirements and team capabilities 🎯

Future benchmark iterations will include additional frameworks and real-world application scenarios to provide more comprehensive performance insights. Because let's be honest, there's always room for more data! 📊

All benchmark scripts and detailed results are available in the project repository for independent verification and testing in different environments. Happy benchmarking! 🚀

Top comments (0)