Ir al contenido
use-cases / run-a-local-llm-serve-it-to-your-fleet / hero
PIPE · LLM LOCAL · FAN-OUT

Ejecuta un LLM local y sírvelo a toda tu flota

Estás corriendo un modelo de 70B en una sola caja con GPU. Cincuenta contenedores aguas abajo de tu flota necesitan la misma respuesta para la misma consulta — están puntuando el mismo catálogo, generando los mismos embeddings, evaluando el mismo experimento. No pagues por cincuenta inferencias. Corre el modelo una vez, retransmite los tokens.

Leer la API de pipe
use-cases / run-a-local-llm-serve-it-to-your-fleet / mechanism

Una GPU, un pipe, cincuenta consumidores

La respuesta ingenua es un servidor HTTP con cola, batching de peticiones y contención de locks. La respuesta más barata para esta forma: cada consulta va a una ruta de pipe con ?n=50. El modelo corre una vez. Cincuenta contenedores consumidores hacen GET a la misma ruta y reciben los mismos tokens al mismo tiempo, abiertos en abanico por el pipe. Un worker lento aplica backpressure a su propia conexión — los demás siguen a velocidad de línea.

fleet-broadcast.sh
# 1× GPU box — run the model once and pipe its tokens upward.
llama.cpp -m llama3-70b.gguf -p "$PROMPT" --stream \
  | curl -T - https://pipe.hoody.com/api/v1/pipe/llm?n=50

# 50 consumer containers — same path, ?n=50, fanned out by the pipe.
for i in $(seq 1 50); do
  curl https://pipe.hoody.com/api/v1/pipe/llm?n=50 \
    | jq -c .delta \
    | ./score.py --worker $i &
done

# Sender blocks until 50 readers have connected, then bytes flow.
# Slow workers backpressure their own connection — others stay at line speed.

PUT envía bytes hacia arriba. GET los baja. El parámetro ?n=50 dice a cuántos lectores esperar; el pipe mantiene la conexión hasta que conectan tantos, luego abre el stream en abanico simultáneamente a todos. Sin cola, sin capa de batching, sin servidor-de-inferencia-con-load-balancer.

UNA INFERENCIA

El modelo corre exactamente una vez por consulta

cincuenta contenedores aguas abajo quieren la misma respuesta; tú la generas en la GPU una vez. El pipe se encarga de la entrega. Sin framework de batching de peticiones, sin capa de caché de tokens, sin coordinación de "por favor no lo vuelvas a ejecutar".

FAN-OUT DEL PIPE

?n=50 abre los mismos bytes en abanico a cincuenta lectores

el pipe se bloquea hasta que cincuenta receptores conectan, luego transmite los bytes del productor a cada uno en paralelo. Copias idénticas, entrega a velocidad de línea, cero almacenamiento en servidor. Hasta 256 receptores por ruta.

BACKPRESSURE POR RECEPTOR

Los workers lentos solo se ralentizan a sí mismos

si un contenedor consumidor está haciendo GC o su disco está ocupado, su conexión se retrasa. El pipe aplica backpressure a ese receptor — los otros 49 siguen transmitiendo a tope. Sin head-of-line blocking, sin tunear profundidad de cola.

TOPE DE FAN-OUT256Techo de receptores por ruta impuesto por el pipe — pon ?n para esperar a tantos antes de que la transferencia comience.
INFERENCIAS POR CONSULTA1El modelo corre una vez por consulta, no una vez por consumidor. El coste de cómputo se desacopla del tamaño de la flota.
HUELLA DE SDK0 kbEl productor es curl. Los consumidores son curl. Cualquier cosa que hable HTTP puede suscribirse — contenedor, agente, navegador, shell.
use-cases / run-a-local-llm-serve-it-to-your-fleet / economics

Por lo que dejas de pagar

Cuando cincuenta contenedores quieren la misma respuesta, las alternativas cobran por llamada, por token, o por servidor de inferencia. El pipe cobra por una transferencia HTTP. Corre el modelo en una caja que ya alquilas.

ANTESAPI hosted · facturación por token50× tokensBedrock o OpenAI te facturan por cincuenta completaciones idénticas cuando cincuenta contenedores hacen la misma pregunta. Mismo prompt, misma respuesta, cobrada cincuenta veces.
DESPUÉSModelo local · broadcast por pipe1× tokensLa caja con GPU que ya alquilas genera una vez. El pipe lleva los bytes a los cincuenta. La flota escala horizontalmente sin escalar la factura de inferencia.

esto no es para cualquier carga — es para la forma en la que N contenedores quieren la misma respuesta. Cuando esa es tu forma, el pipe es el fan-out más barato que vas a cablear. Cargas con prompts divergentes siguen queriendo un servidor de inferencia de verdad; este patrón brilla cuando la pregunta es idéntica y la flota es ancha.

use-cases / run-a-local-llm-serve-it-to-your-fleet / punchline

Una GPU, un pipe, cincuenta contenedores probando los mismos tokens.

0101 · UNA GPU GENERA LOS TOKENS
0202 · UN PIPE LOS LLEVA
0303 · CINCUENTA CONTENEDORES LOS PRUEBAN A LA VEZ
sin servicio de fan-out de inferenciala ruta es el broadcast
use-cases / run-a-local-llm-serve-it-to-your-fleet / replaces

Lo que esto reemplaza

Cada stack de "dale a mi flota acceso a un modelo" al que recurres cuando una consulta tiene que alimentar a muchos consumidores. Cada uno cobra por llamada, hospeda tus pesos, o te pide que corras un load balancer delante de vLLM. El pipe retransmite una vez.

  • AWS Lambda + BedrockFacturación por token × tamaño de flota, pesos que no son tuyos
  • Modal LabsRunners de GPU hosted, facturación por segundo por worker
  • ReplicatePrecio por llamada, ida-y-vuelta de red por consumidor
  • OpenAI API a escalaPrompt idéntico facturado una vez por consumidor
  • vLLM/TGI tras un load balancerServidor, cola, tunear batching, superficie ops que mantener viva
  • Gateways de modelo autoalojadosRouting, auth, rate limits — todo DIY para un fan-out
use-cases / run-a-local-llm-serve-it-to-your-fleet / cta

Deja de pagar cincuenta facturas de inferencia por una respuesta. Corre el modelo donde ya alquilas el silicio. Abre un pipe. Deja que la flota lea.

Leer la API de pipe
use-cases / run-a-local-llm-serve-it-to-your-fleet / related

Lee los otros