Performance Comparison: PHP, Node.js, Go, and Rust at 10,000 Requests/s

Benchmarking backend languages is crucial for high-traffic apps. This blog compares PHP, Node.js, Go, and Rust when handling 10,000 requests per second using tools like wrk, ab, and k6. Let’s dive into their performance, scalability, and resource usage.

Why Benchmark?

High-traffic apps demand speed and efficiency. Benchmarking helps:

• Identify the fastest language for your use case.
• Optimize resource usage (CPU, memory).
• Ensure scalability under load.

We’ll test a simple REST API endpoint returning { "message": "Hello, World!" } with 10,000 requests/s.

Setup

• Hardware: 4-core CPU, 8GB RAM, Ubuntu 20.04.
• Tools: wrk, ab, k6.
• Test: 10,000 requests/s for 30 seconds, 10 concurrent connections.

Implementations

1. PHP (Laravel)

PHP is widely used for web apps. We use Laravel for a lightweight API.

// routes/api.php
Route::get('/hello', function () {
    return response()->json(['message' => 'Hello, World!']);
});

Run with php artisan serve --host=0.0.0.0 --port=8000.

2. Node.js (Express)

Node.js excels in asynchronous I/O. We use Express for simplicity.

const express = require('express')
const app = express()

app.get('/hello', (req, res) => {
  res.json({ message: 'Hello, World!' })
})

app.listen(3000, () => console.log('Node.js on port 3000'))

3. Go (Gin)

Go is known for concurrency and speed. We use the Gin framework.

package main

import "github.com/gin-gonic/gin"

func main() {
    r := gin.Default()
    r.GET("/hello", func(c *gin.Context) {
        c.JSON(200, gin.H{"message": "Hello, World!"})
    })
    r.Run(":8080")
}

4. Rust (Actix)

Rust prioritizes safety and performance. We use Actix for a fast API.

use actix_web::{get, App, HttpResponse, HttpServer};

#[get("/hello")]
async fn hello() -> HttpResponse {
    HttpResponse::Ok().json(serde_json::json!({"message": "Hello, World!"}))
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| App::new().service(hello))
        .bind("0.0.0.0:8081")?
        .run()
        .await
}

Benchmarking

Tool: wrk

Install wrk: sudo apt-get install wrk

Run test:

wrk -t10 -c10 -d30s http://localhost:8000/hello

Results

• Rust: Fastest, lowest resource usage, thanks to zero-cost abstractions.
• Go: Close to Rust, excellent concurrency with goroutines.
• Node.js: Strong for async tasks but higher memory usage.
• PHP: Slower, higher CPU load, but still viable for simpler apps.

Tool: k6

k6 provides detailed metrics. Install: sudo apt-key adv ... (follow k6 docs).

Run test:

import http from 'k6/http'
import { sleep } from 'k6'

export let options = {
  vus: 10,
  duration: '30s',
}

export default function () {
  http.get('http://localhost:8080/hello')
  sleep(0.1)
}

k6 confirmed similar trends: Rust and Go outperformed PHP and Node.js in throughput and latency.

Key Takeaways

• Rust: Best for maximum performance and low resource usage. Steeper learning curve.
• Go: Balances simplicity and speed. Ideal for rapid development.
• Node.js: Great for async-heavy apps but less efficient under extreme load.
• PHP: Reliable for traditional web apps, less suited for ultra-high traffic.

Best Practices

• Optimize: Use caching (e.g., Redis) to reduce load.
• Scale: Deploy with Docker and Kubernetes for horizontal scaling.
• Monitor: Track performance with tools like Prometheus.
• Test Locally: Simulate real-world loads with wrk or k6.

Conclusion

For 10,000 requests/s, Rust and Go lead in performance, while Node.js and PHP are easier to start with but lag under heavy load. Choose based on your team’s expertise and project needs. Benchmark your specific use case to confirm!

Ready to optimize your backend? Start testing today!