Sessenta contêineres em um servidor
Uma caixa bare-metal executa dezenas a centenas de contêineres Hoody. KSM e BTRFS dedup fazem o custo marginal próximo a zero.
Contêineres·Snapshots
TipoDesbloqueadoEstágioFrotaDificuldadeAvançadoTrabalhoImplantar uma APIParaConstrutores de IAParaEquipes de desenvolvimentoServiçosPipeServiçosDaemonPor que HoodyHTTP-nativoPor que HoodyEconomia de contêineresPor que HoodyNativo de IA
TipoDesbloqueadoEstágioFrotaDificuldadeAvançadoTrabalhoImplantar uma APIParaConstrutores de IAParaEquipes de desenvolvimentoServiçosPipeServiçosDaemonPor que HoodyHTTP-nativoPor que HoodyEconomia de contêineresPor que HoodyNativo de IA
use-cases / run-a-local-llm-serve-it-to-your-fleet / hero
PIPE · LOCAL LLM · FAN-OUT
Rode um LLM local e sirva-o à sua frota inteira
Você está rodando um modelo 70B em uma única caixa de GPU. Cinquenta contêineres downstream pela sua frota precisam da mesma resposta para a mesma query — estão pontuando o mesmo catálogo, gerando os mesmos embeddings, avaliando o mesmo experimento. Não pague por cinquenta inferências. Rode o modelo uma vez, faça broadcast dos tokens.
gpu-01.fleet.local · llama.cpp
EM EXECUÇÃORTX 409024 GB VRAMllama3-70b · q41× FONTE
PASSO 1 · MODELO
# generate once, pipe upwardllama.cpp -m llama3-70b.gguf \ -p "$PROMPT" --stream \ | curl -T - \ /pipe/llm?n=50PASSO 2 · PIPE
pipe/llm?n=50UM CAMINHO · CINQUENTA LEITORESfrota · 50 contêineres consumidores
n=50app-1
app-2
app-3
app-4
app-5
app-6
app-7
app-8
app-9
app-10
app-11
app-12
app-13
app-14
app-15
app-16
app-17
app-18
app-19
app-20
app-21
app-22
app-23
app-24
app-25
app-26
app-27
app-28
app-29
app-30
app-31
app-32
app-33
app-34
app-35
app-36
app-37
app-38
app-39
app-40
app-41
app-42
app-43
app-44
app-45
app-46
app-47
app-48
app-49
app-50
TODOS PROVANDO OS MESMOS TOKENSBACKPRESSURE POR CONEXÃO
o modelo roda uma vez · o pipe faz broadcast · workers lentos atrasam só a si mesmos
use-cases / run-a-local-llm-serve-it-to-your-fleet / mechanism
Uma GPU, um pipe, cinquenta consumidores
A resposta ingênua é um servidor HTTP com fila, batching de requisições e contenção de lock. A resposta mais barata para esse formato: cada query vai para um caminho de pipe com ?n=50. O modelo roda uma vez. Cinquenta contêineres consumidores fazem GET no mesmo caminho e recebem os mesmos tokens ao mesmo tempo, distribuídos pelo pipe. Um worker lento aplica backpressure só na própria conexão — os outros ficam na velocidade da linha.
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 manda bytes pra cima. GET puxa pra baixo. O parâmetro ?n=50 diz quantos leitores esperar; o pipe segura a conexão até essa quantidade conectar, e aí distribui o stream em fan-out simultaneamente para todos. Sem fila, sem camada de batching, sem servidor-de-inferência-com-load-balancer.
UMA INFERÊNCIA
O modelo roda exatamente uma vez por query
cinquenta contêineres downstream querem a mesma resposta; você gera ela na GPU uma vez. O pipe cuida da entrega. Sem framework de batching de requisições, sem camada de cache de tokens, sem coordenação de "por favor não rode de novo".
PIPE FAN-OUT
?n=50 distribui os mesmos bytes pra cinquenta leitores
o pipe bloqueia até cinquenta receivers conectarem, então transmite os bytes do produtor para cada um em paralelo. Cópias idênticas, entrega na velocidade da linha, zero armazenamento no servidor. Até 256 receivers por caminho.
BACKPRESSURE POR DESTINATÁRIO
Workers lentos atrasam só a si mesmos
se um contêiner consumidor está em GC ou seu disco está ocupado, a conexão dele atrasa. O pipe aplica backpressure naquele receiver — os outros 49 continuam transmitindo a toda velocidade. Sem head-of-line blocking, sem ajuste de profundidade de fila.
TETO DE FAN-OUT256Limite de receivers por caminho imposto pelo pipe — defina ?n para esperar essa quantidade antes da transferência começar.
INFERÊNCIAS POR QUERY1O modelo roda uma vez por query, não uma vez por consumidor. O custo de compute é desacoplado do tamanho da frota.
PEGADA DE SDK0 kbProdutor é curl. Consumidores são curl. Qualquer coisa que fale HTTP pode se inscrever — contêiner, agente, navegador, shell.
use-cases / run-a-local-llm-serve-it-to-your-fleet / economics
O que você deixa de pagar
Quando cinquenta contêineres querem a mesma resposta, as alternativas cobram por chamada, por token ou por servidor de inferência. O pipe cobra por uma transferência HTTP. Rode o modelo numa caixa que você já aluga.
ANTESAPI hospedada · cobrança por token50× tokensBedrock ou OpenAI cobram por cinquenta completions idênticos quando cinquenta contêineres fazem a mesma pergunta. Mesmo prompt, mesma resposta, cobrado cinquenta vezes.
DEPOISModelo local · broadcast pelo pipe1× tokensA caixa de GPU que você já aluga gera uma vez. O pipe carrega os bytes pros cinquenta. A frota escala horizontalmente sem escalar a conta de inferência.
isso não é toda carga de trabalho — é o formato em que N contêineres querem a mesma resposta. Quando esse é seu formato, o pipe é o fan-out mais barato que você vai cabear. Cargas com prompts divergentes ainda querem um servidor de inferência de verdade; esse padrão brilha quando a pergunta é idêntica e a frota é larga.
use-cases / run-a-local-llm-serve-it-to-your-fleet / punchline
Uma GPU, um pipe, cinquenta contêineres provando os mesmos tokens.
0101 · UMA GPU GERA OS TOKENS
0202 · UM PIPE OS CARREGA
0303 · CINQUENTA CONTÊINERES PROVAM AO MESMO TEMPO
sem serviço de fan-out de inferênciao caminho é o broadcast
use-cases / run-a-local-llm-serve-it-to-your-fleet / replaces
O que isso substitui
Toda stack de "dê acesso a um modelo pra minha frota" que você procura quando uma query precisa alimentar muitos consumidores. Cada uma cobra por chamada, hospeda seus pesos ou pede pra você rodar um load balancer na frente do vLLM. O pipe faz broadcast uma vez.
- AWS Lambda + BedrockCobrança por token × tamanho da frota, pesos que você não tem
- Modal LabsRunners de GPU hospedados, cobrança por segundo por worker
- ReplicatePreço por chamada, round-trip de rede por consumidor
- OpenAI API em escalaPrompt idêntico cobrado uma vez por consumidor
- vLLM/TGI atrás de um load balancerServidor, fila, ajuste de batching, superfície de ops pra manter de pé
- Gateways de modelo self-hostedRoteamento, auth, rate limits — tudo DIY pra um fan-out só
use-cases / run-a-local-llm-serve-it-to-your-fleet / cta
Pare de pagar cinquenta contas de inferência por uma resposta. Rode o modelo onde você já aluga o silício. Abra um pipe. Deixe a frota ler.
use-cases / run-a-local-llm-serve-it-to-your-fleet / related
Leia os outros
