roadrunner-server/roadrunner

Features

• PHP Application Servers - Acts as a high-performance application server using a persistent worker model to eliminate PHP bootload overhead.
• Worker Pool Models - Maintains a pool of persistent worker processes to eliminate PHP bootload overhead and manage resource recycling.
• HTTP Request Handlers - Processes incoming web requests using compliant workers to route traffic to application logic.
• Task Queues - Manages the consumption of tasks from queues, including completion marking and requeueing logic.
• Key-Value Stores - Provides high-performance key-value storage for persisting small amounts of application state across requests.
• Application Framework Integrations - Provides a mechanism to connect PHP application frameworks to a high-performance process manager via standard interfaces.
• Background Job Processing - Processes and manages asynchronous tasks and background jobs offloaded from the main request flow.
• Background Job Queues - Consumes tasks from various message brokers to execute asynchronous background work.
• Task Queue Management - Provides tools to create, pause, and resume background task queues to control processing flow.
• Broadcast Messaging - Supports real-time message broadcasting to push updates to WebSocket clients instantly.
• WebSocket Servers - Maintains persistent bi-directional WebSocket connections between the server and clients for real-time data exchange.
• gRPC Interfaces - Processes binary gRPC requests and routes them to worker processes for high-performance execution.
• Protocol-Agnostic Proxies - Routes diverse traffic types including HTTP/3, gRPC, and FastCGI to a unified worker execution model.
• Pipe-Based Communication - Exchanges request and response payloads between the Go server and PHP workers using standard pipes.
• Inter-Process Communication Configuration - Configures the data exchange method between the server and workers using standard pipes or sockets.
• Process Persistence - Eliminates bootload time by keeping application processes alive between requests.
• Worker Payload Exchange - Communicates with worker scripts via pipes or sockets to exchange request and response payloads.
• Durable Workflow Engines - Orchestrates durable, stateful business processes by integrating with an external Temporal engine.
• Asynchronous Task Queueing - Offloads long-running tasks to background workers to prevent blocking the main request thread.
• Modular Plugin Architectures - Implements a modular architecture allowing the server to be extended via independent Go plugins and a shared event bus.
• Application Observability - Implements application observability by exporting metrics, logs, and traces via the OpenTelemetry standard.
• Application Performance Monitoring - Provides comprehensive observability into system health using OpenTelemetry for metrics, traces, and logging.
• Distributed Tracing - Implements distributed tracing via OpenTelemetry to track requests across different system components.
• Telemetry Collectors - Collects and exports telemetry data across HTTP, gRPC, and job components using the OpenTelemetry standard.
• Process Supervision - Monitors application health and performs soft resets of workers based on resource and time limits.
• Worker Process Tuning - Supervises a pool of PHP worker processes with automatic restarts and execution time limits.
• Worker Lifecycle Management - Manages the full lifecycle of PHP CLI processes, including allocation, release, and destruction of workers.
• gRPC Service Implementations - Implements high-performance gRPC binary servers for efficient communication between distributed services.
• Real-Time Communication - Supports persistent bidirectional WebSocket connections for real-time data exchange and push updates.
• Message Brokers - Integrates with distributed messaging systems using the AMQP protocol for secure queue management.
• Task Queues and Background Jobs - Integrates with Beanstalk to pull and process background tasks from remote or local work queues.
• Application Metrics Collection - Submits application performance data to external monitoring systems via language-agnostic interfaces.
• Stream Processing - Consumes and manages Kafka messages to build real-time data pipelines and event processing.
• Distributed Caching - Implements distributed caching for web responses to improve retrieval speeds across multiple nodes.
• In-Memory Queues - Provides high-performance task queuing in volatile memory to avoid external broker dependencies.
• Response Output Caching - Caches final rendered HTTP responses to reduce server-side processing burden and improve page load times.
• Workflow Engine Integrations - Integrates with an external engine to manage complex, long-running business processes and stateful workflows.
• RPC Method Extensions - Enables the registration of custom RPC methods within plugins to expose internal server logic.
• GitOps Deployment Management - Automates server deployment to Kubernetes using GitOps tools like Argo CD and Helm charts.
• Docker Container Deployments - Packages the application server and environment into Docker images for consistent deployment.
• Plugin-Extensible Runtimes - Implements a runtime that allows core server logic and process management to be extended via custom plugins.
• Go Implementations - Enables the creation of custom server capabilities and middleware using Go plugins.
• Request Queuing Systems - Buffers incoming requests in an internal queue to manage worker assignment and allocation timeouts.
• Worker Monitoring Interfaces - Provides real-time monitoring of active workers, including PIDs, memory usage, and execution counts.
• Server Configuration Management - Parses YAML and JSON files and integrates environment variables to control server behavior at runtime.
• Serverless Runtime Management - Enables executing PHP applications within AWS Lambda by managing a pool of reusable workers.
• Systemd Services - Integrates with systemd to manage the application process as a background service.
• Batch Dispatching - Increases throughput by sending multiple tasks to a queue in a single delivery.
• Worker Pool Management - Allows dynamic tuning of worker pool sizes via RPC to optimize system resources at runtime.
• Worker Scaling - Dynamically adjusts the number of active worker processes based on demand to optimize resource usage.
• Middleware-Based Request Pipelines - Implements modular chains of pluggable components to intercept and process HTTP and gRPC requests.
• Method Invocation - Exposes a remote procedure call interface to trigger embedded services for worker and configuration management.
• HTTP/2 Support - Implements HTTP/2 protocol features including H2C and resource pushing via response headers.
• HTTP/3 Implementations - Supports the HTTP/3 protocol and automates TLS certificate management via ACME providers.
• NATS Integrations - Integrates with NATS JetStream to process asynchronous tasks through a managed pool of workers.
• TCP Server Management - Runs a high-performance server to manage custom networking requirements using raw TCP connections.
• Pub-Sub Systems - Integrates with Google Pub/Sub to process events and parallelize tasks via a publisher-subscriber model.
• Cache Management Interfaces - Provides an RPC interface for external applications to perform cache operations on the server.
• TCP Proxies - Proxies incoming raw TCP connections to stateless workers for bidirectional data exchange.
• TCP and UDP Forwarders - Handles raw TCP requests and routes them to the appropriate application logic.
• Asynchronous RPC Execution - Enables non-blocking execution of remote procedure calls to improve performance and concurrency.
• Framework Adapters - Connects the application server to PHP frameworks to manage state and process execution.
• Mutual TLS Authentication - Enforces mutual TLS authentication by verifying client certificates during the gRPC handshake.
• Execution Isolation - Isolates worker processes by launching them under specific system users and groups.
• TLS Certificate Management - Automates the acquisition and renewal of TLS certificates via Let's Encrypt.
• Process Control Interfaces - Exposes RPC interfaces enabling external applications to manage worker pools, cache, and server configurations.
• External State Connectors - Interfaces with external key-value stores and message brokers to manage shared data and job queues.
• Durable Workflow Execution Engines - Executes stateful workflows and stateless activities by integrating with a durable workflow engine.
• Sidecar Task Delegation - Integrates with external engines to manage stateful, long-running business processes via sidecar task delegation.
• Background Job Monitoring - Provides detailed observability into background job pipelines, including readiness and active task counts.
• Centralized Logging Systems - Unifies output streams by sending log messages from application workers to the central server.
• Application Log Routing - Directs captured application logs to various output formats and destinations.
• Channel-Based Routing - Provides granular control over log data by assigning specific levels and destinations to individual plugins.
• Application Logging - Captures log messages from server components and worker error streams for centralized output.
• gRPC Probing - Implements a built-in health checking service following the gRPC protocol to report server state.
• Health Monitoring Endpoints - Exposes standardized health check endpoints for orchestrators to verify operational status.
• Prometheus Exporters - Includes an embedded Prometheus-compatible server for collecting and exposing performance metrics.
• Prometheus-Based Metric Exporters - Collects custom application-level metrics via RPC and exports them in Prometheus format.
• System Health Monitors - Tracks and reports the operational health and status of various internal system components.
• Worker Resource Recycling - Restarts worker processes automatically based on memory limits or job counts to prevent resource leaks.
• Worker Execution Supervision - Enforces execution time limits and resource thresholds to automatically recycle worker processes.
• Reverse Proxies - Acts as a reverse proxy that accepts forwarded web traffic to facilitate load balancing and caching.
• Response Streaming - Supports incremental delivery of large HTTP response bodies using strings or generators.
• FastCGI Gateways - Implements a FastCGI gateway allowing web servers to communicate directly with PHP worker processes.
• HTTP Request Interceptors - Provides middleware to intercept and modify incoming HTTP requests and responses for authentication and rate limiting.
• Laravel Server Integrations - Integrates the server with the Laravel framework to optimize state management and process execution.
• Middleware Pipelines - Executes a sequence of independent middleware components to transform incoming requests and outgoing responses.
• Request Routing - Directs incoming requests to different handlers based on the request mode defined in environment variables.
• Server Process Management - Manages the lifecycle of the server process including startup, stopping, and crash recovery via signals.
• Worker Live Reloading - Restarts worker processes automatically after every request to reflect code changes instantly.
• Static Asset Serving - Delivers static assets from the filesystem using a dedicated plugin or HTTP middleware.
• Application Servers - High-performance server, load balancer, and process manager.

Star history