Roadrunner Laravel Package

Product Decisions This Supports

• Architecture Modernization:

  • Replace legacy Nginx + PHP-FPM setups with a unified, high-performance PHP application server (RoadRunner) to reduce infrastructure complexity and improve scalability.
  • Enable microservices decomposition by leveraging RoadRunner’s gRPC, HTTP/3, and WebSocket support for inter-service communication.

• Performance Optimization:

  • Reduce latency via HTTP/2/3, 103 Early Hints, and gzip compression middleware, critical for real-time applications (e.g., dashboards, live feeds).
  • Offload queue processing (RabbitMQ, Kafka, SQS) from web workers to dedicated RoadRunner jobs, improving responsiveness.

• Observability & Reliability:

  • Built-in OpenTelemetry integration for distributed tracing (gRPC, HTTP, Jaeger) to debug microservices.
  • Metrics server (Prometheus) and distributed locks for resource contention in multi-instance deployments.

• Cost Efficiency:

  • Eliminate Nginx licensing (if applicable) and reduce server footprint by consolidating HTTP, queues, and RPC under RoadRunner.
  • Lower cloud costs via efficient process management (auto-restarts, execution time limits).

• Roadmap Priorities:

  • Phase 1: Migrate monolithic Laravel APIs to RoadRunner for performance gains.
  • Phase 2: Adopt Temporal workflows for long-running business processes (e.g., order fulfillment).
  • Phase 3: Replace Beanstalkd with RoadRunner’s Kafka/SQS plugins for horizontal scaling.

• Build vs. Buy:

  • Buy: RoadRunner’s plugin ecosystem (e.g., Centrifugo for WebSockets) avoids reinventing wheels for real-time features.
  • Build: Custom middleware/plugins for domain-specific needs (e.g., rate limiting, JWT validation).

When to Consider This Package

Adopt RoadRunner If:

✅ You’re using Laravel/Symfony and want to eliminate Nginx/FPM for lower latency and simpler deployments. ✅ Your app has mixed workloads (HTTP + queues + gRPC) and needs unified process management. ✅ You require HTTP/3, WebSockets, or real-time features (e.g., chat, live updates) without adding Nginx/PHP-FPM overhead. ✅ Observability is critical—RoadRunner’s OpenTelemetry + Prometheus integration reduces tooling sprawl. ✅ You’re deploying on Kubernetes—RoadRunner’s lightweight design and plugin isolation align with cloud-native principles. ✅ Your team lacks DevOps resources—RoadRunner’s auto-restarts, health checks, and systemd-like service management reduce operational toil.

Look Elsewhere If:

❌ Your stack is purely serverless (e.g., AWS Lambda + API Gateway)—RoadRunner adds unnecessary complexity. ❌ You need Windows-specific features (RoadRunner is Go-based; Windows support is secondary). ❌ Your app is static—use Nginx/Varnish or Cloudflare Workers instead. ❌ You’re locked into a non-PSR-7 framework (e.g., legacy Zend, old Symfony 2)—RoadRunner requires PSR-15 middleware. ❌ Your team lacks Go/PHP interop experience—RoadRunner’s plugin system requires basic configuration knowledge.

How to Pitch It (Stakeholders)

For Executives:

"RoadRunner lets us replace our bloated Nginx+FPM stack with a single, high-performance PHP server—cutting costs, reducing latency, and enabling real-time features like WebSockets and gRPC. It’s like upgrading from a sedan to a hypercar for our backend, with the added bonus of built-in observability and queue processing. Early adopters (e.g., [Company X]) saw 30% faster API responses and 40% lower cloud bills by consolidating their infrastructure."

Key Outcomes:

• Faster time-to-market for real-time features (e.g., live dashboards).
• Lower ops costs—no more tuning Nginx/PHP-FPM.
• Future-proof—supports HTTP/3, WebSockets, and microservices out of the box.

For Engineering:

**"RoadRunner is a drop-in replacement for PHP-FPM that gives us:

• HTTP/3, gRPC, and WebSockets without Nginx hacks.
• Built-in queues (RabbitMQ, Kafka, SQS) to offload background jobs from web workers.
• OpenTelemetry for distributed tracing—no more stitching together New Relic + custom logs.
• Plugins for everything: Temporal workflows, Centrifugo (WebSockets), and even a metrics server.

Migration Path:

1. Phase 1: Replace PHP-FPM with RoadRunner for HTTP routes (1–2 weeks).
2. Phase 2: Move queues to RoadRunner jobs (parallel effort).
3. Phase 3: Adopt gRPC for internal services (3–4 weeks).

Trade-offs:

• Learning curve: Go-based config (.rr.yaml) and plugin system.
• Debugging: Some PHP errors may surface differently (e.g., worker crashes vs. FPM timeouts).

Try It Out:

composer require spiral/roadrunner-cli
./vendor/bin/rr get-binary
./rr serve -c .rr.yaml

Docs: roadrunner.dev | Slack: Spiral Framework

For DevOps/SRE:

**"RoadRunner simplifies our infrastructure by:

• Eliminating Nginx (no more config sync, TLS management, or proxy tuning).
• Auto-restarts and health checks—like systemd but for PHP workers.
• Built-in metrics (Prometheus) and distributed locks for multi-instance setups.

Deployment Example (Docker):

FROM php:8.3-cli
COPY --from=ghcr.io/roadrunner-server/roadrunner:2025.X.X /usr/bin/rr /usr/local/bin/rr
CMD [\"rr\", \"serve\", \"-c\", \"/app/.rr.yaml\"]

Monitoring: Expose /metrics endpoint via RoadRunner’s prometheus middleware.

Alert: Watch for SIGUSR2 signal support for graceful config reloads (v2025.1.5+)."