11-10-2026

Roadrunner: el servidor php de alto rendimiento

RoadRunner es un servidor de aplicaciones PHP de alto rendimiento, escrito en Go y potenciado por plugins. Actúa como process manager y load balancer, manteniendo un pool de workers PHP persistentes en memoria.
En lugar de arrancar PHP desde cero en cada request, como hace FPM, los workers se inician una sola vez y reutilizan el estado de la aplicación entre peticiones. El resultado es un salto enorme en rendimiento, menor latencia y un uso más eficiente de recursos.

Características principales

Servidor HTTP/1.1, HTTP/2, HTTP/3 y FastCGI compatible con PSR-7/PSR-17
Sistema de colas con drivers para RabbitMQ, Kafka, SQS, Beanstalk, NATS…
Soporte nativo para gRPC, workflows y WebSockets
Supervisión automática de workers
Métricas Prometheus, OpenTelemetry y hot-reload
Arquitectura de plugins extremadamente flexible

Instalación rápida

La forma más sencilla de empezar es usando Composer:

# Dependencias PHP
composer require spiral/roadrunner-http nyholm/psr7

# CLI para descargar el binario de RoadRunner
composer require spiral/roadrunner-cli --dev

# Descargar el binario compatible con tu sistema
vendor/bin/rr get

También se puede descargar el binario precompilado desde GitHub Releases o usar la imagen oficial de Docker "ghcr.io/roadrunner-server/roadrunner". La extensión sockets de PHP debe estar activada.

Configuración básica

Es necesario crear un archivo llamado ".rr.yaml" en la raíz del proyecto:

version: "3"

server:
  command: "php psr-worker.php"
  # Opcional: límites de supervisión
  # relay: pipes
  # relay_timeout: 60s

http:
  address: 0.0.0.0:8080
  # middleware: ["gzip", "headers"]
  # max_request_size: 256

logs:
  level: error          # en desarrollo puedes poner debug
  mode: production

Worker simple en PHP

Crear el archivo "psr-worker.php":

require __DIR__ . '/vendor/autoload.php';

use Nyholm\Psr7\Response;
use Nyholm\Psr7\Factory\Psr17Factory;
use Spiral\RoadRunner\Worker;
use Spiral\RoadRunner\Http\PSR7Worker;

$worker = Worker::create();
$factory = new Psr17Factory();
$psr7 = new PSR7Worker($worker, $factory, $factory, $factory);

while (true) {
    try {
        $request = $psr7->waitRequest();
        if ($request === null) {
            break; // RoadRunner se está apagando
        }
    } catch (\Throwable $e) {
        $psr7->respond(new Response(400));
        continue;
    }

    try {
        // Aquí va tu aplicación (Laravel, Symfony, Slim, PHP puro…)
        $psr7->respond(new Response(200, [], '¡Hola desde RoadRunner!'));
    } catch (\Throwable $e) {
        $psr7->respond(new Response(500, [], 'Error interno'));
        // Opcional: notificar error al supervisor
        // $psr7->getWorker()->error((string) $e);
    }
}

Arrancar el servidor:

./rr serve

Con esto el servidor PHP de alto rendimiento escuchando en el puerto 8080 ya está listo.

RoadRunner vs FrankenPHP vs Swoole

Aspecto	RoadRunner	FrankenPHP	Swoole / OpenSwoole
Lenguaje base	Go	C (basado en Caddy)	C (extensión PHP)
Modelo	Workers persistentes aislados	Workers + modo clásico	Coroutines + event loop
Estabilidad	Muy alta (aislamiento fuerte)	Alta	Media-alta (cuidado con estado)
Colas y plugins	Excelente (Jobs, Temporal…)	Más limitado	Bueno pero menos maduro
Facilidad de despliegue	Binario + YAML	Un solo binario	Extensión PECL
Mejor para	Apps empresariales, migraciones, estabilidad	Contenedores, simplicidad	Real-time, I/O intensivo

RoadRunner destaca especialmente por su estabilidad y por el modelo de aislamiento de procesos: si un worker se corrompe o tiene un memory leak, el resto sigue funcionando y RoadRunner lo reinicia de forma controlada.

Ventajas reales

Eliminación casi total del tiempo de bootstrap
Mucho mejor rendimiento en aplicaciones con frameworks pesados
Supervisión profesional de workers
Sistema de colas integrado muy potente
Ideal para microservicios, APIs de alto tráfico y aplicaciones empresariales
Configuración clara y versionable en YAML